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:
|m_expr||::=||u_expr | m_expr "*" u_expr | m_expr "//" u_expr | m_expr "/" u_expr|
|a_expr||::=||m_expr | a_expr "+" m_expr | a_expr "-" m_expr|
* (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.2.
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.3.
In addition to performing the modulo operation on numbers, the
operator is also overloaded by string and unicode objects to perform
string formatting (also known as interpolation). The syntax for string
formatting is described in the
Python Library Reference,
section ``Sequence Types''.
+ (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
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