Arithmetic Operators & Internals

The Seven Arithmetic Operators

Deep Dive: Operator Overloading

Everything in Python—numbers, strings, lists—is an object. When you use an operator, you are actually calling a method on that object. This meant you can define how operators behave for your own custom classes.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # Overload the '+' operator
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    # Overload string representation for printing
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(2, 4)
v2 = Vector(1, 1)

# Python converts this to: v1.__add__(v2)
v3 = v1 + v2

print(v3)  # Vector(3, 5)

Why this matters

This "Data Model" is the secret sauce behind libraries like NumPy and Pandas. When you add two NumPy arrays, they don't loop through elements slowly in Python. They use the overloaded __add__ method to dispatch execution to highly optimized C code, making it thousands of times faster.

The Magic Method Trilogy: __add__, __radd__, __iadd__

Implementing __add__ is just the beginning. To make your custom objects truly behave like numbers (e.g., to support 10 + vector vs vector + 10), you need to understand the full protocol.

1. Forward Addition (__add__)

Called when your object is on the LEFT side of the +. (e.g., vector + 10 calls vector.__add__(10)).

2. Reverse Addition (__radd__)

What happens if you do 10 + vector? The integer 10 doesn't know how to add a Vector! Python sees that int.__add__ returns NotImplemented, so it flips the operation and callsvector.__radd__(10). This allows your custom objects to play nicely with built-in types.

3. In-Place Addition (__iadd__)

Called when you write vector += 10. This is critical for performance. If you don't implement this, Python just does x = x + y (creating a new object). For strict performance (like with big lists), __iadd__ should modify the object in place (return self) instead of creating a new one.

The Forgotten Operator: Unary Invert (~)

Most Python courses skip the tilde (~), but it's crucial for indexing and bitwise interactions. It performs a Bitwise NOT, which inverts all bits of the number.

x = 5   # Binary:  ...000101
inv = ~x # Binary: ...1111010 (Two's manual complement notation)

print(inv) # -6

# Why is this useful?
# It's perfect for symmetric indexing!
data = ['a', 'b', 'c', 'd', 'e']

print(data[0])   # 'a' (First)
print(data[~0])  # 'e' (Last)  -> data[-1]
print(data[1])   # 'b' (Second)
print(data[~1])  # 'd' (Second to last) -> data[-2]

Complex Numbers & Math Modules

Python is one of the distinct few languages with native support for Complex Numbers. Engineers use them for electrical engineering (AC circuits), signal processing (Fourier Transforms), and quantum computing.

# Syntax: real + imaginary 'j'
# Note: Mathematicians use 'i', but Engineers use 'j'. Python uses 'j'.

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

print(z1 + z2)      # (3+2j)
print(z1 * z2)      # (5+1j)

# Getting components
print(z1.real)      # 2.0
print(z1.imag)      # 3.0
print(abs(z1))      # 3.605... (Magnitude)

Performance Optimization: divmod()

