Numeric Types
The Python numeric types are integers, floating point numbers, and complex numbers. Besides, booleans are implemented as a subtype of integers.
Types of Python Numeric
Integer
Integers
int have unlimited precision. The constructor
int() can be used to create a integer. Integer literals can also be used to create integers. For example,
- Decimal integer
decinteger:e.g. 1234567890
- Binary integer
bininteger:e.g. 0𝑏10,0𝐵10
- Octal integer
octinteger:e.g. 0𝑜1234567, 0𝑂1234567
- Hexadecimal integer
hexinteger: e.g. 0𝑥1234567890𝐴𝐵𝐶𝐷𝐸𝐹, 0𝑋1234567890𝐴𝐵𝐶𝐷𝐸𝐹
Floating Point Number
Floating point numbers are usually implemented using double in C. Information about the precision and internal representation of Python floating point numbers can be obtained in
sys.float_info. The standard library also includes the additional numeric types
fractions.Fraction for rationals, and
decimal.Decimal for floating-point numbers with user-definable precision. The constructor
float() can also be used to create a integer. Floating point literals can also be used to create floating point number. For example,
- Decimal point floating point number:
pointfloat e.g. 123456.7890
- Exponent floating point number:
exponentfloat e.g. 7𝑒10,7.2𝐸10
Complex Number
Complex numbers have a real and imaginary part. The real part of a complex number can be extracted by
𝑧.real and the imaginary part of the complex number can be extracted by
𝑧.imag. The constructor
complex() can be used to create a integer. The real part of a complex number can be created by the floating point numeral or integer numeral. While the imaginary part of the complex number can be created by the imaginary numeral which is similar to the real part but a specifier
𝑗 or
𝐽 is appended to the numeric literal. A complex number with a zero real part can be created by a imaginary literal only. For example,
1.3+0.8𝑗, 5.6+8.4𝐽
Python Numeric Operations
Python numeric operations can be divided into basic arithmetic operations and real operations.
Arithmetic Operations
The basic types of Python supported operators for basic arithmetic operations are Unary operators, binary operators and numeric functions.
OperationDescriptionRemarks
-𝑥𝑥 negated
+𝑥𝑥 unchanged
𝑥+𝑦sum of 𝑥 and 𝑦
𝑥-𝑦difference of 𝑥 and 𝑦
𝑥*𝑦product of 𝑥 and 𝑦
𝑥/𝑦quotient of 𝑥 and 𝑦
𝑥//𝑦floored quotient of 𝑥 and 𝑦
𝑥%𝑦remainder of 𝑥/𝑦
abs(𝑥)absolute value or magnitude of 𝑥
int(𝑥)𝑥 converted to integer
float(𝑥)𝑥 converted to floating point
complex(𝑟𝑒,𝑖𝑚)a complex number with real part 𝑟𝑒, imaginary part 𝑖𝑚 with 𝑖𝑚 defaults to zero
𝑐.conjugate()conjugate of the complex number 𝑐
divmod(𝑥,𝑦)the pair (𝑥//𝑦,𝑥%𝑦)
pow(𝑥,𝑦)𝑥 to the power 𝑦
𝑥**𝑦𝑥 to the power 𝑦
Also referred to as integer division. The resultant value is a whole integer, though the result’s type is not necessarily int. 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.
Not for complex numbers. Instead convert to floats using abs() if appropriate.
Conversion from floating point to integer may round or truncate as in C; see functions math.floor() and math.ceil() for well-defined conversions.
float also accepts the strings “nan” and “inf” with an optional prefix “+” or “-” for Not a Number (NaN) and positive or negative infinity.
Python defines pow(0, 0) and 0 ** 0 to be 1, as is common for programming languages.
The numeric literals accepted include the digits 0 to 9 or any Unicode equivalent (code points with the Nd property).
Real Number Operations
The standard types of Python supported operators for real number operations are numeric functions.
OperationDescriptionRemarks
math.trunc(𝑥)𝑥 truncated to Integral
round(𝑥[,𝑛])𝑥 rounded to 𝑛 digits, rounding half to even. Default to 0, if 𝑛 is omitted
math.floor(𝑥)the greatest Integral 𝑥 <=
math.ceil(𝑥)the least Integral 𝑥 >=
Typical Integer Operations
Bitwise Operations on Integer Types
Bitwise operations are for integers only. The basic types of Python supported operators are Unary operators, binary operators and numeric functions.
Types of Bitwise Operators
The types of bitwise operators are:
OperationDescriptionRemarks
~𝑥the bits of 𝑥
𝑥|𝑦bitwise or of 𝑥 and 𝑦
𝑥^𝑦bitwise exclusive or of 𝑥 and 𝑦
𝑥&𝑦bitwise and of 𝑥 and 𝑦
𝑥<<𝑛𝑥 shifted left by 𝑛 bits
𝑥>>𝑛𝑥 shifted right by 𝑛 bits
The result of bitwise operations is calculated as though carried out in two’s complement with an infinite number of sign bits.
The priorities of the binary bitwise operations are all lower than the numeric operations and higher than the comparisons; the unary operation ~ has the same priority as the other unary numeric operations (+ and -).
Negative shift counts are illegal and cause a ValueError to be raised.
A left shift by n bits is equivalent to multiplication by pow(2, n) without overflow check.
A right shift by n bits is equivalent to division by pow(2, n) without overflow check.
Performing these calculations with at least one extra sign extension bit in a finite two’s complement representation (a working bit-width of 1 + max(x.bit_length(), y.bit_length()) or more) is sufficient to get the same result as if there were an infinite number of sign bits.
Methods on Integer Types
The
int type implements the
numbers.Integral abstract base class.
Other Methods on integer are:
OperationDescriptionRemarks
int.bit_length()
int.to_bytes(length, byteorder, *, signed=False)
classmethod int.from_bytes(bytes, byteorder, *, signed=False)
int.as_integer_ratio()
Typical Float Operations
The
float type implements the
numbers.Real abstract base class.
Methods on Float Types
Other Methods on float are:
OperationDescriptionRemarks
float.as_integer_ratio()
float.is_integer()
float.hex()
classmethod float.fromhex(s)
Hashing of numeric types
For numbers x and y, possibly of different types, it’s a requirement that hash(x) == hash(y) whenever x == y (see the __hash__() method documentation for more details). For ease of implementation and efficiency across a variety of numeric types (including int, float, decimal.Decimal and fractions.Fraction) Python’s hash for numeric types is based on a single mathematical function that’s defined for any rational number, and hence applies to all instances of int and fractions.Fraction, and all finite instances of float and decimal.Decimal. Essentially, this function is given by reduction modulo P for a fixed prime P. The value of P is made available to Python as the modulus attribute of sys.hash_info.
CPython implementation detail: Currently, the prime used is P = 2**31 - 1 on machines with 32-bit C longs and P = 2**61 - 1 on machines with 64-bit C longs.
Here are the rules in detail:
If x = m / n is a nonnegative rational number and n is not divisible by P, define hash(x) as m * invmod(n, P) % P, where invmod(n, P) gives the inverse of n modulo P.
If x = m / n is a nonnegative rational number and n is divisible by P (but m is not) then n has no inverse modulo P and the rule above doesn’t apply; in this case define hash(x) to be the constant value sys.hash_info.inf.
If x = m / n is a negative rational number define hash(x) as -hash(-x). If the resulting hash is -1, replace it with -2.
The particular values sys.hash_info.inf, -sys.hash_info.inf and sys.hash_info.nan are used as hash values for positive infinity, negative infinity, or nans (respectively). (All hashable nans have the same hash value.)
For a complex number z, the hash values of the real and imaginary parts are combined by computing hash(z.real) + sys.hash_info.imag * hash(z.imag), reduced modulo 2**sys.hash_info.width so that it lies in range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)). Again, if the result is -1, it’s replaced with -2.
Source and Reference