Making Python Fast: Profiling & Optimization¶

import cProfile, pstats, timeit, io

# ── timeit: precise timing for small code snippets ────────────────────────────
# timeit runs the snippet many times to get a stable measurement

# Command line (most convenient):
# python -m timeit "sum(range(1000))"
# python -m timeit -n 10000 "sorted(range(100))"

# In code:
time_sum = timeit.timeit("sum(range(1000))", number=10_000)
# Returns total seconds for 10,000 runs; divide by 10_000 for per-run time

# Compare two implementations:
time_list  = timeit.timeit("[x**2 for x in range(1000)]", number=1000)
time_gen   = timeit.timeit("sum(x**2 for x in range(1000))", number=1000)

# ── cProfile: full call graph profiling ──────────────────────────────────────
# Profile a function call, print top 10 functions by cumulative time
def expensive():
    total = 0
    for i in range(100_000):
        total += len(str(i))    # lots of small operations
    return total

# Method 1: one-liner
cProfile.run("expensive()")

# Method 2: capture and format
pr = cProfile.Profile()
pr.enable()
expensive()
pr.disable()

stream = io.StringIO()
stats  = pstats.Stats(pr, stream=stream)
stats.sort_stats("cumulative")
stats.print_stats(10)           # top 10 by cumulative time
print(stream.getvalue())

# Method 3: profile decorator
import functools
def profile(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        pr = cProfile.Profile()
        pr.enable()
        result = func(*args, **kwargs)
        pr.disable()
        pr.print_stats(sort="cumulative")
        return result
    return wrapper

# ── line_profiler: line-by-line timing (install: pip install line_profiler) ──
# @profile  ← adds profiling; run: kernprof -l -v script.py
# def my_function():
#     result = []           # Line 1: 0.001s  0.1%
#     for x in data:        # Line 2: 0.011s  1.1%
#         result.append(x)  # Line 3: 0.900s  89.9%  ← HOTSPOT
#     return result

from functools import cache, lru_cache
import timeit

# ── functools.cache: unbounded memoization ────────────────────────────────────
@cache
def fibonacci(n: int) -> int:
    """Classic example: exponential without cache, linear with cache."""
    if n <= 1: return n
    return fibonacci(n-1) + fibonacci(n-2)

fibonacci(50)   # computed in microseconds; without cache: 2^50 calls

# ── functools.lru_cache: bounded cache with eviction ─────────────────────────
@lru_cache(maxsize=256)  # keep at most 256 results; evicts LRU on overflow
def fetch_user_profile(user_id: int) -> dict:
    """Expensive DB/API call — cache the results."""
    # simulate expensive operation
    import time; time.sleep(0.1)
    return {"id": user_id, "name": f"User {user_id}"}

# First call: executes the function
fetch_user_profile(42)   # ~0.1s
# Second call: returns cached result
fetch_user_profile(42)   # ~0.0001s

print(fetch_user_profile.cache_info())
# CacheInfo(hits=1, misses=1, maxsize=256, currsize=1)

# ── Real-world: caching config or API responses ───────────────────────────────
_config_cache: dict = {}

def get_config(key: str) -> str:
    """Read config once per key, cache it."""
    if key not in _config_cache:
        _config_cache[key] = expensive_config_read(key)
    return _config_cache[key]

# ── When NOT to cache ─────────────────────────────────────────────────────────
# - Functions with side effects (writes to DB, sends emails)
# - Functions with mutable arguments (lists, dicts — not hashable anyway)
# - Functions where the result changes over time (current time, DB state)
# - When memory is the bottleneck (unbounded cache may cause OOM)

import numpy as np
import timeit

n = 1_000_000

# Python loop: ~100ms for 1M elements
def python_sum_squares(data):
    return sum(x * x for x in data)

data_list = list(range(n))
data_np   = np.arange(n, dtype=np.float64)

# NumPy vectorized: ~1ms for 1M elements (100× faster)
def numpy_sum_squares(arr):
    return np.sum(arr * arr)

t_python = timeit.timeit(lambda: python_sum_squares(data_list), number=10)
t_numpy  = timeit.timeit(lambda: numpy_sum_squares(data_np),   number=10)

print(f"Python: {t_python:.3f}s   NumPy: {t_numpy:.3f}s   "
      f"speedup: {t_python/t_numpy:.0f}x")
# Python: 0.912s   NumPy: 0.009s   speedup: 101x

# ── Key NumPy patterns ────────────────────────────────────────────────────────
arr = np.array([1, 4, 9, 16, 25], dtype=float)

arr * 2                         # element-wise: [2, 8, 18, 32, 50]
np.sqrt(arr)                    # element-wise sqrt: [1, 2, 3, 4, 5]
arr[arr > 10]                   # boolean mask: [16, 25]
arr.sum()                       # 55.0
arr.mean()                      # 11.0
np.where(arr > 10, arr, 0)     # conditional: [0, 0, 0, 16, 25]

# Matrix operations
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
A @ B                           # matrix multiply: [[19, 22], [43, 50]]
A.T                             # transpose

import cProfile
from functools import lru_cache

# STEP 1: Write clear, correct code first — don't pre-optimize
def find_common_customers(orders: list[dict], returns: list[dict]) -> list[str]:
    """Find customers who both ordered AND returned something."""
    common = []
    for order in orders:
        for ret in returns:
            if order["customer_id"] == ret["customer_id"]:
                if order["customer_id"] not in common:
                    common.append(order["customer_id"])
    return common
# Correct, but O(n*m) time and O(n) membership check — O(n²m) overall

# STEP 2: Profile it — find the bottleneck is the nested loop
# (results would show find_common_customers consuming 95% of time)

# STEP 3: Fix the algorithm — O(n+m) with sets
def find_common_customers_fast(orders: list[dict], returns: list[dict]) -> list[str]:
    """Same result, O(n+m) via set intersection."""
    order_customers  = {o["customer_id"] for o in orders}
    return_customers = {r["customer_id"] for r in returns}
    return sorted(order_customers & return_customers)   # O(min(n,m))

# STEP 4: Measure the improvement
import timeit
orders  = [{"customer_id": i % 10000} for i in range(50_000)]
returns = [{"customer_id": i % 8000}  for i in range(20_000)]

slow = timeit.timeit(lambda: find_common_customers(orders, returns), number=1)
fast = timeit.timeit(lambda: find_common_customers_fast(orders, returns), number=10)

print(f"Slow: {slow:.3f}s   Fast: {fast/10:.4f}s   Speedup: {slow/(fast/10):.0f}x")