Python - Numbers

As per Python’s data model, An object of Number data type represents a numeric literal, a notation for representing a fixed value in source code. For example in the assignment statement

In  [1] :x=10

Here 10 is a literal as numeric value representing 10 is directly stored in memory. However, a number object is also formed as a result of arithmetic operations. For example:

In  [2] :y=x*2

Here, even if 20 is not literally included in source code, the multiplication results in a number object assigned to variable y. Number object also results out of certain built-in arithmetic function such as int() and float(). These functions are explained later in this chapter.

Python identifies four numeric types.

int: Zero, positive and negative whole numbers without a fractional part and having unlimited precision belong to int data type.

Examples: 1234, 0, -456

Number having 0o or 0O as prefix represents octal number which can have 0 to 7 as one of the digits in it.

Example:

0O12: equivalent to 10 (ten) in decimal number system.

Number with 0x or 0X as prefix represents hexadecimal number. Hexadecimal number system has 0 to 9 digits and A to F alphabets equivalent to 10 to 15.

Example:

• 0x12: equivalent to 18 (Eighteen) in decimal number system
• bool: Object of this type can have either True or False. They represent 1 and 0 respectively. These constants are defined as keywords in Python.
• float: Positive and negative real number with a fractional part denoted by decimal symbol or scientific notation using E or e

Examples: 1234.56, 3.142, -1.55, 0.23

Scientific notation is used as a short representation to express floats having many digits. The number is shortened to a float with two digits after decimal point and multiplied by appropriate power of 10 denoted as E or e.

For example,

345600000000 is represented as 3.456e11 or 3.456E11

345.56789 is represented as 3.4556789e2 or 3.4556789E2

Complex: A number with real and imaginary component is called a complex number. In mathematics, -1 (square root of -1) is defined as imaginary number and is denoted by J or j. Complex number is represented as x+yj. Both x and y are real numbers.

Examples: 1+2j, 10-5.5J, 5.55+2.33j, 3.11e-6+4j

In a complex number, x is called real component and y multiplied by imaginary number forms imaginary part of complex number.

In  [3]   : c=4+5j
In  [4]   : c.real
Out [4] : 4.0
In  [5]   : c.imag
Out [5] : 5.0

Built-in conversion functions

Numeric object of one type can be converted in another with the use of following functions:
int() : returns integer object from a float or a string containing digits.

In [6] : int(100)
Out [6] : 100
In [7] : int(25.55)
Out [7] : 25
In [8] : int('11')
Out [8] : 11

To convert binary, octal or hexadecimal number to decimal integer, int() function takes string representation of binary/octal/hexadecimal number as first parameter and second parameter is the base of respective number system 2, 8 or 16.

In  [9] :int('25', 8) # string contains octal number - base=8
Out [9] :21
In  [10] :int('1A', 16) #string contains hexadecinal number base=16
Out [10] :26
In  [11] :int('10101',2) #string contains binary number base=2
Out [11] :21

float() : This built-in function returns a floating point number object from a number or string containing digits with decimal point or scientific notation (E or e).

In  [12]   : float(100)
Out [12] : 100.0
In  [13]   : float('1.25e10')
Out [13] : 12500000000.0

complex() : returns a complex number with real and imaginary component. The function can take two parameters, one each for real and imaginary component. They can be of any numeric type (int, float or complex)

In [14] : complex(4,5)
Out [14] : (4+5j)
In [15] : complex(2.32, 4.005)
Out [15] : (2.32+4.005j)
In [16] : complex(4j, 2.5j)
Out [16] : (-2.5+4j)

If only one parameter is given it is treated as real component, imaginary component is set to zero.

In [17] :complex(12)
Out [17] :(12+0j)

Built-in mathematical functions

abs() : Absolute value of a number is always positive, irrespective of its sign. In other words, absolute value of a number will always return a positive number. The built-in function abs() can have any numeric object as parameter.

In  [18]   : abs(-225)
Out [18] : 225
In  [19]   : abs(2+3-4*5)
Out [19] : 15
In  [20]   : abs(-100/3)
Out [20] : 33.333333333333336

If the parameter is a complex number, its magnitude is returned. (Magnitude of a+bj or a-bj is√ a2+b2)

In [21] : abs(2-2j) #this is 8
Out [21] : 2.8284271247461903

hex() : This function converts a decimal integer into hexadecimal number representation with 0x prefix.

In [22] : hex(18)
Out [22] : '0x12'
In [23] : hex(127)
Out [23] : '0x7f'
In [24] : hex(-100)
Out [24] : '-0x64'

oct() : converts a decimal integer in octal representation with 0o prefix.

In  [25]    :oct(10)
Out [25]  :'0o12'
In  [26]    :oct(8)
Out [26]  :'0o10'
In  [27]    :oct(-100)
Out [27]  :'-0o144'

pow() : This function requires two parameters. First is any number, second is the power. The function calculates first parameter raised to second. If x and y are parameters, result of pow() function is xy.

In    [28] :pow(10,2)
Out [28] :100
In    [29] :pow(100, 0.5)
Out [29] :10.0
In    [30] :pow(1+2j,2)
Out [30] :(-3+4j)

round() : This function also needs two parameters. First parameter is a number. The function rounds it off to precision denoted by second parameter.

In    [31]   :round(325.6874,2)
Out [31]   :325.69
In    [32]   :round(325.6874,1)
Out [32]   :325.7
In    [33]   :round(325.6874,0)
Out [33]   :326.0

In this chapter we learned about different numeric data types in Python. Python has built-in functions for conversion of one numeric data type. Other mathematical functions have also been explained.

In next chapter we shall study different operators in Python.