Reference counting

How Python Tracks Memory

Python uses reference counting as its primary memory management strategy. Every object on the heap carries an internal counter, the reference count, that tracks exactly how many variables, data structures, or internal references are currently pointing to it.

The rules are simple:

1. A new reference to an object increments the counter
2. A reference is removed (variable deleted, goes out of scope, reassigned), the counter decrements
3. When the counter reaches zero, no code can possibly reach the object anymore, Python immediately frees the memory

  a = [1, 2, 3]
                            Heap
                            ────
  a ─────────────────────► [ list: 1, 2, 3 ]  refcount = 1


  b = a
                            Heap
                            ────
  a ─────────────────────► [ list: 1, 2, 3 ]  refcount = 2
  b ─────────────────────► ▲


  c = a
                            Heap
                            ────
  a ─────────────────────► [ list: 1, 2, 3 ]  refcount = 3
  b ─────────────────────► ▲
  c ─────────────────────► ▲


  del b
                            Heap
                            ────
  a ─────────────────────► [ list: 1, 2, 3 ]  refcount = 2
  c ─────────────────────► ▲


  del c
  del a
                            Heap
                            ────
                           [ list: 1, 2, 3 ]  refcount = 0
                                              → freed immediately ✓

Verifying with sys.getrefcount()

Python exposes the reference count of any object via sys.getrefcount().

One higher more

One important detail, calling getrefcount() itself temporarily creates an extra reference by passing the object as an argument, so the count always reads one higher than you might expect.

import sys

a = [1, 2, 3]
print(sys.getrefcount(a))   # 2 — one for a, one for getrefcount's argument

b = a
print(sys.getrefcount(a))   # 3 — a, b, getrefcount's argument

c = a
print(sys.getrefcount(a))   # 4 — a, b, c, getrefcount's argument

del b
print(sys.getrefcount(a))   # 3 — b removed, back to a, c, argument

del c
print(sys.getrefcount(a))   # 2 — c removed, back to a, argument

del a
# refcount hits 0 — object freed from memory immediately

Why It Matters

Reference counting has two important properties:

1. Immediacy: memory is freed the instant the last reference is removed, not at some unpredictable future time. This makes Python’s memory management deterministic and predictable for most cases.

2. Limitation: reference counting alone cannot handle circular references, where two objects reference each other and neither ever reaches zero. Python handles this with a supplementary cyclic garbage collector that runs periodically to detect and free these cycles:

Circular reference

# A circular reference — neither object ever reaches refcount 0
a = {}
b = {}
a["b"] = b      # a references b
b["a"] = a      # b references a

del a
del b
# Both still have refcount 1 — neither freed by reference counting alone
# The cyclic garbage collector will find and free these

Circular reference in deep

When you del a and del b, you are only removing the variable names from the stack, but the objects on the heap still reference each other. That internal reference keeps each object’s count at 1.

Here is the step by step:

  a = {}
  b = {}

  Stack          Heap
  ─────          ────
  a ────────►  [ dict A ]  refcount = 1
  b ────────►  [ dict B ]  refcount = 1


  a["b"] = b    ← dict A now holds a reference to dict B

  Stack          Heap
  ─────          ────
  a ────────►  [ dict A ]  refcount = 1
                  │
                  └───────► [ dict B ]  refcount = 2
                              ▲       (b + A's internal reference)
  b ──────────────────────────┘


  b["a"] = a    ← dict B now holds a reference to dict A

  Stack          Heap
  ─────          ────
  a ────────►  [ dict A ]  refcount = 2
                ▲  │          (a + B's internal reference)
                │  └───────► [ dict B ]  refcount = 2
                │           ▲  │          (b + A's internal reference)
  b ────────────┘           │  │
                            └──┘  ← they point to each other


  del a    ← removes the variable from the stack
             dict A refcount drops from 2 to 1
             (B still holds a reference to A)

  Stack          Heap
  ─────          ────
               [ dict A ]  refcount = 1  ← kept alive by B's reference
                  │
                  └───────► [ dict B ]  refcount = 2
                           ▲  │
  b ───────────────────────┘  │
                              │
                            points back to A


  del b    ← removes the variable from the stack
             dict B refcount drops from 2 to 1
             (A still holds a reference to B)

  Stack          Heap
  ─────          ────
  (empty)    [ dict A ]  refcount = 1  ← kept alive by B's reference
                │
                └───────► [ dict B ]  refcount = 1  ← kept alive by A's reference
                         ▲
                         │
                    points back to A

  ⚠️ both objects are unreachable from the stack
     but neither refcount ever hits 0
     → reference counting alone cannot free them
     → cyclic garbage collector needed

The key insight is that del a and del b only remove the stack references, the arrows from variable names to objects. The objects themselves still hold internal references to each other, keeping both counts at 1.

Counting reference is not enough with circular reference

After the two del operations, no variable on the stack points to either object anymore, they are unreachable, but reference counting has no way to detect that. It only counts references, it does not check reachability. That is exactly the gap the Cyclic Garbage Collector fills.

	Reference Counting	Cyclic GC
Triggers	Every reference change	Runs periodically
Speed	Immediate	Delayed
Handles cycles	❌ No	✅ Yes
Overhead	Per operation	Batch