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 operators:
* (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
% (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
x == (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
floor(x/y) - 15.2.
+ (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
- (subtraction) operator yields the difference of its
arguments. The numeric arguments are first converted to a common
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
-1e-100 % 1e100have the same sign as
1e100, the computed result is
-1e-100 + 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
-1e-100in this case. Which approach is more appropriate depends on the application.
floor(x/y)to be one larger than
(x-x%y)/ydue to rounding. In such cases, Python returns the latter result, in order to preserve that
divmod(x,y) * y + x % ybe very close to