Python Numbers
In Python, there are three common data types used to store numbers:
- Integer (int)
- Float (float)
- Complex (complex)
Integer
An integer is a number without decimal places, or we can say that integers are whole numbers. Integers can be positive, as well as negative. They can be of any length, the only limitation for length is the memory of the system.
We can use underscores(_) anywhere in between the long numbers to make them easier to read. The number will still be treated as an integer.
Type function will return class ‘int’.
Positive integer.
temperature = 65
print(temperature)
print(type(temperature))
Integer with underscore(s).
price = 786_123_496
print(price)
print(type(price))
Negative integer.
temperature = -65
print(temperature)
print(type(temperature))
Long integer.
long_number = 123456789123456789123456789123456789123456789123456789
print(long_number)
print(type(long_number))
Float
A floating-point number (float) is a number with a decimal place. They can also be either positive or negative and can be of any length. Floating-point numbers can also contain “e”, “e” is a scientific notation that means “10 to the power of”. For example, 1E17 means 1 * 1017.
To make them easier to read, we can also use underscores (_) anywhere in between the long numbers, even after the decimals. The number will still be treated as a float.
Type function will return class ‘float’.
Positive float.
temperature = 65.5
print(temperature)
print(type(temperature))
Float with underscore(s).
price = 786_123_496.23_14
print(price)
print(type(price))
Negative float.
temperature = -65.5
print(temperature)
print(type(temperature))
Long float.
long_number = 123456789123456789123456789123456789123456789123456789.3659874
print(long_number)
print(type(long_number))
Float with “e”
length = 12E3
print(length)
print(type(length))
Complex
Complex numbers are numbers with a real part and an imaginary part. They are not used in our day-to-day calculations, mostly used by expert mathematicians.
In a complex number, j is appended with the imaginary part. Example 4+7j, here, in this number, 4 is a real number and 7 is an imaginary number.
Type function will return class ‘complex’.
Positive complex number.
x = 4+5j
print(x)
print(type(x))
[variable].real is used to fetch the real part.
print(x.real)
[variable].imag is used to fetch the imaginary part.
print(x.imag)
complex() function is used to create complex number. It has two arguments, first is real number and second is imaginary number.
y = complex(4,5)
print(y)
print(type(y))
Number Type Conversion
We can convert data type of number from one type to other type usign these methods:
- int() – To convert to integer
- float() – To convert tot floating-point number.
- complex() – To convert a number to complex number
int() – Converting float to int.
x = 5.5
a = int(x)
print(a)
print(type(a))
float() – Converting int to float.
x = 5
a = float(x)
print(a)
print(type(a))
complex() – Converting int to complex.
x = 5
a = complex(x)
print(a)
print(type(a))
Number Functions
Here are a few built-in functions, that can be used with the numbers.
| Function | Description | Example | Output |
|---|---|---|---|
| min(a,b,…) | Returns the minimum of the sequence. | min(5,10,6) | 5 |
| max(a,b,….) | Returns the maximum of the sequence. | max(5,10,6) | 10 |
| abs(a) | Returns the (positive) distance between a and 0. | abs(-5.6) | 5.6 |
| pow(a,b) | Returns a ** b. | pow(2,3) | 8 |
| round(a[,n]) | The value of a is rounded to n digits. | round(5.236,2) | 5.24 |
Math Module
Python has math module for the different mathematical operations on the numbers like trigonometry, logarithms, etc. Here are the few of the functions from the maths module:
| Function | Description | Example | Output |
|---|---|---|---|
| math.sqrt(a) | Returns the square root of a. | math.sqrt(4) | 2.0 |
| math.floor(a) | The floor value of a, i.e., the greatest integer that is less than a. | math.floor(5.6) | 5 |
| math.ceil(a) | The ceiling value of a, i.e., the smallest integer that is not less than a. | math.ceil(5.6) | 6 |
| math.exp(a) | The exponent of a. | math.exp(2) | 7.38905609893065 |
| math.fabs(a) | The absolute value of a. | math.fabs(-5.28) | 5.28 |
| math.log(a) | The natural log value of a. | math.log(20) | 2.995732273553991 |
| math.log10(a) | The base 10 log of a is returned. | math.log10(20) | 1.3010299956639813 |
| math.modf(a) | A tuple is returned containing the fractional and integer parts of a floating-point number. The integer part is also returned as a float. | math.modf(2.56) | (0.56, 2.0) |
Random Module
The random module is used to generate the random numbers, select random elements, etc. Though random module is too vast, but here are a few methods of random module:
To generate a random number between 0 and 1.
import random
print(random.random())
To select a randome item from the string, list, etc
import random
name = 'Logical Python'
print(random.choice(name))
Decimal Numbers in Python
Internally in the code, the decimal numbers are not represented as we think. When we try to perform some arithmetic operations on the decimals, we see unexpected results.
Why we get 3.3000000000000003 ?
x = 1.1
y = 2.2
z = x + y
print(z)
This does not happens with all numbers.
x = 2.2
y = 3.3
z = x + y
print(z)
Floating-Point Representation Limitations:
This discrepancy is due to the way floating-point numbers are stored in the computer’s memory. The limitations of representing certain decimal fractions in the binary floating-point format.
Python uses the IEEE 754 standard for floating-point arithmetic, which represents numbers in binary. However, not all decimal fractions can be precisely represented in binary, leading to rounding errors.
Binary Representation of 1.1 and 2.2:
1. The decimal number 1.1 cannot be represented precisely in binary, just like the fraction 1/3 cannot be represented precisely as a decimal (0.333… recurring). So, when 1.1 is converted to binary, it becomes an infinitely repeating binary fraction.
1.0001100110011001100110011001100110011001100110011...2. Similarly, the decimal number 2.2 cannot be represented exactly in binary and has a repeating binary fraction.
10.001100110011001100110011001100110011001100110011...3. When you add these two binary representations (1.1 and 2.2), you get a binary number that is very close to, but not exactly equal to, the binary representation of 3.3.
11.0100110011001100110011001100110011001100110011001...4. Due to the limitations of the binary floating-point representation, the result is a number that is not precisely 3.3.
Decimal Module
If you need precise decimal arithmetic, you can use the decimal module in Python, which provides a Decimal data type that avoids these rounding errors:
import decimal
x = decimal.Decimal('1.1')
y = decimal.Decimal('2.2')
z = x+y
print(z)
