As referenced in the comments, defining an __exit__ method for your object and using the with statement is the preferred way of "destructing" objects. It's more explicit and predictable.
However, even using the with statement won't guarantee clean destruction of your object if a SIGTERM is received. In order to do something when a
signal is received, you'll have to add a signal handler.
import signal
import sys
def handle_signal[signum, frame]:
print['Got signal']
# Do some cleanup
sys.exit[signum] # Maybe ???
signal.signal[signal.SIGTERM, handle_signal]
At this point, you might consider calling del your_object in the signal handler, but even that is not guaranteed to call the __del__ method if there are still references to that object in the program [see the docs for __del__]
So bottom line I think is not to expect things to go absolutely smoothly and predictably if you're depending on SIGTERM to close your Python programs.
View Discussion
Improve Article
Save Article
View Discussion
Improve Article
Save Article
Constructors in Python
Destructors are called when an object
gets destroyed. In Python, destructors are not needed as much as in C++ because Python has a garbage collector that handles memory management automatically.
The __del__[] method is a known as a destructor method in Python. It is called when all references to the object have been deleted i.e when an object is garbage collected.
Syntax of
destructor declaration :
def __del__[self]: # body of destructor
Note : A reference to objects is also deleted when the object goes out of reference or when the program ends.
Example 1 : Here is the simple example of destructor. By using del keyword we deleted the all references of object ‘obj’, therefore destructor invoked automatically.
Python3
class Employee:
def
__init__[self]:
print['Employee created.']
def __del__[self]:
print['Destructor called, Employee deleted.']
obj = Employee[]
del obj
Output:
Employee created. Destructor called, Employee deleted.
Note : The destructor was called after the program ended or when all the references to object are deleted i.e when the reference count becomes zero, not
when object went out of scope.
Example 2 :This example gives the explanation of above mentioned note. Here, notice that the destructor is called after the ‘Program End…’ printed.
Python3
class Employee:
def __init__[self]:
print['Employee created']
def __del__[self]:
print["Destructor called"]
def Create_obj[]:
print['Making Object...']
obj = Employee[]
print['function end...']
return obj
print['Calling Create_obj[] function...']
obj = Create_obj[]
print['Program End...']
Output:
Calling Create_obj[] function... Making Object... Employee created function end... Program End... Destructor called
Example 3 : Now, consider the following example :
Python3
class A:
def
__init__[self, bb]:
self.b = bb
class B:
def __init__[self]:
self.a = A[self]
def __del__[self]:
print["die"]
def fun[]:
b = B[]
fun[]
In this example when the function fun[] is called, it creates an instance of class B which passes itself to class A, which then sets a
reference to class B and resulting in a circular reference.
Generally, Python’s garbage collector which is used to detect these types of cyclic references would remove it but in this example the use of custom destructor marks this item as “uncollectable”.
Simply, it doesn’t know the order in which to destroy the objects, so it leaves them. Therefore, if your instances are involved in circular references they will live in memory for as long as the application
run.