Next: Sequence Types Prev: Comparisons Up: Types Top: Top

2.1.4. Numeric Types

There are three numeric types: plain integers, long integers, and floating point 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. 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. 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 plain integer is smaller than long integer is smaller than floating point. Comparisons between numbers of mixed type use the same rule.(1) The functions int(), long() and float() can be used to coerce numbers to a specific type. All numeric types support the following operations:

Operation
Result --- Notes

abs(x)
absolute value of x
int(x)
x converted to integer --- (1)
long(x)
x converted to long integer --- (1)
float(x)
x converted to floating point
-x
x negated
+x
x unchanged
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 --- (2)
x % y
remainder of x / y
divmod(x, y)
the pair (x / y, x % y) --- (3)
pow(x, y)
x to the power y
Notes:
(1)
Conversion from floating point to (long or plain) integer may round or truncate as in C; see functions floor and ceil in module math for well-defined conversions.
(2)
For (plain or long) integer division, the result is an integer; it always truncates towards zero.
(3)
See the section on built-in functions for an exact definition.

Menu

Bit-string Operations on Integer Types

---------- Footnotes ----------

(1) As a consequence, the list [1, 2] is considered equal to [1.0, 2.0], and similar for tuples.