Numeric Data Types in Python: Integers, Floats and Complex Types

Numeric data types store numerical values in a programming language, they can be divided into Integer data types, which  store whole numbers;  floating data types, which store floating-point values i.e values with decimal points, and lastly we have the complex data types , which store complex numbers.

Python offers builtin support for the  three numeric data types , the int type is used to represent the integer values, the float type represents the floating point values and the complex type represents complex numbers. Boolean values, represented by the bool type, are a subtype of the integer data type.

The three numeric types are immutable, meaning that once they are created, their value cannot be changed. You can check on Mutable vs Immutable Data Types  to see more details.

In this article we will explore the three numeric data types , their features and applications in Python programming.

Integers

Integers represent whole numbers and are the most commonly used numeric data type in Python programming.

Examples of integers:

1, 2, 3, 5, 9, 78, 10000, 178900 

Some languages like C++ and Java  have limits on the size of integers due to how numbers are represented internally in the memory. And in such languages, there are different types of integers as characterized by their size, for example an integer variable  will only hold integers in the range  -2147483648 to 2147483647 , trying to assign a value outside that range will raise an error unless you use other integer types such as the long int type.

In Python ,there is only one integer type represented by type int which is abstracted  in a way that it can hold integers of unlimited size. These means that you can efficiently use integers like 2^10000, which has over 3000 digits, a thing which is impossible in some languages like C++ or Java.

The int type  defines some attributes and methods  for integer instances, which allows easy manipulation and conversions, these  features allow us to perform operations such as arithmetic, logical  comparison , boolean logic e.tc on integers.

Arithmetic Operations on Integers

The most commonly performed operations on integers and other numeric types are arithmetic operations,  these are just the basic operations from mathematics such as addition, subtraction, multiplication and division. Briefly, the operators used for arithmetic operations are:

You can check on arithmetic operators to see a detailed discussion on these operators and operations.

The only operations which may be a little unfamiliar is the Floor Division and the Modulo operation, all the rest are just as used  in Mathematics.

The Floor division is just like normal division but returns the floor value of the division result ,  the floor value of a number is the largest  integer  which is less than or  equal to the number. For example the floor value of 5.5 is 5 .

The modulo operation returns the remainder of a division, for example 10 % 3 is 1  because 10 divided by 3 is 3   remainder 1. While this operation  is not used much in elementary mathematics, it has alot of use when it comes to programming, for example if you divide any number by two, the remainder is always 1 or 0, if the remainder is  1, the number is odd, if 0, the number is even:

a = 7
match a % 2:
    case 1:
        print("Odd")
    case 0:
        print("Even")

//Odd

Example of arithmetic operations on integers interactively:

67 - 7
//60
67 + 7
//74
67 * 7
//469
67 / 7
//9.571428571428571
67 // 7 
//9
67 % 7
//4
30 // 10
//3
30 % 10
//0
3 ** 5
//143
3 ** -2
//0.1111111111111111

What you note from the above examples is that most arithmetic operations where both operands are integers evaluates to an integer. The only case where this does not apply is in exact division i.e division using the ( / ) operator,  which always evaluates to a float; and  in the case of exponentiation/power where the second operand, the exponent, is negative.

Each instance of the int class has a method which is responsible for performing each arithmetic operations, in fact, when you use the arithmetic operators, you are simply calling the method  which performs the actual operation. These methods are called magic methods or dunder methods(dunder is acronym for double underscore).

for example you can also add integers using the addition magic method which is __add__() as shown below:

a = int(9).__add__(7)
print(a)

Relational and comparison Operations on Integers

Performing logical comparison on integers and other numeric values is almost like how we do it in mathematics, the operators used are almost  the same except for the equality operator, In math the  ( = ) operator is used for equality, but in Python and most other languages this operator is reserved for assignment, the  (==) operator  is used for equality. This is a very common pitfall for beginners and even some experienced programmers, where you use a single equal sign (=) for equality.

The other operation which is not very common in mathematics but it is very common in programming is not equal to  , in Python the operator used for this operation is (!=) .

