Numbers & Math in Python

Welcome to the world of numbers and mathematics in Python! Whether you're calculating simple sums or working on complex algorithms, understanding how Python handles numbers and math operations is essential. In this lesson, we'll explore the fundamental numeric types, common arithmetic operations, and some useful math functions — all through practical examples to get you coding confidently.

Python treats numbers as first-class citizens, making it both intuitive and powerful for beginners and pros alike. As you progress, you'll see how Python's flexibility with numbers opens doors to countless applications — from finance to game development and data science.

Understanding Python's Numeric Types

Python primarily supports three numeric types:

• int — Integer values, e.g., 42, -7.
• float — Floating-point (decimal) numbers, e.g., 3.14, -0.001.
• complex — Complex numbers with real and imaginary parts, e.g., 2 + 3j.

Let’s see these in action:

a = 7        # int
b = 3.14     # float
c = 1 + 2j   # complex

print(type(a))  # <class 'int'>
print(type(b))  # <class 'float'>
print(type(c))  # <class 'complex'>

Note: Python integers can be arbitrarily large, unlike many languages with fixed integer sizes.

Basic Arithmetic Operators

Python supports all the classic arithmetic operations:

• + Addition
• - Subtraction
• * Multiplication
• / Division (always returns a float)
• // Floor division (division but rounds down to nearest integer)
• % Modulus (remainder after division)
• ** Exponentiation (power)

Here’s how each one works:

x = 15
y = 4

print(f"Addition: {x + y}")       # 19
print(f"Subtraction: {x - y}")    # 11
print(f"Multiplication: {x * y}") # 60
print(f"Division: {x / y}")       # 3.75 (float)
print(f"Floor Division: {x // y}")# 3 (integer)
print(f"Modulus: {x % y}")        # 3 (remainder)
print(f"Exponentiation: {x ** y}")# 50625 (15^4)

💡 Tip: Use floor division // when you want integer division without decimals, such as counting whole items.

Mixing Types: int and float

Python automatically promotes integers to floats when needed in expressions. For example, dividing two integers with / always results in a float. This behavior helps prevent unexpected loss of precision.

a = 7       # int
b = 2.0     # float

result = a + b
print(result)         # 9.0 (float)
print(type(result))   # <class 'float'>

result2 = a / 2
print(result2)        # 3.5 (float)

This automatic type conversion is called type coercion and is very helpful to avoid needless errors.

Using the math Module for Advanced Math

Python’s built-in math module provides many useful functions and constants for more advanced mathematical operations:

• math.sqrt(x) — square root
• math.pow(x, y) — power function (alternative to **)
• math.sin(x), math.cos(x), math.tan(x) — trigonometric functions (x in radians)
• math.pi — π constant
• math.e — Euler’s number
• math.floor(x), math.ceil(x) — floor and ceiling functions

import math

print("Square root of 16:", math.sqrt(16))
print("5 to the power of 3:", math.pow(5, 3))
print("Value of pi:", math.pi)
print("sin(π/2):", math.sin(math.pi / 2))
print("Floor of 3.7:", math.floor(3.7))
print("Ceiling of 3.1:", math.ceil(3.1))

Using math.pow returns a float, while the ** operator preserves integer types if possible. For example, 2 ** 3 returns 8 (int), but math.pow(2, 3) returns 8.0 (float).

Working with Complex Numbers

Python’s complex type lets you work with numbers having real and imaginary parts, useful in fields like engineering and signal processing.

Here’s how to create and operate on complex numbers:

z1 = 3 + 4j
z2 = 1 - 2j

# Addition
print("z1 + z2 =", z1 + z2)

# Multiplication
print("z1 * z2 =", z1 * z2)

# Real and imaginary parts
print("Real part of z1:", z1.real)
print("Imaginary part of z1:", z1.imag)

# Magnitude (absolute value)
print("Magnitude of z1:", abs(z1))

Python makes complex arithmetic straightforward — try experimenting with these operations to get comfortable.

Rounding Numbers and Precision

Sometimes you need to round numbers to a specific number of decimal places. Python provides the built-in round() function for this:

num = 3.1415926535

print(round(num, 2))  # 3.14
print(round(num, 4))  # 3.1416
print(round(num))     # 3 (rounds to nearest integer)

⚠️ Important: Due to binary floating-point representation, some decimal fractions can’t be represented exactly, which can cause small precision errors. For example:

print(0.1 + 0.2 == 0.3)  # False
print(0.1 + 0.2)          # 0.30000000000000004

If you require exact decimal arithmetic (e.g., for financial calculations), consider using the decimal module instead.

Built-in Numeric Functions

Python provides several built-in functions useful when working with numbers:

• abs(x) — returns absolute value
• pow(x, y[, z]) — power function, pow(x, y, z) computes (x^y) mod z
• divmod(x, y) — returns quotient and remainder as a tuple
• min(), max() — find the smallest or largest value

print(abs(-7))           # 7
print(pow(2, 5))          # 32
print(pow(2, 5, 13))      # 6 (modular exponentiation)
print(divmod(17, 5))      # (3, 2)
print(min(3, 7, 1, 9))   # 1
print(max(3, 7, 1, 9))   # 9

Practice with Examples: Putting It All Together

Let's write a small program to calculate the area of a circle using the radius input. We'll use Python’s math module and numeric operations:

import math

def circle_area(radius):
    if radius <= 0:
        return 0
    return math.pi * (radius ** 2)

r = 5
area = circle_area(r)
print(f"Area of circle with radius {r}: {area:.2f}")

This example shows how numbers, operators, and functions combine to solve real problems.

Summary & Best Practices

• Use int for whole numbers, float for decimals, and complex for complex numbers.
• Remember division / always returns float; use // for integer division.
• Use the math module for advanced math functions and constants.
• Beware floating-point precision errors; for exact decimal arithmetic, use the decimal module.
• Practice combining numeric types and operations to strengthen your fluency with Python math.

Mastering numbers and math in Python will greatly empower your coding journey. Experiment with the examples above, tweak values, and try new math functions to build your confidence. In the next lessons, you’ll see how these fundamentals apply to real-world projects and data analysis.