I wrote a class in Python with num_instances = 0 and expected it to reset every time a new object was created.
It didn't. Here's why — and it completely changed how I think about memory. 🧠
The code that confused me
class ObjectCounter:
num_instances = 0 # I thought this resets every time
def __init__(self):
ObjectCounter.num_instances += 1
obj1 = ObjectCounter() # num_instances = 1
obj2 = ObjectCounter() # num_instances = 2
# Never reset to 0. Why??
My assumption was wrong. num_instances = 0 does NOT run on every object creation. It runs once — when Python first reads the class definition.
Think of the class body like a blueprint being drawn once. The
__init__is the construction happening each time. The blueprint is never redrawn.
Diagram 1 — What actually happens step by step
[ Class defined ] ──► [ obj1 = ObjectCounter() ] ──► [ obj2 = ObjectCounter() ]
num_instances = 0 __init__ runs __init__ runs
runs ONCE here count = 1 count = 2
lives in class memory mutates class attribute counter keeps growing
vs a function:
num = 0 → created fresh on every call → dies when function returns → always resets to 0
Diagram 2 — Stack vs Heap: where things actually live
┌─────────────────────────────┐ ┌──────────────────────────────────────┐
│ STACK MEMORY │ │ HEAP MEMORY │
│ Function calls & locals │ │ Classes, objects, lists, dicts │
│ │ │ │
│ ┌─────────────────────┐ │ │ ┌──────────────────────────────┐ │
│ │ main() │ │ │ │ ObjectCounter (class object) │ │
│ │ x, y, z → born & │ │ │ │ __dict__: {num_instances: 2} │ │
│ │ die here │ │ │ │ Stays alive entire program │ │
│ └─────────────────────┘ │ │ └──────────┬──────────┬─────────┘ │
│ │ │ ▲ ▲ │
│ ┌─────────────────────┐ │ │ ┌─────────┴──┐ ┌───┴────────┐ │
│ │ my_function() │ │ │ │ obj1 │ │ obj2 │ │
│ │ num = 0 │ │ │ │ instance │ │ instance │ │
│ │ reset every call │ │ │ └─────────────┘ └────────────┘ │
│ └─────────────────────┘ │ │ │
│ │ │ │
│ ✕ temporary │ │ ✓ permanent (until GC) │
│ ✕ dies when fn returns │ │ ✓ shared across all instances │
│ ✕ no shared state │ │ ✓ mutated in place, never reset │
└─────────────────────────────┘ └──────────────────────────────────────┘
Diagram 3 — The mind-bending part: variables are just labels
In Python, a variable doesn't hold a value. It's just a label pointing to an object on the heap. Even x = 5 — that integer is a full heap object with its own memory address.
Stack (names) Heap (objects)
┌───────────┐
│ a = ─────┼──────────► ┌─────────────────────┐
└───────────┘ ┌────►│ list: [1, 2, 3, 4] │
┌───────────┐ │ │ ref count = 2 │
│ b = ─────┼──────┘ └─────────────────────┘
└───────────┘
b.append(4) also changes a!
Both names point to the same object.
Diagram 4 — Python's secret: integer interning
Python pre-creates integers from -5 to 256 and reuses them forever. Beyond that, new objects are made each time.
a = 5; b = 5
print(a is b) # True → SAME object in memory!
a = 1000; b = 1000
print(a is b) # False → different objects
Small int (-5 to 256): interned Large int: new object each time
┌──────────┐ ┌──────────┐ ┌──────────────┐
│ a = 5 │──┐ │ a = 1000 │────►│ int: 1000 (A)│
└──────────┘ ├──► ┌──────────────┐ └──────────┘ └──────────────┘
│ │ int: 5 │
┌──────────┐ │ │ shared forever│ ┌──────────┐ ┌──────────────┐
│ b = 5 │──┘ └──────────────┘ │ b = 1000 │────►│ int: 1000 (B)│
└──────────┘ └──────────┘ └──────────────┘
a is b → True a is b → False
id(a) == id(b) ✓ id(a) != id(b) ✗
Diagram 5 — How memory gets freed: reference counting
x = [1,2,3] ──► y = x ──► del y ──► del x
ref count = 1 ref count = 2 ref count = 1 ref count = 0
→ freed! 🗑️
When ref count hits 0, Python automatically frees that memory from the heap.
No manual malloc/free needed — unlike C/C++.
The full picture
┌──────────────────────────────────────────────────┐
│ HEAP MEMORY │
│ │
│ type (metaclass) │
│ ▲ ▲ │
│ │ │ │
│ int str ← built-in classes │
│ ▲ │
│ │ │
│ ObjectCounter ← your class │
│ { num_instances: 2 } │
│ ▲ ▲ │
│ │ │ │
│ instance_1 instance_2 ← your objects │
│ │
│ 5, 256, "hello" ← interned primitives │
└──────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────┐
│ STACK MEMORY │
│ x, y ────────────────────────► (point to │
│ heap objects) │
└──────────────────────────────────────────────────┘
One question about a class counter led me to understand stack vs heap, reference semantics, interning, and garbage collection.
Python hides a lot of complexity behind clean syntax. But when you peek under the hood, it's elegant all the way down.
If this was useful, I write about things I'm actively learning as an SDE. Follow along. 🚀
#Python #SoftwareEngineering #WebDevelopment #Programming #LearningInPublic #ComputerScience #100DaysOfCode
Top comments (0)