Numeric data types such as integers and floatingpoint numbers are fundamental elements in Python programming. Mastering integers and floats enables developers to work with essential mathematical operations and represent quantitative data in their applications. This comprehensive guide will provide readers with an indepth look at using numeric data types in Python.
Table of Contents
Open Table of Contents
Overview of Numeric Data Types
Python contains two primary builtin numeric data types:

Integers (
int
): Whole numbers like 2, 1, 0, 1, 2, 3 etc. 
Floatingpoint numbers (
float
): Decimal numbers like 1.5, 0.3, 0.0, 5.6 etc.
These numeric types support basic mathematical operations like addition, subtraction, multiplication and division. Let’s explore them in more detail.
Integers
Integers (int
) represent whole numbers without a decimal point. For example:
num1 = 10 # integer
num2 = 20 # negative integer
In Python 3, integers have unlimited precision by default which means they can grow in size and are only limited by your system’s memory.
Integers are useful for counting, enumerations, calculating whole numbers, representing discrete values and more.
FloatingPoint Numbers
Floats (float
) represent real numbers with a decimal point. For instance:
num1 = 1.5 # float
num2 = 0.4 # negative float
Floats have limited precision and range relative to integers. Python adheres to the IEEE 754 doubleprecision floatingpoint standard which provides 17 significant decimal digits of precision.
Floats are useful for calculations that require fractional values, measuring continuous data, approximations, scientific computations and more.
Core Integer Operations
Now let’s explore some core math operations using integer data types in Python.
Addition
We can perform addition using the +
operator:
num1 = 10
num2 = 20
sum = num1 + num2
print(sum) # Output: 30
Subtraction
Subtraction is done using the 
operator:
num1 = 30
num2 = 10
difference = num1  num2
print(difference) # Output: 20
Multiplication
The *
operator is used to multiply integers:
num1 = 5
num2 = 2
product = num1 * num2
print(product) # Output: 10
Division
Integers are divided using the /
operator which returns a float:
num1 = 20
num2 = 5
quotient = num1 / num2
print(quotient) # Output: 4.0
To get an integer result, we can use integer division //
which discards the fraction:
num1 = 20
num2 = 5
quotient = num1 // num2
print(quotient) # Output: 4
Exponentiation
We can calculate powers using the **
operator:
num1 = 2
num2 = 5
result = num1 ** num2
print(result) # Output: 32
This covers the basic math operations on integers. Let’s now look at some additional integer features.
Additional Integer Features
Identity Testing
We can test if two integers refer to the same object in memory using the is
operator:
num1 = 500
num2 = 500
print(num1 is num2) # Output: True
num1 = 300
print(num1 is num2) # Output: False
Bitwise Operations
Integers support bitwise arithmetic with operators like &
(AND), 
(OR), ^
(XOR), >>
(right shift) etc. For example:
num1 = 5 # 0b0101
num2 = 3 # 0b0011
print(num1 & num2) # 0b0001 => 1
print(num1  num2) # 0b0111 => 7
print(num1 ^ num2) # 0b0110 => 6
Bitwise operations are useful for lowlevel flags, bitmasks, set logic and optimizations.
Random Numbers
We can generate random integers using the random
module:
import random
rand_int = random.randint(0, 10) # integer from 010
print(rand_int) # Output: 3
This is helpful for simulations, games, sampling, and security applications.
Type Conversion
Integers can be converted to floats and vice versa:
num1 = 5
float_num = float(num1)
print(float_num) # Output: 5.0
float_num = 6.7
int_num = int(float_num)
print(int_num) # Output: 6
Explicit conversion is required when mixing integer and float operations.
This covers some key integer functions available in Python. Next, we’ll explore using floats for fractional values.
Core Float Operations
Now let’s look at some common math operations using floats in Python.
Addition
Floats can be added just like integers:
num1 = 1.5
num2 = 2.0
sum = num1 + num2
print(sum) # Output: 3.5
Subtraction
Subtraction works the same way as for integers:
num1 = 3.5
num2 = 2.5
diff = num1  num2
print(diff) # Output: 1.0
Multiplication
We simply use the *
operator:
num1 = 2.5
num2 = 6.4
product = num1 * num2
print(product) # Output: 16.0
Division
The /
operator provides float division:
num1 = 6.0
num2 = 3.0
quotient = num1 / num2
print(quotient) # Output: 2.0
Exponentiation
Float powers are computed with **
:
num1 = 5.0
num2 = 2.0
result = num1 ** num2
print(result) # Output: 25.0
This covers the basic float math operations. Let’s look at some additional float features.
Additional Float Features
Rounding
The round()
function rounds floats to the nearest integer:
num = 3.75
print(round(num)) # Output: 4
We can specify number of decimals to round to:
num = 1.274
print(round(num, 2)) # Output: 1.27
Float Precision
Floats have limited precision due to how they are stored. Operations can lead to small errors:
num = 0.1 + 0.2
print(num) # Output: 0.30000000000000004
This needs to be handled if precision is critical.
Infinity and NaN
Dividing by 0 results in infinity:
print( 5.0 / 0) # Output: inf
Invalid operations return NaN (not a number):
print(0.0 / 0.0) # Output: nan
These special values need additional handling.
Type Conversion
We can convert between floats and integers:
num1 = 1.5
num2 = int(num1)
print(num2) # Output: 1
Explicit conversion is required when mixing types.
This covers some key capabilities of floats in Python. Next, we’ll explore how to represent numeric data.
Representing Numeric Data
When programming with numbers, we need to store and represent different types of numeric data efficiently. Here are some ways to do that in Python:
Integers
Integers are best for counting, ids, enumerations:
count = 0
user_id = 12345
status = 1 # enum
Floats
Use floats for measurements, metrics, percentages, approximations:
price = 9.99
temperature = 98.6
sales_tax = 0.0825 # 8.25%
pi = 3.141592 # approximation
Complex Numbers
Complex numbers have real and imaginary parts represented with j
:
complex_num = 5 + 2j
print(complex_num.real) # Output: 5.0
print(complex_num.imag) # Output: 2.0
Useful for many scientific and engineering applications.
Fractions
The fractions
module provides fractional values:
import fractions
f = fractions.Fraction(2, 3)
print(f) # Output: 2/3
Exact representations of rational numbers as fractions.
Decimals
The decimal
module supports highprecision decimal numbers:
from decimal import Decimal
num = Decimal('0.1')
print(num + Decimal('0.2')) # Output: 0.3
Avoids float rounding errors for currency or other cases requiring exact decimal values.
NumPy Arrays
NumPy provides fast vectorized operations on ndimensional arrays:
import numpy as np
arr = np.array([1, 2, 3])
print(arr + 5) # Output: [6 7 8]
Great for linear algebra, matrix math, signal processing, data science.
This covers various ways to represent different types of numeric data using Python’s tools.
Handling Numeric Data
When working with numeric data in Python, proper handling is required in certain cases. Here are some best practices:
Avoid Mixing Types
Be explicit when converting between int, float and other types to avoid errors:
num1 = 1.5 #float
num2 = 2 #integer
# Wrong:
print(num1 + num2) # Error
# Correct:
print(num1 + float(num2)) # Output: 3.5
Handle Rounding Errors
Use decimal module, rounding or int conversion to control float precision:
from decimal import Decimal
float_num = 0.1 + 0.2
decimal_num = Decimal('0.1') + Decimal('0.2')
print(float_num) # 0.30000000000000004
print(decimal_num) # 0.3
Check for Overflow
Check if results exceed system int or float limits:
import sys
print(sys.maxsize) # Max int size
print(sys.float_info.max) # Max float
Use arbitrary precision libraries to avoid overflow.
Handle Infinity/NaN
Check for divide by zero, invalid operations that create NaN or Infinity values:
x = 5.0/0
print(x) # inf
print(x == float('inf')) # True
Handle these special cases appropriately.
Simplify Expressions
Use parentheses to simplify numerical expressions and control order of operations:
x = (2*3) + (4*5) #14 + 20 = 34
y = 2*3 + 4*5 # 6 + 20 = 26
This helps improve readability and prevent logic errors.
Properly handling numeric data will make programs more robust and errorfree when performing mathematical calculations.
Practical Examples and Use Cases
Let’s now look at some practical code examples that demonstrate realworld usage of numeric data types in Python:
Calculating ROI
Using integers and floats to calculate return on investment (ROI):
investment = 25000 # dollars
revenue = 30000 # dollars
profit = revenue  investment
roi = (profit/investment) * 100
print(roi) # Output: 20.0
Game Health Points
Using integers to represent health for a video game character:
max_hp = 100
hp = max_hp
print(hp) # Output: 100
# Take damage
hp = hp  20
print(hp) # Output: 80
# Heal
hp = hp + 50
print(hp) # Output: 100
BMI Calculator
Floating point BMI calculation based on weight and height inputs:
weight = 65.5 # kg
height = 1.7 # meters
bmi = weight / (height ** 2)
print(bmi) # Output: 22.68
Population Growth
Modeling exponential population growth with floats:
pop_size = 10000
growth_rate = 1.5%
result = pop_size
for i in range(10):
result = result * (1 + growth_rate)
print(round(result)) # Output: 16529
These are some examples of how numeric data types are used in real Python programs.
Conclusion
In this comprehensive guide, we explored the core concepts and techniques for working with numeric data types in Python, including:
 Integer and floating point number types
 Mathematical operations on integers and floats
 Additional number features like rounding, precision, overflow handling
 Techniques for representing different numeric data
 Best practices for properly handling numeric values
 Practical examples and use cases
Python provides powerful tools through its numeric programming capabilities. Understanding integers and floats is essential knowledge for any Python developer working on math, science, analytics, finance, and many other domains.
With the foundation covered in this guide, you should now be able to confidently implement numeric programming techniques to build more robust and functional applications in Python.