Python Numbers

Python offers a wide variety of inbuilt data types to handle different requirements. Each data type comes with built-in methods for performing different operations.

The numeric data in Python is generally in three formats namely Integer, Float, and Complex.

In this article, you will learn the basic numeric data types available in Python, along with the different ways of creating them.

You will also learn the different methods available to carry out the basic operations in them and the Math module and the Python Decimal and Fraction modules in detail.

Integer Number

Int or Integer data type is used for numeric data of any length without a decimal point. Integer data can be either positive or negative.

For example, we can use the int data type to store the roll number of a student. The Integer type in Python is represented using a int class.

We can create an integer variable using the two ways

1. Directly assigning an integer value to a variable
2. Using a int() class.

Example to create Integer number

roll_no = 33
# display roll no
print("Roll number is:", roll_no)  # 33
print(type(roll_no))  # class 'int'

# create integer using int() class
id = int(25)
print(id)  # 25
print(type(id))  # class 'int'

Float Number

Float or Floating point data type is used for numeric data with one or more decimals. It can be either positive or negative.

We can create a Integer or Float variable by assigning values. We can get the type of a variable by using the type function.

#data types
x=-9999
y=99.99
print(type(x))
print(type(y))

Output

<class 'int'>
 <class 'float'>

Complex Numbers

A Python complex number is one having a real and imaginary parts. It is generally represented as

c==c.real+c.imaginary*1j

This is the rectangular or cartesian representation of the complex number where z.real and z.imaginary are the cartesian coordinates.

A Python complex number can be represented in both rectangular as well as polar coordinates. Polar coordinates are one alternative way of representing complex numbers that will have r and phi where r is the modulus and phi is the phase angle.

Python provides a separate module called cmath with functions, especially for these complex numbers.

In addition to the regular trigonometric and classification functions, it has additional methods to perform the conversion from rectangular to polar and to find the phase angles.

import cmath

#to find the phase angle
phi = cmath.phase(complex(-1.0, 1.0))
print(phi)

#to find the rectangular coordinates
c=cmath.rect(1,2)
print("real::",c.real)
print("imaginary::",c.imag)
print("complex number::",c)

#print the polar coordinates
p=cmath.polar(c)
print("polar::",p)

Output

2.356194490192345
real:: -0.4161468365471424
imaginary:: 0.9092974268256817
complex number:: (-0.4161468365471424+0.9092974268256817j)
polar:: (1.0, 2.0)

As seen in the above output we can find the real and imaginary part of the complex number and convert it from rectangular to polar and vice versa.

Hexadecimal and Octal Numbers

We can represent a number in Octal form by preceding with a 0 and in hexadecimal form by preceding with a 0x. We can convert a number from integer to octal by using the oct() method and into hexadecimal form by using the hex() method.

i = 10
print("in octal form::", oct(i))
print("in hexa decimal form ::", hex(i))

Output

in octal form:: 0o12
in hexa decimal form :: 0xa

Number Type Conversion

Python allows the conversion of data from one type to another in two ways.

• Implicit type conversion
• Explicit type conversion

Implicit Type Conversion

In the case of two compatible data types, Python performs the type conversion implicitly. Compatible data types are in general two numeric data types like int and float. It will convert the smaller data type to larger one to prevent any data loss. For eg.; int data will be converted to float.

But, if we try to perform some operations between a string and int types then it will throw Type error.

Let us see this with an example.

x = 99
y = 1.111

#data in int and float
print(type(x))
print(type(y))

#addition
z = x+y

#type after addition
print(type(z))

Output

<class 'int'>
<class 'float'>
<class 'float'>

Explicit Type Conversion

We can convert data in one type to another explicitly using int(), float(), complex() etc; This is called typecasting.

#concatenating int and str types
i = 99
s = "apple"
print(s+str(i))

Output

apple99

Math Module Methods to work with Numerical Data

Python has built-in methods to perform complex mathematical operations.

In order to use them, we need to import the math module using the import math statement. We will see some most widely used math methods with examples.

ceil() and floor()

