Bytecode & How CPython Runs Your Code

import dis

def total_marks(marks):
    total = 0
    for m in marks:
        total += m
    return total

dis.dis(total_marks)
#   LOAD_CONST     1 (0)          ← push 0
#   STORE_FAST     1 (total)      ← total is slot 1: array access, fast
#   LOAD_FAST      0 (marks)
#   GET_ITER
#   FOR_ITER      ...
#   LOAD_FAST      1 (total)      ← load, add, store: three separate steps
#   LOAD_FAST      2 (m)
#   BINARY_OP     13 (+=)
#   STORE_FAST     1 (total)      ← a thread could be switched mid-sequence:
#   ...                             this is WHY += is not atomic

import math
def use_global():  return math.pi        # LOAD_GLOBAL — dict lookups
def use_local():
    pi = math.pi                         # bind once...
    return pi                            # LOAD_FAST — array index

# __pycache__/utils.cpython-312.pyc  ← compiled bytecode cache
#   - created on first import, reused while source is unchanged
#   - source mtime/hash checked → edit .py and it recompiles automatically
#   - version-tagged: 3.12 and 3.13 caches coexist side by side
#   - this is compile-to-bytecode caching, NOT machine-code compilation

# The specializing adaptive interpreter (PEP 659, Python 3.11+):
def add(a, b):
    return a + b

for _ in range(100):
    add(2, 3)
# After warm-up, generic BINARY_OP specializes to BINARY_OP_ADD_INT —
# a fast path that skips type dispatch while both args stay ints.
# Specializations deoptimize automatically if types change: add("a", "b") still works.

# Practical takeaways:
#   - Upgrading 3.10 → 3.12 is often a free 25-60% speedup
#   - Type-stable hot loops (same types every iteration) specialize best
#   - python -X importtime app.py   → per-module import cost breakdown
#   - Python 3.13+: experimental copy-and-patch JIT builds on these tiers