5.6 Binary arithmetic operations
The binary arithmetic operations have the conventional priority levels. Note that some
of these operations also apply to certain nonnumeric types. Apart from the power
operator, there are only two levels, one for multiplicative operators and one for additive
operators:

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) 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
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 absolute value of the second operand^{5.1}.
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 numbers; there similar identities hold
approximately where x/y is replaced by floor(x/y) or floor(x/y)
 1 ^{5.2}.
Deprecated since release 2.3. The floor division operator, the modulo operator,
and the divmod() function are no longer defined for complex
numbers. Instead, convert to a floating point number using the abs()
function if appropriate.
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.
Footnotes
 ... operand^{5.1}
 While
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 doubleprecision number, in order that 1e100 %
1e100 have the same sign as 1e100 , the computed result is 1e100
+ 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 1e100
in this case. Which approach is more appropriate depends on the application.
 ... 1^{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 (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 .