These two methods are used to round a float number to the nearest integer. As the name suggests, ceil()  method is used to round the number UP to the nearest integer value while floor() is used to round a number DOWN to the nearest integer value.

import math as m

a = 1.4
print(m.ceil(a))
print(m.floor(a))

Output

2
1

degrees() and radians()

In trigonometric calculations, we represent angles in both degrees as well as radian’s form.

We use the degrees() method to convert the angle in radians to degrees.
Similarly, we use radians() method to convert the angle in degrees to radians.

In addition to the above methods, math module also provides some frequently used constants like pi. Let us see this with an example below.

import math

pi = math.pi
print(pi)
#To find the degree equivalent of the radians
print("Degree value of pi is ::",math.degrees(pi))

#Radians for the degrees
print("Radian value of 90 degree is ::",math.radians(90))

Output

3.141592653589793
Degree value of pi is :: 180.0
Radian value of 90 degree is :: 1.5707963267948966

sin() and cos()

We can find the trigonometric sin and cos values using built-in methods in the python math module.

We can find the sin value of an angle in radians using the sin() method. Similarly, we can find the cos value of the angle in radians using the cos() method.

#sin value of 90
radians_90=math.radians(90)
print("sin value of pi/2 is ::", math.sin(radians_90))

#cos value of 60
radians_60 = math.radians(60)
print("cos value of pi/2 is ::", math.cos(radians_60))

Output

sin value of pi/2 is :: 1.0
cos value of pi/2 is :: 0.5000000000000001

factorial()

We can find the factorial of any positive integer using the <code>factorial()</code> method in the math module. This method will return the factorial value, multiplication of all the numbers from the specified number until 1. E.g., the factorial of 5 is 5*4*3*2*1. Let us see this with an example.

import math

#factorial of 6 : 6*5*4*3*2*1
print("factorial of 6 is ::", math.factorial(6))

Output

factorial of 6 is :: 720

fabs() and trunc()

We can use the fabs() method in the math module to find a number’s absolute value as a float. This method will remove the negative sign, if any, and return only the absolute float value.

We can truncate a number to its nearest integer using the trunc() method. This method will not return the negative sign, if any.

import math

#floating absolute value
print("floating absolute value::", math.fabs(-99.999))
print("floating absolute value of an integer::", math.fabs(-11))

#truncated integer value
print("truncated integer value::", math.trunc(-99.99))

Output

floating absolute value:: 99.999
floating absolute value of an integer:: 11.0
truncated integer value:: -99

As we can see the fabs() method is returning the floating absolute value of both a float number as well as an integer. The trunc() method returns the truncated integer value of the given number which includes the negative sign as well.

pow() and log()

We can find the natural log value of a number using the log() method in math module.
The pow() method accepts two arguments, x, and y, and returns the value of x raised to power y. Let us see both the methods with an example.

import math

print("The value of 9^3 is ::", math.pow(9, 3))
print("The log value of 5::", math.log(5))

Output

The value of 9^3 is :: 729.0
The log value of 5:: 1.6094379124341003

Checking Functions

In math module, there are methods to check whether a number is either finite or infinite. We also have a method to check whether an argument is number or not.

isfinite() and isinf()

We can check whether a number is finite or not using the isfinite() method. This method will return True if the value is finite and false if it is infinite. In the same way, we can check whether a number is infinite or not using the isinf() method.

#checking whether a number is finite or not
print("Finite or not::",math.isfinite(-0.00006))
#checking whether a number is infinite or not
print("Infinite or not::",math.isinf(math.inf))

Output

Finite or not:: True
Infinite or not:: True

isnan()

We can also check whether the argument we pass is a number or not using the isnan() method.This method will return true the passed argument is not a number.

#checking whether it is a number or not
print("IS a number or not::", math.isnan(math.nan))

Output

IS a number or not:: True

isclose()

We can find whether two numbers are close or not using the isclose() method. We can even mention the absolute tolerance which will compare the numbers near 0 and it is the minimum tolerance. We can pass the relative tolerance which is the maximum difference allowed between two numbers.

