Numbers, Arithmetic and the Math Module

Python’s numeric types — int and float — behave similarly to their JavaScript counterparts but with some important differences. Python integers have unlimited precision — there is no maximum safe integer like JavaScript’s Number.MAX_SAFE_INTEGER. Python floats use 64-bit IEEE 754 double precision, the same as JavaScript, which means the same floating-point precision issues apply. Understanding Python’s arithmetic operators, integer division, the modulo operator, and when to use the decimal module for exact arithmetic is essential for building a FastAPI application that handles financial data, pagination calculations, and numeric validation correctly.

Python’s Numeric Types #

# int — whole numbers, unlimited precision
small     = 42
large     = 9_999_999_999_999_999   # underscores for readability
negative  = -17
hex_lit   = 0xFF                     # 255
bin_lit   = 0b1010                   # 10
oct_lit   = 0o17                     # 15

# float — 64-bit double precision
pi        = 3.14159265358979
sci_small = 1.5e-10                  # 0.00000000015
sci_large = 2.998e8                  # 299800000.0

# complex — Python supports complex numbers natively
c = 3 + 4j                           # real=3, imaginary=4
print(c.real, c.imag)                # 3.0 4.0

# Check if an int
isinstance(42, int)     # True
isinstance(3.14, int)   # False
isinstance(3.14, float) # True

Arithmetic Operators #

a, b = 17, 5

# Standard arithmetic
a + b    # 22  — addition
a - b    # 12  — subtraction
a * b    # 85  — multiplication
a ** b   # 1419857 — exponentiation (no Math.pow needed)

# Division — TWO types in Python
a / b    # 3.4   — true division (always returns float)
a // b   # 3     — floor division (integer result, rounds toward -infinity)

# Modulo
a % b    # 2     — remainder after floor division

# Augmented assignment (same as JS)
x = 10
x += 5    # x = 15
x -= 3    # x = 12
x *= 2    # x = 24
x //= 5   # x = 4  (floor division assignment)
x **= 3   # x = 64 (exponentiation assignment)

# Note: Python has no ++ or -- operators
# Use x += 1 instead of x++

Floor Division vs True Division #

# True division (/) — always returns float
10 / 2    # 5.0  (not 5!)
7 / 2     # 3.5
-7 / 2    # -3.5

# Floor division (//) — returns int (rounds toward -infinity)
10 // 2   # 5
7 // 2    # 3    (truncates toward -infinity)
-7 // 2   # -4   (rounds DOWN, not toward zero — different from JS Math.trunc!)

# Modulo (%) — remainder
17 % 5    # 2    (17 = 3×5 + 2)
-17 % 5   # 3    (Python modulo always has same sign as divisor)

# Practical uses
# Pagination: how many full pages of 10 items?
total_items = 47
items_per_page = 10
full_pages = total_items // items_per_page  # 4
remainder  = total_items % items_per_page   # 7

# Is a number even?
def is_even(n):
    return n % 2 == 0

# Is a number divisible by another?
def divisible_by(n, d):
    return n % d == 0

The math Module #

import math

math.sqrt(16)         # 4.0  — square root
math.ceil(3.2)        # 4    — ceiling (round up)
math.floor(3.9)       # 3    — floor (round down)
math.abs(-5)          # Note: use built-in abs(-5) = 5 instead
math.pow(2, 10)       # 1024.0 — exponentiation (returns float)
math.log(100, 10)     # 2.0  — log base 10
math.log(math.e)      # 1.0  — natural log
math.pi               # 3.141592653589793
math.e                # 2.718281828459045
math.inf              # infinity
math.isnan(float('nan'))  # True — check for NaN
math.isinf(math.inf)      # True — check for infinity

# Rounding
round(3.5)     # 4  (banker's rounding: rounds to even)
round(2.5)     # 2  (rounds to even — 2 is even)
round(3.456, 2)  # 3.46 — round to 2 decimal places

Floating-Point Precision and the Decimal Module #

# The floating-point problem (same in Python and JavaScript)
0.1 + 0.2          # 0.30000000000000004 — not 0.3!
0.1 + 0.2 == 0.3   # False — bug waiting to happen in financial code

# Workaround 1: round for display
round(0.1 + 0.2, 10) == round(0.3, 10)   # True

# Workaround 2: math.isclose() for comparisons
import math
math.isclose(0.1 + 0.2, 0.3)   # True — uses relative tolerance

# Workaround 3 (best for money): use Decimal
from decimal import Decimal, ROUND_HALF_UP

price    = Decimal("19.99")    # Always pass as string!
tax_rate = Decimal("0.10")
tax      = price * tax_rate    # Decimal("1.999")

# Round to 2 decimal places
total = (price + tax).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
print(total)   # 21.99

# Never do this — loses precision:
wrong = Decimal(0.1)   # Decimal('0.1000000000000000055511151231257827021181583404541015625')

Common Mistakes #

Mistake 1 — Expecting / to return an integer #

❌ Wrong — assuming division returns an int like Python 2:

result = 10 / 2
print(type(result))   # <class 'float'> — it's 5.0, not 5!

✅ Correct — use // for integer division:

result = 10 // 2   # 5 (int) ✓

Mistake 2 — Using float for monetary values #

❌ Wrong — float arithmetic for prices:

price = 19.99
tax   = price * 0.1
total = price + tax   # 21.988999999999997 — billing error!

✅ Correct — use Decimal for money:

from decimal import Decimal
price = Decimal("19.99")
tax   = price * Decimal("0.1")   # Decimal("1.999")
total = price + tax               # Decimal("21.989") — exact ✓

Mistake 3 — Using ++ for incrementing #

❌ Wrong — JavaScript increment operator:

count = 0
count++   # SyntaxError in Python

✅ Correct — augmented assignment:

count = 0
count += 1   # ✓

Quick Reference #