Destructors in Python

Spread the love

When discussing Object-Oriented Programming (OOP), much attention is given to the creation and functionality of objects. However, the termination phase of an object’s life cycle, while less glamorous, is equally significant. In Python, just as there’s a mechanism to initialize objects (constructors), there exists a counterpart to handle the cleanup before an object is discarded: the destructor.

This article unravels the concept of destructors in Python, emphasizing their purpose, behavior, and best practices.

Table of Contents:

  1. Object Life Cycle and the Role of Destructors
  2. The __del__ Method: Python’s Destructor
  3. Invoking the Destructor
  4. Destructors and Inheritance
  5. Caveats and Considerations
  6. Best Practices with Destructors
  7. Conclusion

1. Object Life Cycle and the Role of Destructors

In OOP, an object undergoes a life cycle: creation, utilization, and termination. While constructors are responsible for the initial phase, setting the object’s initial state, destructors ensure any necessary cleanup occurs before the object’s removal. This cleanup might include closing file handles, disconnecting from databases, or releasing large memory resources.

2. The __del__ Method: Python’s Destructor

In Python, the destructor is represented by a special method: __del__. This method is automatically invoked when an object’s reference count drops to zero, signaling that the object is no longer in use.


The primary purpose of the destructor, __del__, is to facilitate cleanup actions, ensuring that any resources the object was using are released before the object is deleted. Such resources might include open file handles, network connections, temporary files, or even database connections.


The destructor method is automatically invoked by the Python garbage collector when the object’s reference count drops to zero, meaning there are no more references pointing to this object.

Here’s a simple example to illustrate:

class Sample:
    def __init__(self, name): = name
        print(f"{} object created")

    def __del__(self):
        print(f"{} object destroyed")

# Creating an instance
obj = Sample("Sample1")

# Deleting the instance
del obj

# Output:
# Sample1 object created
# Sample1 object destroyed

When obj is deleted using del, the message from the destructor confirms that the __del__ method was invoked and the object was destroyed.

When is __del__ Called?:

Apart from the explicit deletion using del, there are other scenarios when an object’s destructor might be called:

  1. If an object is created inside a function and the function execution completes, the object goes out of scope, triggering its destructor.
  2. At the end of the program’s execution, objects might get destroyed, invoking their destructors.
  3. When an object is overwritten, like obj = Sample("Sample1"); obj = Sample("Sample2"), the destructor for Sample1 will be called.


  1. While the __del__ method offers a way to run cleanup code, it’s not guaranteed when it will be executed, especially with the presence of circular references.
  2. There is no need to call the __del__ method explicitly, and it’s usually not a recommended practice.
  3. Exceptions arising inside the __del__ method can be challenging to catch and handle, as the traceback might not always be displayed.

3. Invoking the Destructor

Destructors in Python are not explicitly called but are implicitly invoked when the object’s reference count reaches zero. Other circumstances triggering the destructor include:

  • The program’s termination
  • The object goes out of scope (e.g., in functions or loops)

However, it’s essential to understand that in Python, due to the garbage collector (specifically, the cyclic garbage collector), not all objects with zero references get destroyed immediately. Objects participating in circular references may remain in memory for a longer time until the cyclic collector comes into play.

4. Destructors and Inheritance

When dealing with class inheritance, destructors also play a pivotal role in ensuring resources from both the child and parent classes are properly released.

If both parent and child classes have destructors, the child class’s destructor is invoked first, followed by the parent’s destructor.

class Parent:
    def __del__(self):
        print("Destructor of Parent")

class Child(Parent):
    def __del__(self):
        print("Destructor of Child")

obj = Child()
del obj

# Output:
# Destructor of Child
# Destructor of Parent

5. Caveats and Considerations:

Explicitly Deleting Objects:

  • Reference Count: In Python, each object has an associated reference count, which is a count of how many references (or pointers) exist to this object in memory. This count increases when new references to the object are made and decreases when references are removed.
  • Using the del Keyword: When you use the del keyword, you are effectively deleting a reference to the object, thereby reducing its reference count by one. However, this doesn’t immediately destroy the object; it simply decreases the reference count.
  • Destructor Invocation: An object’s destructor (__del__ method) is called when its reference count drops to zero, not when del is explicitly used. If other references to the object exist elsewhere in the code, the object remains alive, and the destructor is not called immediately after the del statement.