#compare the closeness of two values
print("with absolute tolerance  difference::", math.isclose(1.5, 2.05, abs_tol = 0.55))

print("with relative difference < difference::", math.isclose(1.5,1.75,rel_tol=0.5))

Output

with absolute tolerance  difference:: True
with relative difference < difference:: True

Square root, GCD, Power, and Exponentials of a Number

In addition to the above methods, there are methods that are commonly used like

• sqrt(): For finding the square root,
• gcd(): For finding the greatest common divisor,
• pow(x,y): For finding  number x raised to power y and
• exp(x): exponentials of number x

Let us see one simple example for all the above functions.

#finding sqrt
print("The square root of 25 is ::", math.sqrt(25))
print("The square root of 10 is ::", math.sqrt(10))

#Greatest Common Divisor
print("The greatest common divisor is ::", math.gcd(6,12))

#exponential value
print("The value os e(x) is::", math.exp(-2))

#Number raised to power
print("The value of 9^3 is ::", math.pow(9, 3))

Output

The square root of 25 is :: 5.0
The square root of 10 is :: 3.1622776601683795
The greatest common divisor is :: 6
The value os e(x) is:: 0.1353352832366127
The value of 9^3 is :: 729.0

Other Python Number Methods

In addition to the above methods, there are few methods in Python for performing some number-related operations. Let us see each with a small example.

bit_length()

This method is used to find the number of bits to represent a number in binary format excluding the sign and leading zeros.

i=-99
print("bit length::", i.bit_length())

#checking by printing the binary version
bin(i)

Output

bit length:: 7
-0b1100011

to_bytes()

This method will return an array of bytes to represent an integer.

(24).to_bytes(3, byteorder='big')

Output

b'\x00\x00\x18'

The above output shows the array of bytes to represent the integer value 24. The byteorder argument determines the byte order used to represent the integer. In case the  byteorder is “big”, the most significant byte is at the beginning of the byte array. In case the  byteorder is “little”, the most significant byte is at the end of the byte array. The integer is represented using length bytes. If the integer cannot be represented within that length then we will get Overflow error.

is_integer()

We can check whether the given number is an integer or not using the is_integer() method. It will return a boolean value.

f=0.25

f.is_integer()

Output

False

As seen in the above example the value of f is not an integer and we got the output as False.

as_integer_ratio()

We can represent the floating number as an integer number ratio. In case of not a perfect fraction ,then the nearest possible ratio will be returned.

f=0.25
f.as_integer_ratio()

Output

(1, 4)

Python Decimal Module

Python stores a decimal value internally as a base 2 binary fractions. For e.g 1/3 in base 10 can be stored as  0.3, 0.33, or 0.3333. But we can add as many digits in the end as possible to get to the near possible approximation.

Due to the limitations of the floating-point arithmetic some decimal numbers cannot be represented exactly in base 2 binary fractions.

To prevent some data loss while performing mathematical operations, especially in numbers with decimal digits, Python provides a separate module, ‘Decimal.’

Creating a Decimal Number

With the help of the decimal  module we can actually set the precision of the number to be displayed up to 28 digits. Based on the requirements we can actually specify the amount of precision while representing the decimal numbers.

• Using decimal() constructor: We need to import the decimal module to perform the following operations.
• Passing a tuple inside the decimal() constructor: Tuple will have three-part. The first part will be 0 for positive and 1 for negative. The second part will be the Integer component.

We can even set flags like ROUND_CEILING,ROUND_FLOOR,ROUND_UP,ROUND_DOWN and traps to raise a Python exception during conditions like Division by Zero.By default certain conditions like the division by zero are set to true only.

import decimal
from decimal import *

print(Decimal(0.01))
print(Decimal('0.05'))
print(Decimal((1, (9,9,9,9), -2)))

Output

0.01000000000000000020816681711721685132943093776702880859375
0.05
-99.99

Decimal Methods

getcontext()

We can set the precision using the getcontext() method and even set the flags to mention whether we need to round the digits up or Down.

print(Decimal(3) / Decimal(77))

Output

