Variables, Mutation & CPython Object Caching

State bugs in Python rarely stem from exotic language features; they stem from misunderstanding object aliasing, mutation, and CPython’s aggressive object caching. In Python, assignment never copies data. It only binds a name to an object reference.

This chapter details reference counting, the difference between mutating a payload versus rebinding a pointer, and how CPython silently caches singletons to save memory.

1. Identity vs. Equality

When dealing with objects, Python relies on two different comparison protocols:

Equality (==): Invokes the __eq__ dunder method on the object to compare the actual values (the payload of the PyObject).
Identity (is): Compares the raw C memory addresses (pointers) of the two objects.

list_a = [1, 2, 3]
list_b = [1, 2, 3]

print(list_a == list_b)  # True (Values match)
print(list_a is list_b)  # False (Distinct memory allocations)

2. Visual Mental Model: Aliasing & Rebinding

Assigning a variable to another variable creates an alias—two names pointing to the exact same memory address.

Aliasing (a = b):
[ Symbol Table ]
 "list_a" ---->  [ PyListObject @ 0x22F4 ] <---- "list_b"

Mutating the shared object (list_a.append(4)):
 "list_a" ---->  [ PyListObject @ 0x22F4 ] (Now contains [1, 2, 3, 4])
 "list_b" ---->  (Sees the same mutation)

Rebinding changes where a name points, decrementing the ob_refcnt of the old object and incrementing it for the new object.

Rebinding (list_a = ["new"]):
 "list_a" ---->  [ PyListObject @ 0x99B1 ] (Contains ["new"])
 "list_b" ---->  [ PyListObject @ 0x22F4 ] (Still contains [1, 2, 3, 4])

3. CPython Object Caching (Interning)

To avoid excessive heap allocations for commonly used primitives, CPython implements several internal caches:

Small Integer Caching: At startup, CPython pre-allocates an array of PyLongObject structs for integers ranging from -5 to 256. Any time your code evaluates to an integer in this range, CPython returns a pointer to the cached singleton rather than allocating a new object.
String Interning: Short strings (especially identifiers like variable names and dict keys) are often “interned” via PyUnicode_InternInPlace(). Only one instance of an interned string exists in memory.
Empty Tuple Singleton: There is only one empty tuple object () in the entire VM.

x = 256
y = 256
print(x is y)  # True! Pointing to the same cached singleton

a = 257
b = 257
print(a is b)  # False! Outside the cache range (in REPL, though compiler optimizations may vary in scripts)

4. Garbage Collection: Refcounting & Cyclic GC

CPython relies primarily on Reference Counting (ob_refcnt). When a variable is deleted or goes out of scope, the counter drops. If it hits 0, the C-level memory deallocator (tp_dealloc) is called immediately.

However, reference counting cannot detect circular references (e.g., a list containing itself). To solve this, CPython includes a secondary Generational Cyclic Garbage Collector that periodically scans objects tracked by the PyGC_Head doubly-linked list, resolving isolated cycles.

⚡

Revision Mode Active Condensed for 5-minute review. Focused on 30-second pitches, mental anchors, and high-frequency interview traps.

⚡ 30-Second Elevator Pitch

“In Python, assignment binds a name to a memory pointer; it never copies data. Equality (==) compares the payload via __eq__, while identity (is) compares raw memory addresses. CPython aggressively caches small integers (-5 to 256) and interns strings to save memory. Memory management is primarily handled by immediate deterministic reference counting (ob_refcnt), backed by a generational cyclic garbage collector to clean up circular references.”

🧠 Under The Hood & Mental Model

Aliasing vs Mutation: Mutating changes the C-struct payload in place. Rebinding changes the symbol table pointer to a completely new object.
Small Integer Array: CPython pre-allocates -5..256. Evaluating these numbers simply grabs the singleton pointer.
ob_refcnt: Memory is freed deterministically the instant a reference count hits zero, ensuring predictable resource cleanup.
Cyclic GC: Only container objects (lists, dicts, instances) that can form cycles are tracked by the secondary generational GC (PyGC_Head).

💻 High-Yield Code & Gotcha

⚠️ GOTCHA: The Augmented Assignment Tuple Trap

Tuples are immutable, meaning their ob_item pointers cannot change. However, if a tuple contains a mutable object (like a list), you can mutate the list. The += operator (INPLACE_ADD) calls list.extend() and then attempts to re-assign the list back to the tuple index.

# ❌ ANTI-PATTERN: Augmented assignment on a mutable item inside an immutable tuple
t = ([1, 2],)

try:
    t[0] += [3, 4]
except TypeError as e:
    print("Caught TypeError:", e)

# THE GOTCHA: Even though a TypeError was raised, the list WAS MUTATED!
print(t)

# ✅ PRODUCTION PATTERN: Separate mutation from rebinding
t = ([1, 2],)
t[0].extend([3, 4])  # Mutates safely in place without triggering a tuple assignment error
print(t) # ( [1, 2, 3, 4], )

⚖️ Trade-Offs & Comparison

+ Reference Counting: Immediate and deterministic cleanup. When a file object loses its last reference, it is closed immediately, unlike tracing GCs (Java/V8) where cleanup is delayed.
- Reference Counting: Modifying ob_refcnt on every assignment requires a memory write barrier and locks up concurrent execution, making it the primary reason the Global Interpreter Lock (GIL) exists.

Python Interview Handbook