{"id":823,"date":"2020-10-26T11:39:36","date_gmt":"2020-10-26T11:39:36","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=823"},"modified":"2025-03-27T13:21:06","modified_gmt":"2025-03-27T13:21:06","slug":"python-garbage-collection","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/advanced-python\/python-garbage-collection\/","title":{"rendered":"Python Garbage Collection"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn how Python garbage collection works and how to interact with the garbage collector programmatically.<\/p>\n\n\n\n

Introduction to Python garbage collection #<\/a><\/h2>\n\n\n\n

In C\/C++, you’re fully responsible for managing the memory of the program. However, in Python, you don’t have to manage the memory yourself because Python does it for you automatically.<\/p>\n\n\n\n

In the references tutorial<\/a>, you’ve learned that Python Memory Manager keeps track of references of objects. The Memory Manager destroys the object and reclaims the memory once the reference count of that object reaches zero.<\/p>\n\n\n\n

However, reference counting doesn’t work properly all the time. For example, when you have an object that references itself or two objects reference each other. This creates something called circular references.<\/p>\n\n\n\n

When the Python Memory Manager cannot remove objects with circular references, it causes a memory leak.<\/p>\n\n\n\n

This is why the garbage collector comes into play to fix the circular references.<\/p>\n\n\n\n

Python allows you to interact with the garbage collector via the built-in gc<\/code> module.<\/p>\n\n\n\n

Interacting with Python garbage collector #<\/a><\/h2>\n\n\n\n

In this example, we’ll first create a circular reference between two instances of class A and class B. Then, we use the garbage collector to destroy the objects in the circular reference.<\/p>\n\n\n\n

First, import the gc<\/code> and ctypes<\/code> modules and defines two functions for counting references and check if an object exists in the memory:<\/p>\n\n\n

import<\/span> gc\nimport<\/span> ctypes\n\n\ndef<\/span> ref_count<\/span>(address)<\/span>:<\/span>\n    return<\/span> ctypes.c_long.from_address(address).value\n\n\ndef<\/span> object_exists<\/span>(object_id)<\/span>:<\/span>\n    for<\/span> object in<\/span> gc.get_objects():\n        if<\/span> id(object) == object_id:\n            return<\/span> True<\/span>\n\n    return<\/span> False<\/span>\n<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this code, the ref_count()<\/code> returns the reference count of an object specified by its memory address. And the object_exists()<\/code> function returns True<\/code> if an object exists in the memory.<\/p>\n\n\n\n
class<\/span> A<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self)<\/span>:<\/span>\n        self.b = B(self)\n        print(f'A: {hex(id(self))}<\/span>, B: {hex(id(self.b))}<\/span>'<\/span>)\n\n\nclass<\/span> B<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, a)<\/span>:<\/span>\n        self.a = a\n        print(f'B: {hex(id(self))}<\/span>, A: {hex(id(self.a))}<\/span>'<\/span>)\n<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Third, disable the garbage collector by calling the disable()<\/code> function:<\/p>\n\n\n
gc.disable()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Fourth, create a new instance of class A that also automatically creates a new instance of B:<\/p>\n\n\n
a = A()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
B: 0x20fccd148e0<\/span>, A: 0x20fccd75c40<\/span>\nA: 0x20fccd75c40<\/span>, B: 0x20fccd148e0<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Fifth, define two variables to hold the memory addresses of the instances of A and B. These variables keep track of the memory addresses of instances of A and B when the variable a<\/code> references another object.<\/p>\n\n\n
a_id = id(a)\nb_id = id(a.b)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Sixth, show the reference counts of instances of A and B:<\/p>\n\n\n
print(ref_count(a_id))  # 2<\/span>\nprint(ref_count(b_id))  # 1<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The instance of A has two references which is the variable a<\/code> and the instance of B. And the instance of B has one reference which is the instance of A.<\/p>\n\n\n\n
Seventh, check if both instances of A and B are in the memory:<\/p>\n\n\n
print(object_exists(a_id))  # True<\/span>\nprint(object_exists(b_id))  # True<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Both of them exist.<\/p>\n\n\n\n
Eighth, set a variable to None<\/code>:<\/p>\n\n\n
a = None<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Ninth, get the reference counts of the instance of A and B:<\/p>\n\n\n
print(ref_count(a_id))  # 1<\/span>\nprint(ref_count(b_id))  # 1<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Now, both reference count of the instance of A and B is 1.<\/p>\n\n\n\n
Tenth, check if the instances exist:<\/p>\n\n\n
print(object_exists(a_id))  # True<\/span>\nprint(object_exists(b_id))  # True<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Both of them still exist as expected.<\/p>\n\n\n\n
Eleventh, start the garbage collector:<\/p>\n\n\n
gc.collect()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
When the garbage collector runs, it can detect the circular reference, destroy the objects, and reclaim the memory.<\/p>\n\n\n\n
Twelveth, check if the instances of A and B exist:<\/p>\n\n\n
print(object_exists(a_id))  # False<\/span>\nprint(object_exists(b_id))  # False<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Both of them don’t exist anymore due to the garbage collector.<\/p>\n\n\n\n
Thirteenth, get the reference counts of the instances of A and B:<\/p>\n\n\n
print(ref_count(a_id))  # 0<\/span>\nprint(ref_count(b_id))  # 0<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Put it all together.<\/p>\n\n\n
import<\/span> gc\nimport<\/span> ctypes\n\n\ndef<\/span> ref_count<\/span>(address)<\/span>:<\/span>\n    return<\/span> ctypes.c_long.from_address(address).value\n\n\ndef<\/span> object_exists<\/span>(object_id)<\/span>:<\/span>\n    for<\/span> object in<\/span> gc.get_objects():\n        if<\/span> id(object) == object_id:\n            return<\/span> True<\/span>\n\n    return<\/span> False<\/span>\n\n\nclass<\/span> A<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self)<\/span>:<\/span>\n        self.b = B(self)\n        print(f'A: {hex(id(self))}<\/span>, B: {hex(id(self.b))}<\/span>'<\/span>)\n\n\nclass<\/span> B<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, a)<\/span>:<\/span>\n        self.a = a\n        print(f'B: {hex(id(self))}<\/span>, A: {hex(id(self.a))}<\/span>'<\/span>)\n\n\n# disable the garbage collector<\/span>\ngc.disable()\n\na = A()\n\na_id = id(a)\nb_id = id(a.b)\n\nprint(ref_count(a_id))  # 2<\/span>\nprint(ref_count(b_id))  # 1<\/span>\n\nprint(object_exists(a_id))  # True<\/span>\nprint(object_exists(b_id))  # True<\/span>\n\n\na = None<\/span>\nprint(ref_count(a_id))  # 1<\/span>\nprint(ref_count(b_id))  # 1<\/span>\n\nprint(object_exists(a_id))  # True<\/span>\nprint(object_exists(b_id))  # True<\/span>\n\n# run the garbage collector<\/span>\ngc.collect()\n\n# check if object exists<\/span>\nprint(object_exists(a_id))  # False<\/span>\nprint(object_exists(b_id))  # False<\/span>\n\n# reference count<\/span>\nprint(ref_count(a_id))  # 0<\/span>\nprint(ref_count(b_id))  # 0<\/span>\n<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Try it<\/a><\/p>\n\n\n\n
Summary #<\/a><\/h2>\n\n\n\n
    \n
  • Python automatically manages memory for you using reference counting and garbage collector.<\/li>\n\n\n\n
  • Python garbage collector helps you avoid memory leaks by detecting circular references and destroy objects appropriately.<\/li>\n\n\n\n
  • Never disable the garbage collector unless you have a good reason to do so.<\/li>\n<\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t
Second, create two classes<\/a> A<\/code> and B<\/code> that have a reference each other:<\/p>\n\n\n