0.03896103896103896103896103896

We can limit the number of digits in the above output by setting the precision using the getcontext().

getcontext().prec = 2
getcontext().rounding = decimal.ROUND_UP
 
print(Decimal(3) / Decimal(77))

Output

0.039

Mathematical Operations

In addition to this, we have the flexibility of using all the mathematical functions like sqrt,log , etc; available in the decimal module as well.

Note: It is very important to clear_flags() which we have already set in order to adjust our precision differently for different requirements.

import decimal
from decimal import Decimal, getcontext
getcontext().clear_flags()
print(Decimal(2).sqrt())

Output

1.414213562373095048801688724

Python Fraction Module

Python provides a separate module for handling the rational numbers called Fraction Module.

A fraction can be formed from a decimal , float, integers ,another rational number or a string.Let us see each one with a small example. We have to import the fractions module first.

from fractions import Fraction

Let us see examples for each of the above.

from fractions import Fraction
#From two integers
Fraction(25, -100)
#From another fraction
Fraction(' -3/7 ')
#from a decimal
from decimal import Decimal
Fraction(Decimal('9.9'))
#from a decimal without quotes
from decimal import Decimal
Fraction(9.1)
#Empty Fraction
Fraction()

Output

Fraction(-1, 4)
Fraction(-3, 7)
Fraction(99, 10)
Fraction(9.1)
Fraction(0, 1)

Fraction Module Methods

limit_denominator()

Some fractions are lengthy, and we can use the limit_denominator() method to limit the number of digits in the denominator. Let us see this with an example.

As fractions have two parts, namely a numerator and a denominator, there are methods to access both.

from fractions import Fraction
import math
#Fraction(math.pi).limit_denominator(100)
f=Fraction(math.pi).limit_denominator(100)
print("The fraction created is::",f)
print("Numerator::",f.numerator)

Output

The fraction created is:: 311/99
Numerator:: 311

from_float()

We can create fractions from a floating number using the  method.

Fraction.from_float(0.25)

Output

Fraction(1, 4)

ceil() and floor()

We can use the ceil() and floor() methods of the math module to find the nearest integer above or below the fraction value.

import math
math.ceil(Fraction(300, 124))

Output

3

Printing Numbers in different Formats

We can print the numbers in different formats using the format function. We can specify the number of digits we want to print after the decimal point in case of a float number. With the help of the format function and padding operator, we can specify the space after the sign in case of a negative integer.

For e.g, In the following example, the float value is limited to only 6 digits (including the decimal point) in the output with 4 digits after the decimal point. In the case of an integer, the total output is 6 digits including the sign.  

print("Total 6 digits with 4 after the decimal point :::")
print('{:06.4f}'.format(3.141592653589793))
 
print("6 digits including the sign:::")
print('{:=6d}'.format((- 234)))

Output

Total 6 digits with 4 after the decimal point :::
3.1416
6 digits including the sign:::
-  234

As seen in the above output the floating-point number in the output is of total 6 digits and it has 4 digits after the decimal point.
Similarly, the integer output has a total of 6 digits including the negative sign.

Summary of all the Methods

Method	Description
ceil()	To round the number UP to the nearest integer value
floor()	To round a number DOWN to the nearest integer value.
degrees()	To convert the angle in radians to degrees.
radians()	To convert the angle in degrees to radians.
factorial()	To find the factorial of any positive integer
fabs()	To find a number’s absolute value as a float.
trunc()	To truncate a number to its nearest integer
pow()	Accepts two arguments, x, and y, and returns the value of x raised to power y
isfinite() and isinf()	To find whether a number is finite or not
isclose()	To find whether two numbers are close or not using
getcontext()	To set the precision of a decimal and set the flags to mention to round the digits up or Down.
limit_denominator()	To limit the number of digits in the denominator.
from_float()	To create fractions from a floating number

Related Tutorials

• Python Data Types
• Python regex find all matches using findall() and finditer()
• Python random randrange() and randint() to generate random integer number within a range
• Python range of float numbers
• Generate Random Float numbers in Python using random() and Uniform()