Just like a constructor is used to create and initialize an object, a destructor is used to destroy the object and perform the final clean up.
Although in python we do have garbage collector to clean up the memory, but its not just memory which has to be freed when an object is dereferenced or destroyed, it can be a lot of other resources as well, like closing open files, closing database connections, cleaning up the buffer or cache etc. Hence when we say the final clean up, it doesn't only mean cleaning up the memory resources.
In our last tutorial we learned how object is created using
__new__ method and initialised using the
__init__ method. In this tutorial, we will learn how to destroy the object.
As we specified clearly in the last tutorial, that
__init__ method is not necessarily the constructor method as it is only repsonsible to initialise the object variables and not create the object, which is done by
Similarly, the concept of destructors is also a little blur in python, although commonly
__del__ method is considered as the destructor method, so lets see how we can use this method to destroy a class's object.
Below we have a simple code for a class
Example, where we have used the
__init__ method to initialize our object, while we have defined the
__del__ method to act as a destructor.
class Example: def __init__(self): print "Object created" # destructor def __del__(self): print "Object destroyed" # creating an object myObj = Example() # to delete the object explicitly del myObj
Object created Object destroyed
__del__is the counter-part of function
__new__is the function which creates the object.
__del__method is called for any object when the reference count for that object becomes zero.
__del__method will be called if it goes out of scope. The destructor method will only be called when the reference count becomes zero.
As we already mentioned in the start that using
__del__ is not a full proof solution to perform the final clean up for an object which is no longer required.
Here we have discussed two such situations where
__del__ function behaves absurd.
Circular referencing refers to a situation where two objects refers to each other. In such a case when both of these objects goes out of reference, python is confused to destroy which object first, and to avoid any error, it doesn't destroy any of them.
Here is an example to demonstrate circular referencing,
class Foo(): def __init__(self, id, bar): self.id = id # saving reference of Bar object self.friend = bar print 'Foo', self.id, 'born' def __del__(self): print 'Foo', self.id, 'died' class Bar(): def __init__(self, id): self.id = id # saving Foo class object in variable # 'friend' of Bar class, and sending # reference of Bar object for Foo object # initialisation self.friend = Foo(id, self) print 'Bar', self.id, 'born' def __del__(self): print 'Bar', self.id, 'died' b = Bar(12)
Foo 12 born Bar 12 born
In object oriented progamming, destructor is only called in case an object is successfully created, because if the any exception occurs in the constructor then the constructor itself destroys the object.
But in python, if any exception occurs in the
__init__ method while initialising the object, in that case too, the method
__del__ gets called.
Hence, even though the object was never initialised correctly, the
__del__ mehthod will try to empty all the resources and variables and in turn may lead to another exception.
class Example(): def __init__(self, x): # for x = 0, raise exception if x == 0: raise Exception() self.x = x def __del__(self): print self.x # creating an object myObj = Example() # to delete the object explicitly del myObj
Exception exceptions.AttributeError: "'Example' object has no attribute 'x'" in <bound method Example.__del__ of <__main__.Example object at 0x02449570>> ignored