Circular References:

  • What are Circular References?: Circular references occur when two or more objects refer to each other, causing a cycle of references. For example, object A references object B, and object B references object A. This creates a loop of references.
  • The Issue: Since both objects in a circular reference are pointing to each other, even if they are no longer needed or accessible from the main program, their reference counts never drop to zero. This can lead to memory leaks because the objects are never destroyed, and their destructors are never called.
  • Python’s Cyclic Garbage Collector: To combat this, Python has a cyclic garbage collector that identifies circular references and cleans them up. While it’s a helpful mechanism, it doesn’t run continuously but at specific intervals, meaning circularly referenced objects might not be immediately destroyed when they’re no longer needed.

Demonstrating Circular References

We’ll create two classes, A and B, such that an instance of A contains a reference to an instance of B, and vice versa, creating a circular reference.

class A:
    def __init__(self):
        self.b = None
    def setB(self, b):
        self.b = b
    def __del__(self):
        print("A's destructor called")

class B:
    def __init__(self):
        self.a = None
    def setA(self, a):
        self.a = a
    def __del__(self):
        print("B's destructor called")

# Creating instances
a = A()
b = B()

# Setting up circular references

# Deleting references
del a
del b

In this scenario, even though we’ve used del on both a and b, their destructors won’t be called immediately due to the circular reference. Their reference counts aren’t zero because they still reference each other.

Python’s Cyclic Garbage Collector

Python’s garbage collector has a component that specifically handles such circular references, ensuring that memory leaks are minimized. After some time or under certain conditions (like when certain memory thresholds are reached), the cyclic garbage collector runs, identifies these circles of references, and deletes the associated objects, calling their destructors.

To force the garbage collector to run, you can use the gc module:

import gc

# Force run garbage collection
gc.collect()  # This will call the destructors of A and B if they are not referenced elsewhere

After running gc.collect(), you should see the output:

A's destructor called
B's destructor called

This confirms that the cyclic garbage collector has identified the circular references and properly cleaned up the objects, invoking their destructors.

Circular references, while seemingly harmless, can introduce subtle memory leaks in applications. It’s crucial to be aware of such scenarios, especially in long-running applications like web servers. Fortunately, Python’s cyclic garbage collector acts as a safety net, but a best practice is to design with caution, aiming to avoid circular dependencies when possible.

Destructor Chaining in Inheritance:

  • Inheritance and Destructors: In an inheritance hierarchy, both parent and derived classes can have their destructors. When an object of the derived class is destroyed, there’s a need to ensure that both destructors are called to free up all associated resources correctly.
  • Using super(): To achieve this, within the destructor of the derived class, you should use the super() function to call the destructor of the parent class. This ensures that resources or actions defined in the parent’s destructor are also addressed.


class Parent:
    def __del__(self):
        print("Destructor of Parent")

class Child(Parent):
    def __del__(self):
        print("Destructor of Child")

# Create an instance of Child
child_instance = Child()

# Delete the instance
del child_instance

When you run the code, you should see the following output:

Destructor of Child
Destructor of Parent

This demonstrates that when an object of the Child class is deleted, its destructor (__del__ method) is called first. Within the destructor of Child, we explicitly call the destructor of the Parent class using the super() function, ensuring that resources or actions associated with both the child and parent classes are appropriately handled.

6. Best Practices with Destructors

  • Limit Resource Management: Use destructors primarily for cleaning up resources, not for performing essential application logic. For critical functionalities, rely on explicit methods instead.
  • Beware of Exceptions: Avoid allowing exceptions to propagate in destructors. If an exception occurs, it should be caught and handled within the destructor itself.
  • Prefer Context Managers: For resource management, especially with external resources like files or network connections, consider using context managers (with statement) as they provide a cleaner and more intuitive approach.
  • Avoid Explicit Calls: Never call the destructor method (__del__) explicitly. Let Python’s memory manager handle its invocation.

7. Conclusion:

Destructors in Python, symbolized by the __del__ method, are an integral part of the object life cycle. While they operate behind the scenes, their role in resource management is undeniable. A clear understanding of destructors ensures that developers can write efficient, resource-friendly Python applications, leaving no trace behind. As the adage goes, “Clean up after yourself.” In the world of Python objects, destructors adhere to this principle diligently.

Leave a Reply