Core Python Programming (2nd Edition)

id(c1), id(c2), id(c3) # all refer to same object
(11938912, 11938912, 11938912)
>>> del c1 # remove one reference
>>> del c2 # remove another reference
>>> del c3 # remove final reference
deleted # destructor finally invoked
Notice how, in the above example, the destructor was not called until all references to the instance of
class C were removed, e.g., when the reference count has decreased to zero. If for some reason your
__del__() method is not being called when you are expecting it to be invoked, this means that somehow
your instance object's reference count is not zero, and there may be some other reference to it that you
are not aware of that is keeping your object around.
Also note that the destructor is called exactly once, the first time the reference count goes to zero and
the object deallocated. This makes sense because any object in the system is allocated and deallocated
only once. Summary:
● Do not forget to call a superclass __del__() first.
● Invoking del x does not call x.__del__()as you saw above, it just decrements the reference count
of x.
● If you have a cycle or some other cause of lingering references to an instance, an object's __del__
() may never be called.
● Uncaught exceptions in __del__() are ignored (because some variables used in __del__() may
have already been deleted). Try not to do anything in __del__() not related to an instance.
● Implementing __del__() is not a common occurrenceonly do it if you really know what you are
doing.
● If you define __del__, and instance is part of a cycle, the garbage collector will not break the
cycleyou have to do it yourself by explicitly using del.
Core Note: Keeping track of instances
Python does not provide any internal mechanism to track how many
instances of a class have been created or to keep tabs on what they
are. You can explicitly add some code to the class definition and
perhaps __init__() and __del__() if such functionality is desired. The
best way is to keep track of the number of instances using a static
member. It would be dangerous to keep track of instance objects by
saving references to them, because you must manage these
references properly or else your instances will never be deallocated
(because of your extra reference to them)! An example follows:
class InstCt(object):
count = 0 # count is class attr
def __init__(self): # increment count
InstCt.count += 1
def __del__(self): # decrement count
InstCt.count -= 1
def howMany(self): # return count
return InstCt.count
>>> a = InstTrack()