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 operators:

- Download entire grammar as text.

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 built-in 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.

- ... floats),
^{5.2} -
If x is very close to an exact integer multiple of y, it's
possible for
`floor(x/y)`

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)[0] * y + x % y`

be very close to`x`

.