Python Numbers: Types, Methods, And Functions

Python Numbers

Mastering the basic data types for numbers is a must when you learn any programming language. Let’s dive into how Python numbers work and the basic arithmetic and mathematics you should know.

Numeric Types In Python

Python comes with support for three numeric data types:

  • integers
  • floating-point numbers
  • complex numbers

In addition to operators and functions, you can create numeric values through numeric literals.

Those with exponent signs or decimal points represent floating-point numbers. To create a complex number, combine a real part (a numeric literal) and an imaginary part (another numeric literal with ‘j’ or ‘J’ appended to it).

Constructors like int(), float(), and complex() can also be used to create numbers.

Integers

Unlike many other languages, such as C, there is only one data type for all integers in Python. They are presented by the int class and have unlimited precision. You don’t have to worry about their size or sign.

The int() function converts strings or floating-point numbers to integers:

>>> int("45")
45
>>> int(4.5)
4
>>> int(-4.5)
-4

You can apply common algebra operations like add, subtract, multiply, and divide.

>>> a = 9
>>> b = 3
>>> a + b
12
>>> a - b
6
>>> a * b
27
>>> a / b
3.0
>>> 7 / 3
2.3333333333333335

Remember that in Python 3, the slash operator (/) specifies float division, meaning the result will be a float, not int, no matter whether the value of the remainder.

>>> type(6 / 3)
<class 'float'>
>>> type(7 / 3)
<class 'float'>

To carry out integer division, use the double-slash operator (//). It returns the floored quotient of the division (the largest integer that is smaller than the true quotient):

>>> 7 // 3
2
>>> type(7 // 3)
<class 'int'>

The module operator (%) returns the remainder of dividing two integers:

>>> 7 % 3
1

To get both the quotient and remainder of an integer division operation, use the divmod() function. It returns a tuple containing two integers:

>>> divmod(7, 3)
(2, 1)

Python supports common operator precedence, so you can write compound expressions without having to use parentheses to explicitly specify the order of operations.

>>> 1 + 5 * 2
11
>>> 1 + (5 * 2)
11

You can use underscores to mark large integers. They help group digits and make the number more readable without affecting its value. Python ignores those characters when storing and printing the number:

>>> distance = 1_000_000_000
>>> print(distance)
1000000000
>>> distance - 1000
999999000

Floating-point Numbers

Most Python implementations (including the default CPython) use C’s double to represent values of the float class. For this reason, the precision of floating-point numbers depends on the system you are running Python on.

You can obtain more information about the representation (such as the maximum positive finite value) of your installation’s float via sys.float_info.

Use the float() constructor to convert a string or a number of other types to a float. The string argument can have a decimal number, a sign, and whitespaces.

>>> float("3.14")
3.14
>>> float(78)
78.0
>>> float()
0.0

When you give float() a float or int, it will return a float that has the same value within the precision of your Python installation.

Note: follow this guide to learn how to check if a float is a whole number.

While Python’s float supports all arithmetic operations involving int, it has some limitations on precision. Your system uses a finite number of bits to represent float numbers, and this can lead to a loss of precision.

>>> 2.11 - 0.11
1.9999999999999998
>>> 1 + 0.0000000000000000000001
1.0

You should be aware of these errors when working with floating-point numbers in Python. The following expression evaluates to false while most might expect otherwise:

>>> (2.11 - 0.11) == 0.02
False

To avoid those problems, check out the built-in decimal module. It is designed to make high-precision float calculations. The module takes into consideration the way humans understand and calculate those numbers.

The support for rational numbers is provided by the fractions module. It offers the Fraction class, which can be constructed from a numerator and a denominator:

>>> from fractions import Fraction
>>> a = Fraction(1, 3)
>>> print(a)
1/3
>>> type(a)
<class 'fractions.Fraction'>

Arithmetic operations can be used with these Fractions instances:

>>> b = Fraction(2, 3)
>>> a + b
Fraction(1, 1)

Complex Numbers

You can enter a complex number by denoting the imaginary portion with ‘j’:

>>> a = 3 + 4j
>>> type(a)
<class 'complex'>

The complex() constructor can also create a complex number value by providing the real and imaginary parts or converting them from a string or number.

>>> complex(3, 4)
(3+4j)
>>> complex("3+4j")
(3+4j)

Note: you must remove white space surrounding the + or / operator. Otherwise, complex() will raise the ValueError exception.

>>> complex("3 + 4j")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: complex() arg is a malformed string

To extract the real and imaginary part of a complex number, get its attributes “real” and “imag”. Both of them are returned as floating-point numbers.

>>> a = complex(3, 4)
>>> a.real
3.0
>>> a.imag
4.0

Use the conjugate() method to get the conjugate of a complex number:

>>> b = a.conjugate()
>>> b
(3-4j)

Other Mathematical Operations

Exponents are supported  with double-multiplication symbols:

>>> 2 ** 4
16

The abs() function returns the absolute value of a number (or any object that has __abs__(). When applied to a complex number, it returns the magnitude:

>>> abs(4.5)
4.5
>>> abs(-8.4)
8.4
>>> abs(4-6j)
7.211102550927978

Python performs implicit type conversion in the case of mixed arithmetic expressions. When given two operands with different numeric types, it automatically converts the “narrower” type to the “wider” one. For example, int values will be converted to float if the other operand is a float.

There are many built-in modules providing additional functions for mathematical operations.

The random module can help you generate pseudo-random numbers with different distributions. In particular, the randint() function returns a random integer within a range defined by you:

>>> import random
>>> random.randint(0, 10)
9
>>> random.randint(0, 10)
10
>>> random.randint(0, 10)
4

The math module, on the other hand, comes with mathematical functions you can find in C. Use it when you want to find the square root of a number or the sine of an angle:

>>> import math
>>> math.sqrt(9)
3.0
>>> math.sin(math.radians(90))
1.0

Tutorials about Python Numbers

Some articles related to Python Numbers that you may be interested in:

Summary

Python makes it simple for programmers by putting numeric values into only three distinct data types. There are also other classes on top of them to provide other numeric and mathematical capabilities.

Leave a Reply

Your email address will not be published. Required fields are marked *