5.6 Binary arithmetic operations
The binary arithmetic operations have the conventional priority levels. Note that some
of these operations also apply to certain non-numeric types. Apart from the power
operator, there are only two levels, one for multiplicative operators and one for additive
* (multiplication) operator yields the product of its arguments. The
arguments must either both be numbers, or one argument must be an integer (plain or long)
and the other must be a sequence. In the former case, the numbers are converted to a
common type and then multiplied together. In the latter case, sequence repetition is
performed; a negative repetition factor yields an empty sequence.
/ (division) and
// (floor division) operators yield the
quotient of their arguments. The numeric arguments are first converted to a common type.
Plain or long integer division yields an integer of the same type; the result is that of
mathematical division with the `floor' function applied to the result. Division by zero
raises the ZeroDivisionError exception.
% (modulo) operator yields the remainder from the division of the
first argument by the second. The numeric arguments are first converted to a common type.
A zero right argument raises the ZeroDivisionError exception.
The arguments may be floating point numbers, e.g.,
4*0.7 + 0.34.) The modulo operator always
yields a result with the same sign as its second operand (or zero); the absolute value of
the result is strictly smaller than the absolute value of the second operand5.1.
The integer division and modulo operators are connected by the following identity:
== (x/y)*y + (x%y). Integer division and modulo are also connected with the
built-in function divmod():
divmod(x, y) == (x/y, x%y).
These identities don't hold for floating point numbers; there similar identities hold
x/y is replaced by
Deprecated since release 2.3. The floor division operator, the modulo operator,
and the divmod() function are no longer defined for complex
numbers. Instead, convert to a floating point number using the abs()
function if appropriate.
+ (addition) operator yields the sum of its arguments. The arguments
must either both be numbers or both sequences of the same type. In the former case, the
numbers are converted to a common type and then added together. In the latter case, the
sequences are concatenated.
- (subtraction) operator yields the difference of its arguments. The
numeric arguments are first converted to a common type.
- ... operand5.1
abs(x%y) < abs(y) is true mathematically, for floats it may
not be true numerically due to roundoff. For example, and assuming a platform on which
a Python float is an IEEE 754 double-precision number, in order that
1e100 have the same sign as
1e100, the computed result is
+ 1e100, which is numerically exactly equal to
1e100. Function fmod() in the math module returns a
result whose sign matches the sign of the first argument instead, and so returns
in this case. Which approach is more appropriate depends on the application.
- ... 15.2
- If x is very close to an exact integer multiple of y, it's possible for
to be one larger than
(x-x%y)/y due to rounding. In such cases, Python
returns the latter result, in order to preserve that
divmod(x,y) * y + x % y
be very close to