🧠 Python Tutorial — Memory Management & Garbage Collection

Introduction 🌟

Python abstracts memory handling so developers don’t have to manage allocation manually. However, understanding how memory works internally is crucial for writing efficient, optimized programs.

Note

🧩 Python Memory Model → Private Heap + Automatic Garbage Collection
🗑️ GC frees unused objects
📌 Uses Reference Counting + Cyclic Garbage Collector

1. Python Memory Architecture 🧱

Python memory is divided into key components:

  • 📍 Object-specific Memory — where data objects live
  • 📍 Private Heap — managed entirely by Python
  • 📍 Memory Manager — handles allocation
  • 📍 Garbage Collector — frees unused memory

2. Reference Counting — Core Mechanism 🔢

In CPython (default Python implementation), every object keeps a reference count: the number of variables pointing to it.

ref_count.py

import sys

a = [1, 2, 3]
print(sys.getrefcount(a))

✔ When reference count drops to 0 → object is destroyed.

Example of Reference Counting

ref_count_example.py

a = [1, 2, 3]
b = a  # +1 reference
c = a  # +1 reference

del b  # -1
del c  # -1

# when all references removed → GC cleans it

Note

💡 Reference counting works instantly — no waiting needed.

3. Problem with Reference Counting — Cyclic References 🔁

Reference counting cannot free cyclic references like this:

cyclic_ref.py

a = []
b = []
a.append(b)
b.append(a)  # both refer to each other

✔ Their refcount never becomes 0 → memory leak risk.

4. Cyclic Garbage Collector (GC) 🔄

Python runs a separate garbage collector to detect and free cycles.

gc_basic.py

import gc

print(gc.get_threshold())   # view GC settings
gc.collect()                # manually trigger garbage collection
  • Generation 0 → short-lived objects
  • Generation 1 → medium-lived
  • Generation 2 → long-lived

✔ GC runs automatically
✔ Higher generations run less frequently

5. Python’s Generational Garbage Collection 🏗️

Objects are grouped into three generations:

GenerationMeaningCollection Frequency
0New objectsMost frequent
1Survived generation 0Less frequent
2Old objectsRarely collected

✔ Objects that survive GC move to the next generation
✔ Based on the principle that most objects die young

6. Memory Allocation in Python 🧩

Small Integer Caching

small_int_cache.py

a = 10
b = 10
print(a is b)  # True

✔ Python reuses small integers (-5 to 256) for performance.

String Interning

string_interning.py

a = "hello"
b = "hello"
print(a is b)  # True

✔ Common strings are shared to reduce memory usage.

7. Memory Leak Scenarios ⚠️

  • ❌ Unintentional global references
  • ❌ Cyclic references with custom classes
  • ❌ Holding unnecessary objects in lists/dicts
  • ❌ Cached objects not released

8. Avoiding Memory Leaks ✔️

  • ✔ Break cycles manually using del
  • ✔ Use weakref for weak references
  • ✔ Use context managers to release resources
  • ✔ Clear large lists/maps after use
  • ✔ Use generators instead of large lists

Using weak references

weakref_example.py

import weakref

class A:
    pass

a = A()
weak_ref = weakref.ref(a)

print(weak_ref())  # returns object
del a
print(weak_ref())  # returns None (object freed)

9. Monitoring Memory Usage 📊

Using sys.getsizeof()

sizeof_example.py

import sys
print(sys.getsizeof([1,2,3]))

Using tracemalloc

Tracks Python memory allocations.

tracemalloc_example.py

import tracemalloc

tracemalloc.start()

a = [i for i in range(10000)]
current, peak = tracemalloc.get_traced_memory()

print("Current:", current)
print("Peak:", peak)

tracemalloc.stop()

10. Real-World Example — Preventing Leaks in Class Cycles 🏗️

class_cycle_fix.py

import weakref

class Node:
    def __init__(self):
        self.parent = None
        self.children = []

root = Node()
child = Node()

child.parent = weakref.ref(root)   # weak link
root.children.append(child)

✔ Breaks cycle → avoids GC overhead

Memory Management Cheat Sheet 📘

ConceptDescription
Reference CountingMain mechanism; frees instantly when count is 0
Cyclic GCHandles cyclic references
Generations3 layers → 0, 1, 2
Small Int CacheReuses -5 to 256
String InterningReuses common strings
weakrefUsed to avoid cycles
tracemallocMemory profiler

Best Practices 💡

  • ✔ Avoid creating large unnecessary objects
  • ✔ Use generators for huge data processing
  • ✔ Remove references using del
  • ✔ Use weakref for parent–child linked objects
  • ✔ Prefer context managers to manage resources
  • ✔ Don’t rely on GC — manage memory consciously

Conclusion 🎉

>>“Python handles memory automatically, but great developers understand how it works behind the scenes.” ✨

You now fully understand Memory Management & Garbage Collection in Python! Want the next topic? Try Object Identity, Name Binding, Data Classes, or Multithreading. Just tell me! 😊