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:

1. Reference counting
2. 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:

import sys

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

y = x
print(sys.getrefcount(x)) 

y = None
print(sys.getrefcount(x))

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:

import sys
x = [1, 2, 3]
y = [4, 5, 6]

x.append(y)
y.append(x)
print(sys.getrefcount(x))
print(sys.getrefcount(y))

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.

import gc
print(gc.get_threshold())

(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:

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)

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:

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:

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:

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:

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:

import gc

t = gc.get_threshold()
print(t)

(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:

import gc
gc.set_threshold(500, 5, 5)

t = gc.get_threshold()
print(t)

(500, 5, 5)

Advantages and Disadvantages 

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