Python Memory Management: Garbage Collection Explained

What Is Python Memory Management?

Python Memory Management is the process of allocating, using, and releasing memory while a program executes.

Whenever you create a variable or object in Python, memory is allocated to store its information. For example:

name = "Python"
age = 25
numbers = [10, 20, 30, 40]

In this example, Python creates objects for the string, integer, and list. These objects occupy memory during program execution.

Python handles most memory-related operations automatically, so developers do not need to manually allocate and release memory as they would in languages such as C.

Python uses several mechanisms for managing memory:

• Memory Allocation: Allocates memory for newly created objects.
• Reference Counting: Tracks how many references point to an object.
• Garbage Collection: Identifies and removes unreachable objects.
• Memory Optimization: Reuses memory efficiently to reduce unnecessary resource consumption.

Understanding these mechanisms helps developers write better-performing applications.

How Python Memory Management Works

Python uses a private heap to manage objects and data structures. The Python memory manager controls how memory is allocated and released within this heap.

When a Python program runs, memory management generally follows this process:

Step 1: Memory Allocation

When an object is created, Python allocates memory to store it.

student = {
    "name": "Rahul",
    "course": "Python",
    "marks": 90
}

Python allocates memory for the dictionary and its associated objects.

Step 2: Object Usage

The program accesses and modifies objects whenever required.

print(student["name"])
student["marks"] = 95

Step 3: Reference Tracking

Python tracks references pointing to objects using a mechanism called reference counting.

Step 4: Garbage Collection

When objects are no longer accessible, Python can reclaim their memory. Reference counting handles many cases, while the garbage collector helps detect circular references.

What Is Python Garbage Collection?

Python Garbage Collection is an automatic memory management mechanism that identifies objects that are no longer accessible and helps reclaim their memory.

For example:

student = ["Rahul", "Arun", "Priya"]

student = None

Initially, the variable student references a list object.

When we assign None to student, the variable no longer references the original list. If no other references point to that list, its reference count becomes zero, allowing Python to reclaim its memory.

Why Is Garbage Collection Important?

• Prevents unnecessary memory consumption.
• Helps manage unused objects.
• Handles circular references.
• Reduces manual memory management.
• Supports long-running Python applications.

The Python garbage collector works alongside reference counting to manage objects that are no longer needed.

Understanding Reference Counting in Python

Reference Counting is one of the primary mechanisms used by Python to manage object memory.

It tracks the number of references pointing to a particular object.

Whenever a reference is created, the reference count generally increases. When a reference is removed, the count decreases.

When the reference count reaches zero, the object can usually be deallocated.

Example:

import sys

data = [10, 20, 30]

print(sys.getrefcount(data))

another_data = data

print(sys.getrefcount(data))

del another_data

print(sys.getrefcount(data))

Output:

2
3
2

The exact count can depend on the Python implementation and the way the expression is evaluated. In CPython, sys.getrefcount() temporarily creates an additional reference when passing an object as an argument.

Let’s understand the example:

• Initially, data references the list.
• Assigning another_data = data creates another reference.
• Deleting another_data reduces the reference count.

Reference counting allows Python to reclaim many objects immediately when they are no longer referenced.

However, it cannot independently handle every memory management situation.

What Is Cyclic Garbage Collection in Python?

Reference counting works efficiently in most situations, but it has a limitation when objects reference each other.

This situation is called a circular reference.

A circular reference occurs when two or more objects reference one another, even though the program can no longer access them.

Example:

class Student:
    pass

student1 = Student()
student2 = Student()

student1.friend = student2
student2.friend = student1

del student1
del student2

Here:

• student1 references student2.
• student2 references student1.
• Both variables are deleted.
• The objects still reference each other.

Their reference counts do not become zero because they maintain references to one another.

Python’s cyclic garbage collector helps identify these unreachable object cycles and reclaim their memory.

This is why Python Garbage Collection is important beyond basic reference counting.

Python Generational Garbage Collection

Python uses generational garbage collection to make cyclic garbage collection more efficient.

The idea is based on the observation that many objects have a short lifetime, while some objects remain in memory for longer periods.

Python groups tracked objects into generations.

The traditional CPython garbage collection model has three generations:

When garbage collection runs, Python can examine younger generations more frequently than older ones.

This helps reduce the amount of work required to identify unreachable objects.

Using the Python gc Module

Python provides a built-in module called gc that allows developers to interact with the cyclic garbage collector.

The gc module is useful for inspecting garbage collection activity, checking whether automatic collection is enabled, and manually triggering collection.

Importing the gc Module

import gc

print(gc.isenabled())

This checks whether automatic garbage collection is enabled.

Manually Triggering Garbage Collection

import gc

collected = gc.collect()

print("Objects collected:", collected)

The gc.collect() function requests a garbage collection cycle and returns the number of unreachable objects found and collected.

Disabling Automatic Garbage Collection

import gc

gc.disable()

print("Garbage collection disabled")

This disables automatic cyclic garbage collection.

Enabling Garbage Collection Again

gc.enable()

print("Garbage collection enabled")

Checking Garbage Collection Statistics

import gc

print(gc.get_stats())

This returns collection statistics for the garbage collector’s generations, depending on the Python version.

Common Python Memory Leaks and Their Causes

A memory leak occurs when a program continues holding references to objects that are no longer needed.

Although Python provides automatic memory management, memory leaks can still happen because of incorrect reference handling.

Some common causes include:

Example: Unnecessary Object Retention

cache = []

def store_data():
    for i in range(100000):
        cache.append(i)

store_data()

The global cache list retains all the generated values.

Even after the function finishes executing, the objects remain referenced by cache.

One possible solution is to clear the cache when the stored data is no longer required:

cache.clear()

This removes the list’s references to its elements, allowing eligible objects to be reclaimed.

Python Memory Optimization Techniques

Understanding Python Memory Optimization helps developers build applications that use system resources efficiently.

Here are some practical techniques:

Use Generators Instead of Large Lists

Generators produce values one at a time instead of storing an entire sequence in memory.

numbers = (x for x in range(1000000))

for number in numbers:
    print(number)

This is useful when processing large datasets.

Delete Unnecessary References

data = [10, 20, 30, 40]

del data

Deleting the variable removes that reference. The object can be reclaimed when no other references remain.

Use Context Managers

Context managers help release resources such as files automatically.

with open("sample.txt", "r") as file:
    content = file.read()

The file is closed automatically when the with block exits.

Avoid Unnecessary Global Variables

Keeping large objects in global variables for longer than necessary can increase memory usage.

Use local variables and release references when data is no longer required.

Monitor Memory Usage

Developers can use tools such as tracemalloc to investigate memory allocation.

import tracemalloc

tracemalloc.start()

data = [i for i in range(100000)]

snapshot = tracemalloc.take_snapshot()

for stat in snapshot.statistics("lineno")[:5]:
    print(stat)

This helps identify where Python memory allocations are occurring.

Difference Between Reference Counting and Garbage Collection

Reference counting and garbage collection work together, but they have different responsibilities.

Both mechanisms contribute to effective Python Memory Management.

Conclusion

For students and aspiring Python developers, learning these concepts provides a strong foundation for building scalable applications, working with large datasets, and developing memory-efficient software.