Author: Amin Boulouma, Software Engineer
Github source code: https://github.com/aminblm/ai_systems_design_from_scratch
Engineering Blog: https://aminblm.github.io/ai_systems_design_from_scratch/blog/

5 Strategies to Master Python Memory Management (Without Memory Leaks)

In a high-throughput production environment, you might notice your container’s memory usage climbing linearly until the OOM (Out Of Memory) killer abruptly terminates your service. You check for obvious bugs, but the application logic seems sound. The issue is often hidden: you are creating references that Python’s garbage collector cannot automatically free, leading to a “memory leak” in a language that is supposed to handle memory for you.

The Real-World Scenario: A service processing large batches of JSON reports stores each processed record in a global list for “audit purposes.” Because these objects are never removed, the heap grows until the service crashes under load.

The Glossary

Garbage Collector (GC): A built-in cleaner that finds objects you are no longer using and throws them in the trash.
Heap: The big storage room where Python keeps all the objects you create.
Reference Counting: A counter attached to an object that tracks how many things are pointing to it.
Memory Leak: When you forget to throw away old toys, eventually your room is so full you cannot move.
Circular Reference: When Object A points to B, and B points back to A, tricking the cleaner into thinking they are still needed.

The Core Concept: Why Python Isn’t Truly “Automatic”

While Python features automatic garbage collection, it relies primarily on Reference Counting. When an object’s reference count drops to zero, it is deleted. However, Circular References break this mechanism. We chose Weak References and explicit lifecycle management because they allow us to observe objects without “owning” them, preventing these cycles from accumulating.

Implementation

Simple Example: Manual Deletion

import gc

# Simple object creation
data = [i for i in range(1000000)]

# Explicitly deleting the reference to trigger cleanup
del data
gc.collect()

Complex Example: Production-Grade Object Lifecycle

import weakref
import gc

class ManagedResource:
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return f"Resource({self.name})"

class Registry:
    def __init__(self):
        # Use weak references to avoid keeping objects alive
        self._objects = weakref.WeakValueDictionary()

    def register(self, obj):
        self._objects[id(obj)] = obj

    def get_status(self):
        return list(self._objects.values())

# Production usage
registry = Registry()
res = ManagedResource("DatabaseConnection")
registry.register(res)

print(f"Active: {registry.get_status()}")
del res # GC will now successfully collect the object
gc.collect()
print(f"Active after delete: {registry.get_status()}")

Quick Reference: Strategy Selection

Strategy	When to use	Why?
Weak References	Caches and Registry patterns	Prevents circular references from blocking GC.
Slots (`__slots__`)	High-volume object creation	Dramatically reduces per-object memory footprint.
Generators	Large dataset processing	Keeps only one item in memory at a time.

Developer Checklist

Are you using __slots__ on classes that represent simple data structures?
Have you identified and broken potential circular references?
Is your batch processing logic using generators instead of loading lists into memory?
Are you using weakref for caches to allow objects to be evicted?

Takeaways

Scope Matters: Keep the scope of variables as small as possible; the smaller the scope, the faster the garbage collector can do its job.
Beware of Globals: Global variables are never collected until the program terminates.
Use Generators: Always favor streaming data over loading full datasets.

Counter-intuitive insight: More memory usage does not always mean a leak. Python’s garbage collector often holds onto memory for future allocations to be faster. Only investigate if the memory growth is linear and never plateaus.