The comparison operators always evaluates to boolean values i.e either True or False. Briefly, the operators are:

Check on relational operators to see more about these operators.

1 < 2
//True
1 > 2
//False
1 == 2
//False
1 <= 2
//True
1 >= 2
//False
1 != 2
//True

Turning other types to int type

We can use the built-in int() function to turn to integers values from other types which have an equivalent integer value. Some types which can be casted to integers are:

int("6")
//6
int("-100")
//-100
int(34.7)
//34
int(True)
//1
int(False)
//0

If called without any argument, the int() function returns 0:

int()
//0

The bool type

The bool type as we said earlier is a subtype of int , it has  only two values which is True and False. In fact, these two values are simply  1 and 0 respectively. Python offers a builtin function issubclass() which we can use to confirm that the bool type is a subtype of int:

issubclass(bool, int)
//True

Performing arithmetic operations on boolean values also evaluates to integers as follows:

True + True
//2
False + False
//0
True + False
//1

Boolean values are the return values of  the following  operators:

Every object which has value can be casted into a boolean type, in a nutshell, the boolean values of the builtin types  are as follows:

We can use the builtin  bool() function to cast values into their boolean values , Examples:

bool(1)
//True
bool(0)
//False
bool(None)
//False
bool(7.3)
//True
bool([1, 3, 5])
//True
bool([])
//False
bool("r")
//True
bool("")
//False

when the bool() function is called without an argument it returns False:

bool()
//False

Floating point numbers are numerical representations that approximate real numbers with a decimal point. Examples of floating point numbers include 1.0, 0.0, 10.4, 7.6, 10.01, and 1000.0

We can also use the scientific notation for floating point values . In this notation a float value is represented in the form of e+x or e-x, where e is the letter “e”, and x is the power of 10, which is a positive or negative integer. For example, the number one million can be represented in scientific notation as 1e+6, and the number one tenth can be represented as 1e-1. This notation is especially useful when we are dealing with very large or small numbers.

1e+6
//1000000.0
1e-4
//0.0001
type(1e+6)
//<class 'float'>

Real numbers are not always accurately represented in memory compared to integers. For example, in some older versions of Python, performing the operation 1.0 / 10 will yield the answer 0.10000000000000001, when the correct answer is just 0.1. Even though , the previous equation will yield the correct answer  in latter versions such as  Python 3.11.2, the expression 1.0 / 10 == 0.10000000000000001 will evaluate to True, even though the two values are not equal.

Example in python 3.11.2

1.0 / 10
//0.1
1.0 / 10 == 0.10000000000000001
//True
0.1 + 0.2
//0.30000000000000004

These inaccuracies have nothing to do with Python, it is purely due to how floating point values are represented, for example  it is  impossible to represent 0.1 accurately in the memory so  it gets approximated to the nearest representable value.

Operations on Floats

Since operations on floats and integers do not have much difference, we will not discuss the operators again. The  thing that you should keep in mind is that an operation which involves an operand of  int type and another  of float type, will always yield a floating point value

Examples:

2.4 + 6.3
//8.7
2.5 * 2.5
//6.25
7.0// 7
//1.0
9 // 3.0
//3.0
10 ** 2.0
//100.0

We can use the builtin float() function to  cast compatible values from other types to float type as follows:

float(1)
//1.0
float("4.7")
//4.7
float("5")
//5.0
float(True)
//1.0
float(False)
//0.0

When the float() function is called without any argument, it returns 0.0:

float()
//0.0

Complex numbers

Compex numbers are numbers of the form a + bj, where a and b are real numbers and j is the imaginary unit, defined as the square root of -1. In Python, complex numbers are represented using the built-in complex data type.

Examples:

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

You can also use the builtin complex() function with two arguments, to create  a complex number.

z = complex(3, 4)
print(z)
//(3+4j)

If no argument is given, the  complex() function returns 0j

complex()
//0j

Accessing the real and the imaginary parts of a complex number.

z = 3 + 4j
print(z.real)
//3.0
print(z.imag)
//4.0