I am new to python and have been working through the examples in Swaroop CH's "A Byte of Python". I am seeing some behavior with the __del__
method that is puzzling me.
Basically, if I run the following script (in Python 2.6.2)
class Person4:
'''Represents a person'''
population = 0
def __init__(self, name):
'''Initialize the person's data'''
self.name = name
print 'Initializing %s'% self.name
#When the person is created they increase the population
Person4.population += 1
def __del__(self):
'''I am dying'''
print '%s says bye' % self.name
Person4.population -= 1
if Person4.population == 0:
print 'I am the last one'
else:
print 'There are still %d left' % Person4.population
swaroop = Person4('Swaroop')
kaleem = Person4('Kalem')
using the Python console (or the Spyder interactive console) I see the following:
execfile(u'C:\1_eric\Python\test1.py')
Initializing Swaroop
Initializing Kalemexecfile(u'C:\1_eric\Python\test1.py')
Initializing Swaroop
Swaroop says bye
I am the last one
Initializing Kalem
Kalem says bye
I am the last one
Why is the __del__
method being called immediately after the __init__
on the second run?
I am guessing that since the same instance names ('swaroop' and 'kaleem') are being used that it is releasing the original instance and garbage collecting it. But, this seems to be playing havoc with the current population count.
What is going on here?
What is a good way to avoid this sort of confusion?
Avoid the use of __del__
?
Check for existing instance names before reusing them?
...
Thanks, Eric
There are a couple of things going on here. When your
Person4
class is instantiated, it initialises itspopulation
class variable to 0. From your interactive console, you appear to be running your "test1.py" file multiple times. The second time you run it, thePerson4
class is declared again which makes it technically different from the first one (even though it has the same name). That means it has its own independentpopulation
count.Now,
swaroop
andkaleem
are global variables, shared between both your instances of "test1.py". Python internally uses reference counting for most of its automatic garbage collection, so the original instance of the firstPerson4
class is not released until the second assignment toswaroop
. Assigning toswaroop
decrements the reference count for the first instance, causing__del__
to be called because the reference count is now zero. But because you're referring toPerson4
by name inside__del__()
, when the previous instance disappears it decrements the newPerson4.population
count, instead of the oldPerson4
population count.Hopefully that made sense. I can see why this might be confusing to somebody learning Python. Your use of class variables at the same time as redefining the
Person4
class usingexecfile()
is further confusing matters. For what it's worth, I've written a lot of Python code and I don't think I've ever needed to use the__del__
special method.General advice: don't use __ del __ in Python. It can break garbage collection in a number of ways, esp. in the case of circular references between objects.
In your example, there're various issues related to the usage of execfile() - which is not a best practice - and the redefinition of global variables. By the way, if you really need to create a pseudo-destructor (i.e. a code that is invoked whenever the object gets garbage collected), write a so-called "finalizer" function (it's not properly a destructor) and invoke it using weakref.ref callback. It should NOT be an instance method of course, and remember that lambda actually creates a closure, hence be sure not to leak any reference to self in the callback! If you need data from the destroyed instance, use the func default argument approach, just be sure never to reference 'self' inside the lambda, otherwise it won't work.
output (the sleep is there to help see what's happening):