Garbage Collection in Python

Last Updated : 08 May, 2025

Garbage Collection in Python is an automatic process that handles memory allocation and deallocation, ensuring efficient use of memory. Unlike languages such as C or C++ where the programmer must manually allocate and deallocate memory, Python automatically manages memory through two primary strategies:

Reference counting
Garbage collection

Reference counting

Python uses reference counting to manage memory. Each object keeps track of how many references point to it. When the reference count drops to zero i.e., no references remain, Python automatically deallocates the object. Example:

Python

import sys  x = [1, 2, 3] print(sys.getrefcount(x))   y = x print(sys.getrefcount(x))   y = None print(sys.getrefcount(x))

Output

2 3 2

Explanation:

x is referenced twice initially (once by x, once by getrefcount()).
Assigning y = x increases the count.
Setting y = None removes one reference.

Problem with Reference Counting

Reference counting fails in the presence of cyclic references i.e., objects that reference each other in a cycle. Even if nothing else points to them, their reference count never reaches zero. Example:

Python

import sys x = [1, 2, 3] y = [4, 5, 6] x.append(y) y.append(x) print(sys.getrefcount(x)) print(sys.getrefcount(y))

Output

3 3

Explanation:

x contains y and y contains x.
Even after deleting x and y, Python won’t be able to free the memory just using reference counting, because each still references the other.

Garbage collection for Cyclic References

Garbage collection is a memory management technique used in programming languages to automatically reclaim memory that is no longer accessible or in use by the application. To handle such circular references, Python uses a Garbage Collector (GC) from the built-in gc module. This collector is able to detect and clean up objects involved in reference cycles.

Generational Garbage Collection

Python’s Generational Garbage Collector is designed to deal with cyclic references. It organizes objects into three generations based on their lifespan:

Generation 0: Newly created objects.
Generation 1: Objects that survived one collection cycle.
Generation 2: Long-lived objects.

When reference cycles occur, the garbage collector automatically detects and cleans them up, freeing the memory.

Automatic Garbage Collection of Cycles

Garbage collection runs automatically when the number of allocations exceeds the number of deallocations by a certain threshold. This threshold can be inspected using the gc module.

Python

import gc print(gc.get_threshold())

Output

(2000, 10, 10)

Explanation: It returns the threshold tuple for generations 0, 1 and 2. When allocations exceed the threshold, collection is triggered.

Manual garbage collection

Sometimes it’s beneficial to manually invoke the garbage collector, especially in the case of reference cycles. Example:

Python

import gc  # Create a cycle def fun(i):     x = {}     x[i + 1] = x     return x  # Trigger garbage collection c = gc.collect() print(c)  for i in range(10):     fun(i)  c = gc.collect() print(c)

Output

0 10

Explanation:

def fun(i) creates a cyclic reference by making a dictionary reference itself.
gc.collect() triggers garbage collection and stores the count of collected objects (initially 0).
for i in range(10) calls fun(i) 10 times, creating 10 cyclic references.
gc.collect() triggers garbage collection again and prints the count of collected cycles .

Types of Manual garbage collection

Time-based garbage collection: The garbage collector is triggered at fixed time intervals.

Event-based garbage collection: The garbage collector is called in response to specific events, such as when a user exits the application or when the application becomes idle.

Forced garbage collections

Python’s garbage collector (GC) runs automatically to clean up unused objects. To force it manually, use gc.collect() from the gc module. Example:

Python

import gc a = [1, 2, 3] b = {"a": 1, "b": 2} c = "Hello, world!" del a,b,c gc.collect()

Explanation:

del a, b, c deletes references to a, b and c, making them eligible for garbage collection.
gc.collect() forces garbage collection to free memory by cleaning up unreferenced objects.

Disabling garbage collection

In Python, the garbage collector runs automatically to clean up unreferenced objects. To prevent it from running, you can disable it using gc.disable() from the gc module. Example:

Python

import gc gc.disable() gc.enable()

Explanation:

gc.disable() disables automatic garbage collection.
gc.enable() re-enables automatic garbage collection.

Interacting with python garbage collector

A built-in mechanism called the Python garbage collector automatically eliminates objects that are no longer referenced in order to free up memory and stop memory leaks. The Python gc module offers a number of ways to interact with the garbage collector, which is often executed automatically.

1. Enabling and disabling the garbage collector: You can enable or disable the garbage collector using the gc. enable() and gc. disable() functions, respectively. Example:

Python

import gc # Disable gc.disable() # Enable gc.enable()

2. Forcing garbage collection: You can manually trigger a garbage collection using the gc. collect() function. This can be useful in cases where you want to force immediate garbage collection instead of waiting for automatic garbage collection to occur. Example:

Python

import gc gc.collect()

3. Inspecting garbage collector settings: You can inspect the current settings of the garbage collector using the gc.get_threshold() function, which returns a tuple representing the current thresholds for generations 0, 1, and 2. Example:

Python

import gc t = gc.get_threshold() print(t)

Output

(2000, 10, 10)

4. Setting garbage collector thresholds: You can set the thresholds for garbage collection using the gc.set_threshold() function. This allows you to manually adjust the thresholds for different generations, which can affect the frequency of garbage collection. Example:

Python

import gc gc.set_threshold(500, 5, 5) t = gc.get_threshold() print(t)

Output

(500, 5, 5)

Advantages and Disadvantages

Let’s explore some of the benefits and drawbacks of Python’s garbage collection.

Advantages	Disadvantages
Automatic Memory Management	May introduce performance overhead
No Manual Memory Handling	Requires understanding of memory concepts
Efficient Cleanup via Generations	Limited control over timing of GC
Customizable GC Settings	Possibility of bugs or memory leaks

Python print() function

AFZAL ANSARI

Improve

Article Tags :

Practice Tags :

python

Garbage Collection in Python

Reference counting

Problem with Reference Counting

Garbage collection for Cyclic References

Generational Garbage Collection

Automatic Garbage Collection of Cycles

Manual garbage collection

Types of Manual garbage collection

Forced garbage collections

Disabling garbage collection

Interacting with python garbage collector

Advantages and Disadvantages

Similar Reads