

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 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.
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.
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
(since
3.14
equals 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 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 builtin function divmod():
divmod(x, y) == (x/y, x%y)
. These identities don't hold for
floating point and complex numbers; there similar identities hold
approximately where x/y
is replaced by floor(x/y)
) or
floor(x/y)  1
(for floats),^{5.2} or floor((x/y).real)
(for
complex).
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.
floor(x/y)
to be one larger than
(xx%y)/y
due to rounding. In such cases, Python returns
the latter result, in order to preserve that divmod(x,y)[0]
* y + x % y
be very close to x
.