 # Python Number

August 23, 2021, Learn eTutorial
739

The main objective of this python number tutorial is to educate the concept of number datatype and its conversion in the python programming language. Also will learn about some arithmetic operations used to manipulate this number datatype.

## Python Number Datatype

In python, when a variable is assigned with a number then it comes under the Python Number Datatype. A number data type comprises of an integer value, float value, and a complex type value which are precisely stated as

• int
• float
• complex

## Int Datatype

• Int data type holds integer values (zero, positive, and negative whole numbers) only
• No fractional part is included
• Length is boundless

### Example: Int Datatype

``````#i is a variable of type int
i1 = 10
i2 = 525
print("integer  1 = ",i1)
print("integer 2 = ",i2) ```
```

Output

```integer 1 = 10
integer 2 = 525
```

## Float Datatype

• Contains floating-point numbers
• Includes fractional parts
• Decimal points bounds precisely to 15 decimals

### Example: Float Datatype

``````#i is a variable of type int
f1 = 10.01
f2 = 525.25
print("floating point number 1 = ",f1)
print("floating point number 2 = ",f2) ```
```

Output

```floating point number 1 = 10.01
floating point number 2 = 525.25
```

## Complex Datatype

Complex numbers are numbers comprises of a real part and an imaginary part to take the form a+ib where a and b are real numbers and b is associated with an imaginary unit, i. Example and output.

• Comprises of real part(a) and imaginary part(b)
• The form is a +ib
• The Imaginary unit is ‘i’

### Example: Complex Datatype

``````C1 =-5-6i
C2 = 4+3i
print("Complex number 1 = ",C1)
print("Complex number 2 = ",C2)
```
```

Output

```
Complex number 1 = -5-6i
Complex number 2 = 4+3i
```

## Python - Type Casting & Coercion

One of the unique features in most programming languages is type conversion. Type conversion simply can be defined as changing the data type of one object to another datatype, subjected to various operations or evaluations. Conversion can be done either implicitly or explicitly based on the requirements for hassle-free operations.

Implicit conversion, otherwise known as coercion, is generally defined as the conversion of one python datatype to another based on expression or evaluation as required by a compiler or interpreter. Python programming language supports the type conversion though it has some pitfalls which we will discuss further.

Let us consider the below example in detail to understand more about python coercion. Suppose we need to find the average of two numbers n1 and n2 which are integer datatype. The result could be a fractional number, which stored as a float value. Python automatically declares the resulted value into float making the programmer hassle-free from error. This type of implicit conversion is usually termed as coercion.

### Example: Type coercion example

``````#Type coercion example
n1 = 2
n2 = 3
print(“Average of” n1 “and” n2 “ = ”,(n1+n2)/2)  ```
```

Output

```Average of  2 and 3 = 2.5
```

In some cases, python needs to explicitly convert one python datatype to another based on the requirement. Such type of conversion is generally termed explicit conversion or typecasting. Python has some built-in function which helps to convert data types explicitly. They are listed below

1. int( arg ) - converts the data type of arg to integer
2. float(arg) - converts the data type of arg to floating-point
3. complex(arg1, arg2) - converts the datatype of arg1 and arg2 to complex type where arg1 holds the real part, and arg2 holds the imaginary part.

### Example: How to do type casting

``````#Type casting example
a = 10
b = 5.3
c = 4+5i
#Conversion
x= float (a)
y=int(b)
z=complex of (a)
#Printing output  with corresponding data type
print( x "belongs to",type(x))
print( y "belongs to",type(y))
print( z "belongs to",type(z)) ```
```

Output

```10.0 belongs to <class 'float'>
5 belongs to <class 'int'>
10+0i belongs to <class 'complex'>
```

## Python Number – Modules

### Decimal Module

We have studied in mathematics about decimals and their operations like addition, subtraction, multiplication ….. But when learning a programming language we have given a new name to decimal numbers called floating-point numbers. We typically consider floating-point numbers as decimals themselves. But in reality there exist some differences, while learning machine languages

We know that machines can only understand the binary representation ie, 0 and 1. Floating-point numbers are treated in binary form as well. Hence the binary floating-point calculation is quite different from the typical decimal calculation.

### Example: Decimal module in python

``````A = 1.10
B = 2.20
C = A+B
print("C =",C) ```
```

Output

```C = 3.3000000000000003
```

