There are four numeric types: *plain integers,
long integers, floating-point numbers,
*
and *complex
numbers*
. Plain integers (also just called
integers) are implemented using `long`

in C, which
gives them at least 32 bits of precision. 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 both
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 built-in
functions and operators. Unadorned integer literals (including hex
and octal numbers) yield plain integers. 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.

Python fully supports mixed arithmetic: when a binary arithmetic
operator has operands of different numeric types, the operand with
the “smaller” type is converted to that of the other,
where a plain integer is smaller than a long integer is smaller than
a floating point is smaller than a complex. Comparisons between
numbers of mixed type use the same rule.^{[1]} The functions
`int()`

, `long()`

,
`float()`

, and `complex()`

can force numbers to a specific ...

Start Free Trial

No credit card required