{"id":74622,"date":"2019-12-30T10:36:53","date_gmt":"2019-12-30T05:06:53","guid":{"rendered":"https:\/\/techvidvan.com\/tutorials\/?p=74622"},"modified":"2024-08-22T18:00:41","modified_gmt":"2024-08-22T12:30:41","slug":"python-numbers","status":"publish","type":"post","link":"https:\/\/techvidvan.com\/tutorials\/python-numbers\/","title":{"rendered":"Python Numbers – Three cheers for int, float and complex numbers"},"content":{"rendered":"

In this article, we will explore the different types of numbers in Python: integers (int), floating-point numbers (float), and complex numbers (complex). We’ll also see how to convert numbers from one type to another, known as type conversions. By the end, you’ll have a solid understanding of Python numbers and how to use them in your programs. Let’s get started and dive into the world of Python numbers!<\/p>\n

Python Number Types<\/h3>\n

Python has basically three numeric data types named as int<\/strong>, float<\/strong>, and complex<\/strong>. Since Python is a dynamically typed language we don\u2019t have to define the data type<\/strong>. It automatically recognizes<\/strong> the data type during runtime when we assign the variable.<\/p>\n

1. Python int<\/h4>\n

In math, an integer is a whole number that can be either positive or negative and does not have any fractional value. Python’s int type is the same, allowing us to create integer objects directly by assigning a numeric value to them. These integers are precise and efficient, suitable for tasks that require exact whole numbers. Python also handles very large integers seamlessly, enabling calculations with big numbers without overflow issues.<\/p>\n

Num1 = 45\r\nNum2 = -10\r\nprint( Num1, Num2)\r\ntype(Num1)<\/pre>\n
Output:<\/strong><\/p>\n
45 -10<\/div>\n
In Python, there is no limit to how long<\/strong> a number can be. It is only constrained by the amount of memory<\/strong> your system has.<\/p>\n
Num = 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 + 1\r\nprint(Num)<\/pre>\n
Output:<\/strong><\/p>\n
100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000<\/div>\n
Note:<\/strong><\/p>\n
The division operator(\u2018\/\u2019)<\/strong> will convert the number<\/strong> into float<\/strong>. We use (\u2018\/\/\u2019)<\/strong> to do integer division<\/strong>.<\/p>\n
print(4\/2)\r\ntype(4\/2)\r\n\r\nprint(4\/\/2)\r\ntype(4\/\/2)<\/pre>\n
Output:<\/strong><\/p>\n
2.0
\n<class \u2018float\u2019>
\n2
\n<class \u2018int\u2019><\/div>\n
Python Integers Representation in different base<\/h4>\n
The default integer representation is in Decimal (base 10)<\/strong>, but we can also store them as Binary<\/strong>, Octal<\/strong> or Hexadecimal<\/strong>.<\/p>\n
They require a prefix<\/strong> before the number.\"python<\/a><\/p>\n
print(0b100, 0B100) #100 in binary\r\nprint(0o100, 0O100) #100 in octal\r\nprint(0x100, 0X100) #100 in hexadecimal<\/pre>\n
Output:<\/strong><\/p>\n
4 4
\n64 64
\n246 256<\/div>\n
The type of Python integers is the same in all the different<\/strong> representations<\/strong>.<\/p>\n
type(0b01)\r\ntype(0o10)\r\ntype(0x10)<\/pre>\n
Output:<\/strong><\/p>\n
<class ‘int’>
\n<class ‘int’>
\n<class ‘int’><\/div>\n
2. Python float<\/h4>\n
In floating-point numbers, there is no fixed number of digits before or after the decimal point, allowing for the representation of very large or very small numbers with fractional parts. In Python, float is used to define these real numbers that have a decimal point. This type is particularly useful for calculations requiring precision, such as scientific computations or financial analysis.<\/p>\n
X = 1.0\r\nY = 25.125\r\nZ = - 48.1928569\r\n\r\nprint(X, Y, Z)\r\ntype(X)<\/pre>\n
Output:<\/strong><\/p>\n
1.0 25.125 -48.1928569
\n<class \u2018float\u2019><\/div>\n
Scientific Notation of Float Numbers<\/h4>\n
Float numbers can also be represented in scientific notation by using the character \u2018e\u2019<\/strong> or \u2018E\u2019<\/strong>.<\/p>\n
For example,<\/strong> 0.01 can be denoted as 1e-2.<\/p>\n
X = 1e-2\r\nY = 4e5\r\nZ = 2.5e105\r\n\r\nprint(X)\r\nprint(Y)\r\nprint(Z)<\/pre>\n
Output:<\/strong><\/p>\n
0.01
\n400000.0
\n2.5e + 105<\/div>\n
The limit<\/strong> to floating-point numbers is that it can only store values up to 1.79 * 10^308<\/strong>. Values maximum than this will be represented with \u2018inf\u2019<\/strong>.<\/p>\n
print(1.79e308)\r\nprint(1.8e308)<\/pre>\n
Output:<\/strong><\/p>\n
1.79e + 308
\nInf<\/div>\n
3. Python Complex number<\/h4>\n
Complex numbers are represented in the form of (a+ib)<\/strong>, where a is called the real part<\/strong> and b is called the imaginary part<\/strong>. Python uses j<\/strong> instead of i<\/strong>.<\/p>\n
Let\u2019s see the representation of a complex number in code.<\/p>\n
X = 4+2j\r\nY = 2-5j\r\nZ = -5j\r\n\r\nprint(X)\r\nprint(Y)\r\nprint(Z)\r\n\r\ntype(5-4j)<\/pre>\n
Output:<\/strong><\/p>\n
(4+2j)
\n(2-5j)
\n(-0-5j)
\n<class \u2018complex\u2019><\/div>\n
Note:<\/strong><\/p>\n
It is compulsory to define the coefficient<\/strong> of the imaginary part, otherwise, the j will be considered as a variable<\/strong>.<\/p>\n
X = 4 + j # NameError: name \u2018j\u2019 is not defined\r\nY = 4 + 1j # Valid complex number\r\n<\/pre>\n
Python Type Conversion<\/h4>\n
Type conversion is the process of converting<\/strong> data types from one type to another.<\/p>\n
For example, <\/strong>an integer value is converted into a float, or a string is converted into a number.<\/p>\n
Type conversion can occur in one of the two types –<\/p>\n