subclass of the ABC. (This class method is called from the
:meth:`~class.__subclasscheck__` method of the ABC.)
- This method should return ``True``, ``False`` or ``NotImplemented``. If
+ This method should return ``True``, ``False`` or :data:`NotImplemented`. If
it returns ``True``, the *subclass* is considered a subclass of this ABC.
If it returns ``False``, the *subclass* is not considered a subclass of
this ABC, even if it would normally be one. If it returns
- ``NotImplemented``, the subclass check is continued with the usual
+ :data:`!NotImplemented`, the subclass check is continued with the usual
mechanism.
.. XXX explain the "usual mechanism"
the other type; may be returned by the in-place binary special methods
(e.g. :meth:`~object.__imul__`, :meth:`~object.__iand__`, etc.) for the same purpose.
It should not be evaluated in a boolean context.
- ``NotImplemented`` is the sole instance of the :data:`types.NotImplementedType` type.
+ :data:`!NotImplemented` is the sole instance of the :data:`types.NotImplementedType` type.
.. note::
- When a binary (or in-place) method returns ``NotImplemented`` the
+ When a binary (or in-place) method returns :data:`!NotImplemented` the
interpreter will try the reflected operation on the other type (or some
other fallback, depending on the operator). If all attempts return
- ``NotImplemented``, the interpreter will raise an appropriate exception.
- Incorrectly returning ``NotImplemented`` will result in a misleading
- error message or the ``NotImplemented`` value being returned to Python code.
+ :data:`!NotImplemented`, the interpreter will raise an appropriate exception.
+ Incorrectly returning :data:`!NotImplemented` will result in a misleading
+ error message or the :data:`!NotImplemented` value being returned to Python code.
See :ref:`implementing-the-arithmetic-operations` for examples.
.. note::
- ``NotImplementedError`` and ``NotImplemented`` are not interchangeable,
+ ``NotImplementedError`` and :data:`!NotImplemented` are not interchangeable,
even though they have similar names and purposes.
See :exc:`NotImplementedError` for details on when to use it.
.. versionchanged:: 3.9
- Evaluating ``NotImplemented`` in a boolean context is deprecated. While
+ Evaluating :data:`!NotImplemented` in a boolean context is deprecated. While
it currently evaluates as true, it will emit a :exc:`DeprecationWarning`.
It will raise a :exc:`TypeError` in a future version of Python.
.. note::
- ``NotImplementedError`` and ``NotImplemented`` are not interchangeable,
+ ``NotImplementedError`` and :data:`NotImplemented` are not interchangeable,
even though they have similar names and purposes. See
- :data:`NotImplemented` for details on when to use it.
+ :data:`!NotImplemented` for details on when to use it.
.. exception:: OSError([arg])
OSError(errno, strerror[, filename[, winerror[, filename2]]])
when invalidating the caches of all finders on :data:`sys.meta_path`.
.. versionchanged:: 3.4
- Returns ``None`` when called instead of ``NotImplemented``.
+ Returns ``None`` when called instead of :data:`NotImplemented`.
.. class:: PathEntryFinder
2. If ``A`` falls back to the boilerplate code, and it were to
return a value from :meth:`~object.__add__`, we'd miss the possibility
that ``B`` defines a more intelligent :meth:`~object.__radd__`, so the
- boilerplate should return :const:`NotImplemented` from
+ boilerplate should return :data:`NotImplemented` from
:meth:`!__add__`. (Or ``A`` may not implement :meth:`!__add__` at
all.)
3. Then ``B``'s :meth:`~object.__radd__` gets a chance. If it accepts
Special reducer that can be defined in :class:`Pickler` subclasses. This
method has priority over any reducer in the :attr:`dispatch_table`. It
should conform to the same interface as a :meth:`~object.__reduce__` method, and
- can optionally return ``NotImplemented`` to fallback on
+ can optionally return :data:`NotImplemented` to fallback on
:attr:`dispatch_table`-registered reducers to pickle ``obj``.
For a detailed example, see :ref:`reducer_override`.
The following types can be pickled:
* built-in constants (``None``, ``True``, ``False``, ``Ellipsis``, and
- ``NotImplemented``);
+ :data:`NotImplemented`);
* integers, floating-point numbers, complex numbers;
For those cases, it is possible to subclass from the :class:`Pickler` class and
implement a :meth:`~Pickler.reducer_override` method. This method can return an
arbitrary reduction tuple (see :meth:`~object.__reduce__`). It can alternatively return
-``NotImplemented`` to fallback to the traditional behavior.
+:data:`NotImplemented` to fallback to the traditional behavior.
If both the :attr:`~Pickler.dispatch_table` and
:meth:`~Pickler.reducer_override` are defined, then
This object is returned from comparisons and binary operations when they are
asked to operate on types they don't support. See :ref:`comparisons` for more
-information. There is exactly one ``NotImplemented`` object.
-``type(NotImplemented)()`` produces the singleton instance.
+information. There is exactly one :data:`NotImplemented` object.
+:code:`type(NotImplemented)()` produces the singleton instance.
-It is written as ``NotImplemented``.
+It is written as :code:`NotImplemented`.
.. _typesinternal:
Methods and their defaults:
-* ``__lt__``: ``NotImplemented``
-* ``__gt__``: ``NotImplemented``
-* ``__le__``: ``NotImplemented``
-* ``__ge__``: ``NotImplemented``
+* ``__lt__``: :data:`NotImplemented`
+* ``__gt__``: :data:`!NotImplemented`
+* ``__le__``: :data:`!NotImplemented`
+* ``__ge__``: :data:`!NotImplemented`
* ``__int__``: ``1``
* ``__contains__``: ``False``
* ``__len__``: ``0``
.. index:: pair: object; NotImplemented
This type has a single value. There is a single object with this value. This
-object is accessed through the built-in name ``NotImplemented``. Numeric methods
+object is accessed through the built-in name :data:`NotImplemented`. Numeric methods
and rich comparison methods should return this value if they do not implement the
operation for the operands provided. (The interpreter will then try the
reflected operation, or some other fallback, depending on the operator.) It
for more details.
.. versionchanged:: 3.9
- Evaluating ``NotImplemented`` in a boolean context is deprecated. While
+ Evaluating :data:`NotImplemented` in a boolean context is deprecated. While
it currently evaluates as true, it will emit a :exc:`DeprecationWarning`.
It will raise a :exc:`TypeError` in a future version of Python.
``x.__ne__(y)``, ``x>y`` calls ``x.__gt__(y)``, and ``x>=y`` calls
``x.__ge__(y)``.
- A rich comparison method may return the singleton ``NotImplemented`` if it does
+ A rich comparison method may return the singleton :data:`NotImplemented` if it does
not implement the operation for a given pair of arguments. By convention,
``False`` and ``True`` are returned for a successful comparison. However, these
methods can return any value, so if the comparison operator is used in a Boolean
:func:`bool` on the value to determine if the result is true or false.
By default, ``object`` implements :meth:`__eq__` by using ``is``, returning
- ``NotImplemented`` in the case of a false comparison:
+ :data:`NotImplemented` in the case of a false comparison:
``True if x is y else NotImplemented``. For :meth:`__ne__`, by default it
delegates to :meth:`__eq__` and inverts the result unless it is
- ``NotImplemented``. There are no other implied relationships among the
+ :data:`!NotImplemented`. There are no other implied relationships among the
comparison operators or default implementations; for example, the truth of
``(x<y or x==y)`` does not imply ``x<=y``. To automatically generate ordering
operations from a single root operation, see :func:`functools.total_ordering`.
Called to implement :func:`operator.length_hint`. Should return an estimated
length for the object (which may be greater or less than the actual length).
The length must be an integer ``>=`` 0. The return value may also be
- :const:`NotImplemented`, which is treated the same as if the
+ :data:`NotImplemented`, which is treated the same as if the
``__length_hint__`` method didn't exist at all. This method is purely an
optimization and is never required for correctness.
function is to be supported.
If one of those methods does not support the operation with the supplied
- arguments, it should return ``NotImplemented``.
+ arguments, it should return :data:`NotImplemented`.
.. method:: object.__radd__(self, other)
types. [#]_ For instance, to evaluate the expression ``x - y``, where *y* is
an instance of a class that has an :meth:`__rsub__` method,
``type(y).__rsub__(y, x)`` is called if ``type(x).__sub__(x, y)`` returns
- *NotImplemented*.
+ :data:`NotImplemented`.
.. index:: pair: built-in function; pow
the behavior that ``None`` is not callable.
.. [#] "Does not support" here means that the class has no such method, or
- the method returns ``NotImplemented``. Do not set the method to
+ the method returns :data:`NotImplemented`. Do not set the method to
``None`` if you want to force fallback to the right operand's reflected
method—that will instead have the opposite effect of explicitly
*blocking* such fallback.
``x == x`` are all false, while ``x != x`` is true. This behavior is
compliant with IEEE 754.
-* ``None`` and ``NotImplemented`` are singletons. :PEP:`8` advises that
+* ``None`` and :data:`NotImplemented` are singletons. :PEP:`8` advises that
comparisons for singletons should always be done with ``is`` or ``is not``,
never the equality operators.
(Added by Raymond Hettinger; :issue:`1818`.)
Finally, the :class:`~collections.abc.Mapping` abstract base class now
- returns :const:`NotImplemented` if a mapping is compared to
+ returns :data:`NotImplemented` if a mapping is compared to
another type that isn't a :class:`Mapping`.
(Fixed by Daniel Stutzbach; :issue:`8729`.)
:meth:`~object.__index__` method).
(Contributed by Serhiy Storchaka in :issue:`37999`.)
-* If :func:`object.__ipow__` returns :const:`NotImplemented`, the operator will
+* If :func:`object.__ipow__` returns :data:`NotImplemented`, the operator will
correctly fall back to :func:`object.__pow__` and :func:`object.__rpow__` as expected.
(Contributed by Alex Shkop in :issue:`38302`.)
PEP written and implemented by Łukasz Langa.
:func:`~functools.total_ordering` now supports a return value of
-:const:`NotImplemented` from the underlying comparison function. (Contributed
+:data:`NotImplemented` from the underlying comparison function. (Contributed
by Katie Miller in :issue:`10042`.)
A pure-python version of the :func:`~functools.partial` function is now in the
``logging.getLogger(__name__)`` in some top-level module called ``'root.py'``.
(Contributed by Vinay Sajip in :issue:`37742`.)
-* Division handling of :class:`~pathlib.PurePath` now returns ``NotImplemented``
+* Division handling of :class:`~pathlib.PurePath` now returns :data:`NotImplemented`
instead of raising a :exc:`TypeError` when passed something other than an
instance of ``str`` or :class:`~pathlib.PurePath`. This allows creating
compatible classes that don't inherit from those mentioned types.
.. nonce: hsCNgX
.. section: Core and Builtins
-If :func:`object.__ipow__` returns :const:`NotImplemented`, the operator
+If :func:`object.__ipow__` returns :data:`NotImplemented`, the operator
will correctly fall back to :func:`object.__pow__` and
:func:`object.__rpow__` as expected.
.. section: Core and Builtins
Parameter substitution of the union type with wrong types now raises
-``TypeError`` instead of returning ``NotImplemented``.
+``TypeError`` instead of returning :data:`NotImplemented`.
..
projects / thirdparty / Python / cpython.git / commitdiff