From the above example on adding 1.10 and 2.20, we are expecting 3.30 as its sum. But the output we got is 3.3000000000000003. This is how fractional numbers are represented in binary forms. And so we have to roughly round the value to 3.30. So we can say that the decimal values stored in the computer are not accurate.

we can sort this inaccuracy of floating-point numbers by simply importing a decimal module. Unlike binary floating-point, the decimal module has programmer altered precision which maintains significance that helps to perform the calculation as we studied in schools. Hence the decimal module is very useful for accounting purposes, financial applications, and so on.

### Example: Decimal module in python

``````import decimal
A = decimal.Decimal('1.1')
B = decimal.Decimal('2.2')
C = 3
D = 3.14

print("A =",A)
print("B =",B)
print("A+B = ",A+B)
print("A+C = ",A+C)
print("A+D = ",A+D) ```
```

Output

```A = 1.1
B = 2.2
A+B =  3.3
A+C =  4.1

print("A+D = ",A+D)
TypeError: unsupported operand type(s) for +: 'decimal.Decimal' and 'float'
```

Note: Decimal operators work with integers but floating-point numbers have to be converted to decimal instances.

Given below table summarizes the difference between decimal and floating-point numbers.

Decimal Float
Have exact representation Does not have an exact representation
Precision length varies on user need Precision length is fixed
Includes idea of significant places Does not support significant places
Partial cover on published standards Full cover on published standards
Decimal operations are slower Floating-point operations are faster
Eg: 1.10 + 2.20 = 3.30 Eg: 1.1 + 2.2 = 3.3000000000000003

### Fraction Module

Like the decimal module, another important module associated with number datatype is the fraction module.

A numerator and a denominator constitute a fraction that we have studied in our earlier classes. Python also supports fractional calculations by importing a module called fractions.

### How to create fraction instances?

Different ways of creating fraction instances are listed below.

### Using integer values as numerator and denominator

``````import fractions
A = fractions.Fraction(1,2)
B = fractions.Fraction (3,4)
print("A =",A)
print("B =",B)
print("A+B =",A+B) ```
```

Output

```A = 1/2
B = 3/4
A+B  = 5/4
```

### Using string format as <’numerator/denominator’>

``````import fractions
A = fractions.Fraction('5/7')
B = fractions.Fraction('3/8')
print("A =",A)
print("B =",B)
print("A+B =",A+B) ```
```

Output

```A = 5/7
B = 3/8
A+B = 61/56
```

### Using floating number format

``````import fractions
A = fractions.Fraction(2.5)
B = fractions.Fraction(1.5)
print("A =",A)
print("B =",B)
print("A+B =",A+B) ```
```

Output

```A = 5/2
B = 3/2
A+B = 4
```

### Using String format as (digits).(digits)

``````import fractions
A = fractions.Fraction('.5')
B = fractions.Fraction('1.5')
print("A =",A)
print("B =",B)
print("A+B =",A+B) ```
```

Output

```A = 1/2
B = 3/2
A+B = 2
```

## Math Module Functions

Python also presents two other important modules that are in fact the back born of mathematical activities. These modules are math and random which are used to perform trigonometric functions, logarithms, probabilities, etc. Functions associated with math modules are tabulated here for easy reference.

Sl No Functions Description Example
1 abs(x) / fabs(x) returns the absolute value of x abs(5.6) => 5
2 ceil(x) returns the ceiling value of x ceil(5.6)=>6
3 floor(x) returns the floor value of x floor(5.6)=>5
4 exp(x) returns the exponential value  x ;ex exp(x)=ex ; e0 = 1
5 log(x) returns the logarithmic value of x, for x>0 log2(8) =3
6 log10(x) returns the logarithmic value of x with base 10,for x>0 log10(100)=2
7 sqrt(x) returns square root of x, x>0 sqrt(16)=4
8 Pow(x,y) returns power of x to y pow(2,3)=8
9 round(x,[n]) returns the round value of X irrespective of sign ound(5.6) =6
round(-5.4) =-5
10 max(n1,n2,n3…) returns the largest value max(1,5,9) =9
11 min(n1,n2,n3…) returns the smallest value min(1,5,9)=1
12 modf(x) returns the fractional part of a floating number modf(5.6)=0.6000000
13 sin() returns sine of argument in radians sin 0
14 cos() returns cosine of argument in radians cos 0
15 tan() returns tangent of argument in radians tan 0
16 hypot(a,b) returns the hypotenuse value of arguments .Type equation here. hypot(3,4) =5
17 degrees() converts radian value to degree and returns degree value