 |
 |
 |
Python Reference Manual |  |
 |
 |
|
|
|
Python Reference Manual | |
|
|
The following methods can be defined to emulate numeric objects. Methods corresponding to operations that are not supported by the particular kind of number implemented (e.g., bitwise operations for non-integral numbers) should be left undefined.
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other[, modulo]) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
+,
-, *, //, %,
divmod(),
pow(), **, <<,
>>, &, ^, |). For instance, to
evaluate the expression x+y, where x is an
instance of a class that has an __add__() method,
x.__add__(y) is called. The __divmod__()
method should be the equivalent to using __floordiv__() and
__mod__(); it should not be related to __truediv__()
(described below). Note that
__pow__() should be defined to accept an optional third
argument if the ternary version of the built-in
pow() function is to be supported.
If one of those methods does not support the operation with the
supplied arguments, it should return NotImplemented.
| self, other) |
| self, other) |
/) is implemented by these methods. The
__truediv__() method is used when __future__.division
is in effect, otherwise __div__() is used. If only one of
these two methods is defined, the object will not support division in
the alternate context; TypeError will be raised instead.
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
+,
-, *, /, %,
divmod(),
pow(), **, <<,
>>, &, ^, |) with reflected
(swapped) operands. These functions are only called if the left
operand does not support the corresponding operation and the
operands are of different types.3.3
For instance, to evaluate the expression x-y,
where y is an instance of a class that has an
__rsub__() method, y.__rsub__(x)
is called if x.__sub__(y) returns
NotImplemented.
Note that ternary pow() will not try calling __rpow__() (the coercion rules would become too complicated).
Note: If the right operand's type is a subclass of the left operand's type and that subclass provides the reflected method for the operation, this method will be called before the left operand's non-reflected method. This behavior allows subclasses to override their ancestors' operations.
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other[, modulo]) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
| self, other) |
+=, -=, *=, /=, //=,
%=, **=, <<=, >>=, &=,
^=, |=). These methods should attempt to do the
operation in-place (modifying self) and return the result (which
could be, but does not have to be, self). If a specific method
is not defined, the augmented operation falls back to the normal
methods. For instance, to evaluate the expression
x+=y, where x is an instance of a class that
has an __iadd__() method, x.__iadd__(y) is
called. If x is an instance of a class that does not define a
__iadd__() method, x.__add__(y) and
y.__radd__(x) are considered, as with the
evaluation of x+y.
| self) |
| self) |
| self) |
| self) |
-,
+, abs() and ~).
| self) |
| self) |
| self) |
| self) |
| self) |
| self) |
| self) |
| self, other) |
None if conversion is impossible. When
the common type would be the type of other, it is sufficient to
return None, since the interpreter will also ask the other
object to attempt a coercion (but sometimes, if the implementation of
the other type cannot be changed, it is useful to do the conversion to
the other type here). A return value of NotImplemented is
equivalent to returning None.
|
|
|
Python Reference Manual | |
|
|