Often in algorithms (like converting seconds to hours/minutes/seconds), you need both the quotient (//) and the remainder (%). Calculating them separately requires two division operations.

Python provides divmod(a, b) which returns a tuple (quotient, remainder) in one step. At the C level, this maps to a single CPU instruction on many architectures, making it twice as fast.

total_seconds = 3665

# The slow way
hours = total_seconds // 3600
remainder = total_seconds % 3600

# The fast way
hours, remainder = divmod(total_seconds, 3600)
minutes, seconds = divmod(remainder, 60)

print(f"{hours}h {minutes}m {seconds}s")

The Floating Point Nightmare

Every programmer eventually encounters this confusing behavior. You expect math to be exact, but computers disagree.

val = 0.1 + 0.2
print(val) 
# Output: 0.30000000000000004 😱

print(val == 0.3)
# Output: False

What is happening?

This is NOT a Python bug. It is a limitation of hardware. Computers interpret numbers in Base-2 (Binary). Just like 1/3 cannot be represented exactly in Base-10 (0.3333...), 0.1 cannot be represented exactly in Base-2. It becomes an infinitely repeating binary fraction logic.

When you add the slightly imprecise binary representation of 0.1 to 0.2, the tiny errors accumulate to form that ...0004 at the end.

import math

a = 0.1 + 0.2
b = 0.3

# Check if they are "close enough" (within distinct tolerance)
if math.isclose(a, b):
    print("They match!")  # This prints!

Special Values: Infinity and NaN

Floating point numbers have special states for "Infinity" and "Not a Number". These are valid float values and follow their own mathematical logic.

# Creating Infinity
pos_inf = float('inf')
neg_inf = float('-inf')

print(pos_inf > 1000000000)  # True
print(pos_inf + 100)         # inf (Infinity eats additions)
print(pos_inf * 2)           # inf

# NaN (Not a Number)
impossible = float('nan')
print(impossible == impossible)  # False! NaN is never equal to itself.
print(math.isnan(impossible))    # True (The only way to check)

Exact Math: The Fraction Module

If you hate floating point errors and need perfect precision (like in specialized engineering or music theory applications), Python's fractions module allows you to do math with rational numbers.

from fractions import Fraction

f1 = Fraction(1, 3)  # 1/3
f2 = Fraction(1, 2)  # 1/2

result = f1 + f2
print(result)        # 5/6 (Perfectly exact!)
print(float(result)) # 0.833333...

# Solving the 0.1 issue
exact_val = Fraction('0.1') + Fraction('0.2')
print(exact_val)     # 3/10

Modulo: The Negative Number Trap

The Modulo operator (%) returns the remainder of division. However, different programming languages handle negative numbers differently.

Python's rule: The result of the modulo always has the same sign as the divisor.

# Positive is simple
print(10 % 3)    # 1

# Negative Operand
print(-10 % 3)   # 2 (Result is positive, like divisor 3)
print(10 % -3)   # -2 (Result is negative, like divisor -3)

# In C or Java, -10 % 3 would be -1.
# This makes Python strictly mathematically correct for "clock arithmetic".

Advanced Power: Modular Exponentiation

Calculating massive powers is computationally expensive. If you try to calculate base ** exp where numbers have hundreds of digits, your RAM will explode.

However, in cryptography (like RSA algorithms), we constantly need to calculate (base ** exp) % mod. Python provides a built-in function for this that is insanely optimized: pow(base, exp, mod).

base = 123456789
exp = 987654321
mod = 1000000007  # Standard prime for competitive programming

# ❌ The Slow Way
# result = (base ** exp) % mod
# This first calculates a number with MILLIONS of digits, then modulo. Too slow.

# ✅ The Fast Way
result = pow(base, exp, mod)
# This applies modulo at every multiplication step, keeping numbers small.
# It runs in milliseconds.

The Matrix Multiplication Operator (@)

Introduced in Python 3.5 (PEP 465), the @ operator is unique. It is the only arithmetic operator dedicated to Linear Algebra. Unlike * which performs element-wise multiplication (like [1, 2] * [2, 3] = [2, 6] in NumPy),@ performs dot products or matrix-matrix multiplication.

While vanilla Python lists don't support it by default, understanding it is mandatory for Data Science.

class Matrix:
    def __init__(self, value):
        self.value = value

    def __matmul__(self, other):
        # This is where you'd implement dot product math
        return f"Multiplying Matrix({self.value}) with Matrix({other.value})"

A = Matrix(5)
B = Matrix(10)

print(A @ B)  # Calls A.__matmul__(B)
# Output: "Multiplying Matrix(5) with Matrix(10)"

The Augmented Assignment Trap (+=)

Operators like +=, -=, and *= are called "Augmented Assignment". They look like syntax sugar for x = x + 1, but they behave differently for Mutable vs Immutable objects.

1. Immutable (Integers, Strings, Tuples)

For immutable types, x += y is exactly x = x + y. Python calculates the result, creates a NEW object, and rebinds the variable x to it.

2. Mutable (Lists, Dictionaries)

For mutable types, x += y calls __iadd__ (In-Place Add). The list modifies ITSELF. The memory address (id(x)) stays the same. This distinction causes the infamous "Tuple Trap".

# A tuple (immutable) containing a list (mutable)
t = ([1, 2], [3, 4])

# Try to modify the list inside the tuple
try:
    t[0] += [3]
except TypeError as e:
    print(f"Error: {e}") 
    # Tuple complains: "tuple object does not support item assignment"

# BUT LOOK AT THE DATA!
print(t)  # ([1, 2, 3], [3, 4]) 😱
# The modification happened (!), THEN the assignment failed.

# Why?
# 1. t[0] accessed the list.
# 2. list += [3] modified the list in-place (Success).
# 3. Python tried to assign the result BACK to t[0] (t[0] = result).
# 4. Tuple said "No assignment allowed!".

The Rounding Rumble: Integers from Floats

Converting a float like 3.7 to an integer seems simple, but there are four distinct ways to do it in Python, and picking the wrong one causes financial bugs.

1. Truncation (`int()`)

Simply chops off the decimal part. Moves towards zero.

2. Floor (`math.floor()`)

Moves towards negative infinity. (Crucial for negative numbers!).

3. Ceiling (`math.ceil()`)

Moves towards positive infinity.

4. Rounding (`round()`) - The Danger Zone ⚠️

Python 3 uses "Bankers Rounding" (Round Half to Even).round(0.5) is 0, but round(1.5) is 2. This minimizes cumulative error in large sums, but confuses everyone else.

import math

val = 3.7
neg = -3.7

# 1. int() - Truncate
print(int(val))      # 3
print(int(neg))      # -3 (Note: different direction than floor!)

# 2. floor() - Down
print(math.floor(val)) # 3
print(math.floor(neg)) # -4 (Lower than -3.7)

# 3. ceil() - Up
print(math.ceil(val))  # 4
print(math.ceil(neg))  # -3

# 4. round() - Bankers Rounding
print(round(2.5))    # 2 (Nearest Even!)
print(round(3.5))    # 4 (Nearest Even!)
print(round(2.6))    # 3 (Standard)

The `math` Module Powerhouse

Python's built-in operators are just the tip of the iceberg. For serious calculations, the standard library math module offers optimized C implementations of common algorithms. Using these is not just about convenience; it's about correctness.

1. Precision Summation (`math.fsum`)

Adding many floats together accumulates error. `sum()` is fast but naive. `math.fsum()` tracks partial sums to maintain precision.

# The floating point error accumulation
values = [0.1] * 10
print(sum(values))        # 0.9999999999999999 ❌
print(math.fsum(values))  # 1.0 ✅

2. Integer Square Root (`math.isqrt`)

New in Python 3.8. If you need the integer part of a square root, don't use int(math.sqrt(x)). It converts to float and back, losing precision for huge numbers. `isqrt` stays in integer land.

3. Number Theory (`gcd`, `lcm`)

Essential for cryptographic algorithms and fraction math.

print(math.gcd(8, 12))  # 4
print(math.lcm(8, 12))  # 24 (Python 3.9+)

4. Useful Constants

Never type `3.14159` manually.

print(math.pi)   # 3.141592653589793
print(math.e)    # 2.718281828459045
print(math.tau)  # 6.28318... (2 * pi)

Performance Lab: Bitwise vs Arithmetic

A common optimization trick in C/C++ is to use Bitwise Left Shift (<<) instead of multiplication by 2. Does this hold true in Python?

import timeit

# Multiplying by 2
print(timeit.timeit('x = 100 * 2', number=10000000))
# Output: ~0.11 seconds

# Shifting left by 1 (Equivalent to *2)
print(timeit.timeit('x = 100 << 1', number=10000000))
# Output: ~0.11 seconds

# Verdict: No significant difference!

Why? Python's overhead interpretation cost dwarfs the CPU cycle difference between MUL and SHL instructions. However, for massive integers (thousands of digits), bitwise operations can be significantly faster because they operate directly on the underlying bits without complex carry-over logic.

Operator Precedence & Associativity Chart

When you write 2 + 3 * 4 ** 2, Python essentially sees a tree structure. Knowing the "Binding Power" of each operator is the only way to predict the result.

# Goal: A function that returns x + 1, then multiply result by 5
# ❌ WRONG
f = lambda x: x + 1 * 5
print(f(2))  # 7  (Evaluated as x + (1*5) -> 2 + 5)

# ✅ CORRECT
f = lambda x: (x + 1) * 5
print(f(2))  # 15 (Evaluated as (2+1) * 5)