The binary arithmetic operations have the conventional priority levels. Note that some of these operations also apply to certain non-numeric types. There is no ``power'' operator, so 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 | aexpr "+" m_expr | aexpr "-" m_expr
The "*"
(multiplication) operator yields the product of its
arguments. The arguments must either both be numbers, or one argument
must be a plain integer 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.
The "/"
(division) operator yields the quotient of its
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.
ZeroDivisionError
The "%"
(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. 3.14 % 0.7
equals 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 second operand.
The integer division and modulo operators are connected by the
following identity: 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 a similar identity holds where
x/y
is replaced by floor(x/y)
).
The "+"
(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.
The "-"
(subtraction) operator yields the difference of its
arguments. The numeric arguments are first converted to a common
type.