Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/python/garbage-collection-python/ below:

Garbage Collection in Python - GeeksforGeeks

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:

1. Reference counting
2. Garbage collection

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))

Explanation:

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

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))

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 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.

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.

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

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

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)

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 .

• 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.

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.

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.

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:

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)

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)

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4