Python Loops — Professional Level¶

import dis

def simple_for():
    result = []
    for i in range(10):
        result.append(i * 2)
    return result

dis.dis(simple_for)

import dis

def simple_while():
    i = 0
    while i < 10:
        i += 1
    return i

dis.dis(simple_while)

import dis

def list_comp():
    return [i * 2 for i in range(10)]

dis.dis(list_comp)

import dis

# Constant folding — computed at compile time
def const_fold():
    for i in range(10):
        x = 2 * 3 * 4  # Compiler computes 24 at compile time

dis.dis(const_fold)
# LOAD_CONST shows 24, not 2, 3, 4 separately

import dis
import timeit

x_global = 42

def loop_global():
    """Uses LOAD_GLOBAL — hash table lookup each time."""
    total = 0
    for i in range(1_000_000):
        total += x_global
    return total

def loop_local():
    """Uses LOAD_FAST — array index lookup (C array)."""
    x_local = 42
    total = 0
    for i in range(1_000_000):
        total += x_local
    return total

# LOAD_FAST is ~20-40% faster than LOAD_GLOBAL
# Because local variables are stored in a C array (f_localsplus)
# and accessed by index, while globals require dict lookup.

dis.dis(loop_global)  # Shows LOAD_GLOBAL
dis.dis(loop_local)   # Shows LOAD_FAST

import timeit

# O(1) membership test — computed arithmetically
print(999_999_999 in range(1_000_000_000))  # True, instant

# vs O(n) for a generator
# print(999_999_999 in (x for x in range(1_000_000_000)))  # Very slow

import sys
print(sys.getswitchinterval())  # 0.005 (5ms default)

# Tight CPU-bound loop — GIL is held for up to 5ms at a time
# Other threads are blocked during this time
def cpu_bound():
    total = 0
    for i in range(10_000_000):
        total += i * i
    return total

import threading
import time

def cpu_work(n: int) -> int:
    total = 0
    for i in range(n):
        total += i * i
    return total

N = 50_000_000

# Sequential — baseline
start = time.perf_counter()
cpu_work(N)
cpu_work(N)
sequential = time.perf_counter() - start

# Threaded — GIL prevents true parallelism
start = time.perf_counter()
t1 = threading.Thread(target=cpu_work, args=(N,))
t2 = threading.Thread(target=cpu_work, args=(N,))
t1.start(); t2.start()
t1.join(); t2.join()
threaded = time.perf_counter() - start

print(f"Sequential: {sequential:.2f}s")
print(f"Threaded:   {threaded:.2f}s")
# Threaded is often SLOWER due to GIL contention overhead!

import sys

# Each iteration: old reference is DECREF'd, new reference is INCREF'd
items = [object() for _ in range(5)]

for item in items:
    # At this point:
    # - 'item' holds a reference (refcount +1)
    # - items[i] still holds a reference
    print(sys.getrefcount(item))  # 3 (item, items[i], getrefcount arg)

# After the loop:
# 'item' still references the LAST element
print(sys.getrefcount(items[-1]))  # 3 (item, items[-1], getrefcount arg)

import sys
import tracemalloc

tracemalloc.start()

# Pattern 1: List — all objects alive simultaneously
snapshot1_start = tracemalloc.take_snapshot()
data_list = [i ** 2 for i in range(100_000)]
total_list = sum(data_list)
snapshot1_end = tracemalloc.take_snapshot()

# Pattern 2: Generator — one object at a time
snapshot2_start = tracemalloc.take_snapshot()
total_gen = sum(i ** 2 for i in range(100_000))
snapshot2_end = tracemalloc.take_snapshot()

# Compare memory
stats1 = snapshot1_end.compare_to(snapshot1_start, "lineno")
stats2 = snapshot2_end.compare_to(snapshot2_start, "lineno")

print("List approach top allocations:")
for stat in stats1[:3]:
    print(f"  {stat}")

print("Generator approach top allocations:")
for stat in stats2[:3]:
    print(f"  {stat}")

import dis

def typed_loop():
    total = 0
    for i in range(1000):
        total += i
    return total

# After warming up (executing several times), CPython replaces:
# BINARY_OP (+=)  ->  BINARY_OP_ADD_INT  (specialized for int+int)
# LOAD_FAST       ->  LOAD_FAST__LOAD_FAST (superinstruction)
# FOR_ITER        ->  FOR_ITER_RANGE (specialized for range)

# You can see specialization stats:
# python -X showstatistics script.py (Python 3.12+)

import dis
import sys

def gen_example():
    x = 10
    yield x    # Frame is suspended here
    x += 20
    yield x    # Frame is suspended here again
    return x

# The generator object holds a reference to the frame
g = gen_example()
print(type(g))  # <class 'generator'>
print(g.gi_frame)  # <frame at 0x...> — the suspended frame
print(g.gi_frame.f_locals)  # {} (not yet started)

next(g)  # Runs until first yield
print(g.gi_frame.f_locals)  # {'x': 10}

next(g)  # Runs until second yield
print(g.gi_frame.f_locals)  # {'x': 30}

try:
    next(g)  # Raises StopIteration with value 30
except StopIteration as e:
    print(f"Return value: {e.value}")  # 30
    print(g.gi_frame)  # None — frame is released

import dis

def delegator():
    yield from sub_gen()

def sub_gen():
    yield 1
    yield 2

dis.dis(delegator)
# Key opcode: SEND (Python 3.12) or GET_YIELD_FROM_ITER + YIELD_VALUE

"""
Benchmark comparing CPython and PyPy loop performance.
Run with both interpreters to see the difference.
"""
import time

def fibonacci_loop(n: int) -> int:
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

def matrix_multiply(n: int) -> list:
    A = [[i + j for j in range(n)] for i in range(n)]
    B = [[i * j for j in range(n)] for i in range(n)]
    C = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            for k in range(n):
                C[i][j] += A[i][k] * B[k][j]
    return C

# Benchmark
for name, func, args in [
    ("fibonacci(1M)", fibonacci_loop, (1_000_000,)),
    ("matrix_mul(100)", matrix_multiply, (100,)),
]:
    start = time.perf_counter()
    func(*args)
    elapsed = time.perf_counter() - start
    print(f"{name}: {elapsed:.3f}s")

# Typical results:
# CPython 3.12:  fibonacci: 0.120s, matrix: 0.450s
# PyPy 3.10:     fibonacci: 0.008s, matrix: 0.015s  (15-30x faster)
#
# PyPy's JIT compiler:
# 1. Traces the hot loop
# 2. Generates machine code with type specialization
# 3. Removes Python object overhead (unboxes integers)
# 4. Applies loop-invariant code motion
# 5. Eliminates bounds checks when safe