new-style class
Any class which inherits from :class:`object`. This includes all built-in
types like :class:`list` and :class:`dict`. Only new-style classes can
- use Python's newer, versatile features like :attr:`__slots__`,
+ use Python's newer, versatile features like :attr:`~object.__slots__`,
descriptors, properties, and :meth:`__getattribute__`.
More information can be found in :ref:`newstyle`.
type
The type of a Python object determines what kind of object it is; every
object has a type. An object's type is accessible as its
- :attr:`__class__` attribute or can be retrieved with ``type(obj)``.
+ :attr:`~instance.__class__` attribute or can be retrieved with
+ ``type(obj)``.
universal newlines
A manner of interpreting text streams in which all of the following are
Future statements are specified by bits which can be bitwise ORed together to
specify multiple statements. The bitfield required to specify a given feature
- can be found as the :attr:`compiler_flag` attribute on the :class:`_Feature`
- instance in the :mod:`__future__` module.
+ can be found as the :attr:`~__future__._Feature.compiler_flag` attribute on
+ the :class:`~__future__._Feature` instance in the :mod:`__future__` module.
This function raises :exc:`SyntaxError` if the compiled source is invalid,
and :exc:`TypeError` if the source contains null bytes.
One useful application of the second form of :func:`iter` is to read lines of
a file until a certain line is reached. The following example reads a file
- until the :meth:`readline` method returns an empty string::
+ until the :meth:`~io.TextIOBase.readline` method returns an empty string::
with open('mydata.txt') as fp:
for line in iter(fp.readline, ''):
turns the :meth:`voltage` method into a "getter" for a read-only attribute
with the same name.
- A property object has :attr:`getter`, :attr:`setter`, and :attr:`deleter`
- methods usable as decorators that create a copy of the property with the
- corresponding accessor function set to the decorated function. This is
- best explained with an example::
+ A property object has :attr:`~property.getter`, :attr:`~property.setter`,
+ and :attr:`~property.deleter` methods usable as decorators that create a
+ copy of the property with the corresponding accessor function set to the
+ decorated function. This is best explained with an example::
class C(object):
def __init__(self):
Return a :term:`slice` object representing the set of indices specified by
``range(start, stop, step)``. The *start* and *step* arguments default to
- ``None``. Slice objects have read-only data attributes :attr:`start`,
- :attr:`stop` and :attr:`step` which merely return the argument values (or their
- default). They have no other explicit functionality; however they are used by
- Numerical Python and other third party extensions. Slice objects are also
- generated when extended indexing syntax is used. For example:
- ``a[start:stop:step]`` or ``a[start:stop, i]``. See :func:`itertools.islice`
- for an alternate version that returns an iterator.
+ ``None``. Slice objects have read-only data attributes :attr:`~slice.start`,
+ :attr:`~slice.stop` and :attr:`~slice.step` which merely return the argument
+ values (or their default). They have no other explicit functionality;
+ however they are used by Numerical Python and other third party extensions.
+ Slice objects are also generated when extended indexing syntax is used. For
+ example: ``a[start:stop:step]`` or ``a[start:stop, i]``. See
+ :func:`itertools.islice` for an alternate version that returns an iterator.
.. function:: sorted(iterable[, cmp[, key[, reverse]]])
been overridden in a class. The search order is same as that used by
:func:`getattr` except that the *type* itself is skipped.
- The :attr:`__mro__` attribute of the *type* lists the method resolution
- search order used by both :func:`getattr` and :func:`super`. The attribute
- is dynamic and can change whenever the inheritance hierarchy is updated.
+ The :attr:`~class.__mro__` attribute of the *type* lists the method
+ resolution search order used by both :func:`getattr` and :func:`super`. The
+ attribute is dynamic and can change whenever the inheritance hierarchy is
+ updated.
If the second argument is omitted, the super object returned is unbound. If
the second argument is an object, ``isinstance(obj, type)`` must be true. If
With three arguments, return a new type object. This is essentially a
dynamic form of the :keyword:`class` statement. The *name* string is the
- class name and becomes the :attr:`__name__` attribute; the *bases* tuple
- itemizes the base classes and becomes the :attr:`__bases__` attribute;
+ class name and becomes the :attr:`~class.__name__` attribute; the *bases* tuple
+ itemizes the base classes and becomes the :attr:`~class.__bases__` attribute;
and the *dict* dictionary is the namespace containing definitions for class
- body and becomes the :attr:`__dict__` attribute. For example, the
+ body and becomes the :attr:`~object.__dict__` attribute. For example, the
following two statements create identical :class:`type` objects:
>>> class X(object):
.. function:: vars([object])
- Return the :attr:`__dict__` attribute for a module, class, instance,
+ Return the :attr:`~object.__dict__` attribute for a module, class, instance,
or any other object with a :attr:`__dict__` attribute.
Objects such as modules and instances have an updateable :attr:`__dict__`
There are currently two built-in set types, :class:`set` and :class:`frozenset`.
The :class:`set` type is mutable --- the contents can be changed using methods
-like :meth:`add` and :meth:`remove`. Since it is mutable, it has no hash value
-and cannot be used as either a dictionary key or as an element of another set.
-The :class:`frozenset` type is immutable and :term:`hashable` --- its contents
-cannot be altered after it is created; it can therefore be used as a dictionary
-key or as an element of another set.
+like :meth:`~set.add` and :meth:`~set.remove`. Since it is mutable, it has no
+hash value and cannot be used as either a dictionary key or as an element of
+another set. The :class:`frozenset` type is immutable and :term:`hashable` ---
+its contents cannot be altered after it is created; it can therefore be used as
+a dictionary key or as an element of another set.
As of Python 2.7, non-empty sets (not frozensets) can be created by placing a
comma-separated list of elements within braces, for example: ``{'jack',
foo`` does not require a module object named *foo* to exist, rather it requires
an (external) *definition* for a module named *foo* somewhere.)
-A special attribute of every module is :attr:`__dict__`. This is the dictionary
-containing the module's symbol table. Modifying this dictionary will actually
-change the module's symbol table, but direct assignment to the :attr:`__dict__`
-attribute is not possible (you can write ``m.__dict__['a'] = 1``, which defines
-``m.a`` to be ``1``, but you can't write ``m.__dict__ = {}``). Modifying
-:attr:`__dict__` directly is not recommended.
+A special attribute of every module is :attr:`~object.__dict__`. This is the
+dictionary containing the module's symbol table. Modifying this dictionary will
+actually change the module's symbol table, but direct assignment to the
+:attr:`__dict__` attribute is not possible (you can write
+``m.__dict__['a'] = 1``, which defines ``m.a`` to be ``1``, but you can't write
+``m.__dict__ = {}``). Modifying :attr:`__dict__` directly is not recommended.
Modules built into the interpreter are written like this: ``<module 'sys'
(built-in)>``. If loaded from a file, they are written as ``<module 'os' from
This method can be overridden by a metaclass to customize the method
resolution order for its instances. It is called at class instantiation, and
- its result is stored in :attr:`__mro__`.
+ its result is stored in :attr:`~class.__mro__`.
.. method:: class.__subclasses__
These represent a mutable set. They are created by the built-in :func:`set`
constructor and can be modified afterwards by several methods, such as
- :meth:`add`.
+ :meth:`~set.add`.
Frozen sets
.. index:: object: frozenset
:ref:`yield`) is called a :dfn:`generator
function`. Such a function, when called, always returns an iterator object
which can be used to execute the body of the function: calling the iterator's
- :meth:`next` method will cause the function to execute until it provides a value
+ :meth:`~iterator.next` method will cause the function to execute until
+ it provides a value
using the :keyword:`yield` statement. When the function executes a
:keyword:`return` statement or falls off the end, a :exc:`StopIteration`
exception is raised and the iterator will have reached the end of the set of
Special attributes: :attr:`__name__` is the class name; :attr:`__module__` is
the module name in which the class was defined; :attr:`__dict__` is the
- dictionary containing the class's namespace; :attr:`__bases__` is a tuple
- (possibly empty or a singleton) containing the base classes, in the order of
- their occurrence in the base class list; :attr:`__doc__` is the class's
- documentation string, or None if undefined.
+ dictionary containing the class's namespace; :attr:`~class.__bases__` is a
+ tuple (possibly empty or a singleton) containing the base classes, in the
+ order of their occurrence in the base class list; :attr:`__doc__` is the
+ class's documentation string, or None if undefined.
Class instances
.. index::
single: __dict__ (instance attribute)
single: __class__ (instance attribute)
- Special attributes: :attr:`__dict__` is the attribute dictionary;
- :attr:`__class__` is the instance's class.
+ Special attributes: :attr:`~object.__dict__` is the attribute dictionary;
+ :attr:`~instance.__class__` is the instance's class.
Files
.. index::
single: stop (slice object attribute)
single: step (slice object attribute)
- Special read-only attributes: :attr:`start` is the lower bound; :attr:`stop` is
- the upper bound; :attr:`step` is the step value; each is ``None`` if omitted.
- These attributes can have any type.
+ Special read-only attributes: :attr:`~slice.start` is the lower bound;
+ :attr:`~slice.stop` is the upper bound; :attr:`~slice.step` is the step
+ value; each is ``None`` if omitted. These attributes can have any type.
Slice objects support one method:
the emulation only be implemented to the degree that it makes sense for the
object being modelled. For example, some sequences may work well with retrieval
of individual elements, but extracting a slice may not make sense. (One example
-of this is the :class:`NodeList` interface in the W3C's Document Object Model.)
+of this is the :class:`~xml.dom.NodeList` interface in the W3C's Document
+Object Model.)
.. _customization:
:pep:`3119` - Introducing Abstract Base Classes
Includes the specification for customizing :func:`isinstance` and
- :func:`issubclass` behavior through :meth:`__instancecheck__` and
- :meth:`__subclasscheck__`, with motivation for this functionality in the
- context of adding Abstract Base Classes (see the :mod:`abc` module) to the
- language.
+ :func:`issubclass` behavior through :meth:`~class.__instancecheck__` and
+ :meth:`~class.__subclasscheck__`, with motivation for this functionality
+ in the context of adding Abstract Base Classes (see the :mod:`abc`
+ module) to the language.
.. _callable-types:
is also recommended that mappings provide the methods :meth:`keys`,
:meth:`values`, :meth:`items`, :meth:`has_key`, :meth:`get`, :meth:`clear`,
:meth:`setdefault`, :meth:`iterkeys`, :meth:`itervalues`, :meth:`iteritems`,
-:meth:`pop`, :meth:`popitem`, :meth:`copy`, and :meth:`update` behaving similar
+:meth:`pop`, :meth:`popitem`, :meth:`!copy`, and :meth:`update` behaving similar
to those for Python's standard dictionary objects. The :mod:`UserDict` module
provides a :class:`DictMixin` class to help create those methods from a base set
of :meth:`__getitem__`, :meth:`__setitem__`, :meth:`__delitem__`, and
is already executing raises a :exc:`ValueError` exception.
.. index:: exception: StopIteration
+.. class:: generator
.. method:: generator.next()
exits without yielding another value, a :exc:`StopIteration` exception is
raised.
+.. class:: .
.. method:: generator.send(value)
conversion of the lone slice item is the key. The conversion of a slice item
that is an expression is that expression. The conversion of an ellipsis slice
item is the built-in ``Ellipsis`` object. The conversion of a proper slice is a
-slice object (see section :ref:`types`) whose :attr:`start`, :attr:`stop` and
-:attr:`step` attributes are the values of the expressions given as lower bound,
-upper bound and stride, respectively, substituting ``None`` for missing
-expressions.
+slice object (see section :ref:`types`) whose :attr:`~slice.start`,
+:attr:`~slice.stop` and :attr:`~slice.step` attributes are the values of the
+expressions given as lower bound, upper bound and stride, respectively,
+substituting ``None`` for missing expressions.
.. index::
projects / python / commitdiff