3.4 Numeric Types 
int, float, long, complex
There are four distinct numeric types: plain integers,
long integers,
floating point numbers, and complex numbers.
In addition, Booleans are a subtype of plain integers.
Plain integers (also just called integers)
are implemented using long in C, which gives them at least 32
bits of precision (sys.maxint is always set to the maximum
plain integer value for the current platform, the minimum value is
sys.maxint  1 ). Long integers have unlimited precision.
Floating point numbers are implemented using double in C.
All bets on their precision are off unless you happen to know the
machine you are working with.
Complex numbers have a real and imaginary part, which are each
implemented using double in C. To extract these parts from
a complex number z, use z.real and z.imag .
Numbers are created by numeric literals or as the result of builtin
functions and operators. Unadorned integer literals (including hex
and octal numbers) yield plain integers unless the value they denote
is too large to be represented as a plain integer, in which case
they yield a long integer. Integer literals with an
"L" or "l" suffix yield long integers
("L" is preferred because "1l" looks too much like
eleven!). Numeric literals containing a decimal point or an exponent
sign yield floating point numbers. Appending "j" or
"J" to a numeric literal yields a complex number with a
zero real part. A complex numeric literal is the sum of a real and
an imaginary part.
Python fully supports mixed arithmetic: when a binary arithmetic
operator has operands of different numeric types, the operand with the
``narrower'' type is widened to that of the other, where plain
integer is narrower than long integer is narrower than floating point is
narrower than complex.
Comparisons between numbers of mixed type use the same rule.^{3.2} The constructors int(), long(), float(),
and complex() can be used
to produce numbers of a specific type.
All numeric types (except complex) support the following operations,
sorted by ascending priority (operations in the same box have the same
priority; all numeric operations have a higher priority than
comparison operations):
Operation 
Result 
Notes 
x + y 
sum of x and y 

x  y 
difference of x and y 

x * y 
product of x and y 

x / y 
quotient of x and y 
(1) 
x // y 
(floored) quotient of x and y 
(5) 
x % y 
remainder of x / y 
(4) 
x 
x negated 

+x 
x unchanged 

abs(x) 
absolute value or magnitude of x 

int(x) 
x converted to integer 
(2) 
long(x) 
x converted to long integer 
(2) 
float(x) 
x converted to floating point 

complex(re,im) 
a complex number with real part re, imaginary part im. im defaults to zero. 

c.conjugate() 
conjugate of the complex number c 

divmod(x, y) 
the pair (x // y, x % y) 
(3)(4) 
pow(x, y) 
x to the power y 

x ** y 
x to the power y 

Notes:
 (1)
 For (plain or long) integer division, the result is an integer.
The result is always rounded towards minus infinity: 1/2 is 0,
(1)/2 is 1, 1/(2) is 1, and (1)/(2) is 0. Note that the result
is a long integer if either operand is a long integer, regardless of
the numeric value.
 (2)
 Conversion from floating point to (long or plain) integer may round or
truncate as in C; see functions floor() and
ceil() in the math module
for welldefined conversions.
 (3)
 See section 2.1, ``Builtin Functions,'' for a full
description.
 (4)
 Complex floor division operator, modulo operator, and divmod().
Deprecated since release 2.3.
Instead convert to float using abs()
if appropriate.
 (5)
 Also referred to as integer division. The resultant value is a whole integer,
though the result's type is not necessarily int.
Footnotes
 ... rule.^{3.2}

As a consequence, the list
[1, 2] is considered equal
to [1.0, 2.0] , and similarly for tuples.
Release 2.5.2, documentation updated on 21st February, 2008.
See About this document... for information on suggesting changes.
