在python中删除继承的dict元素

Question

I have a dict of Objects which are to be destroyed as follows.

class Elem:
    def __init__(self, name):
       self.name = name
    .
    .
    def __del__(self):
       print('destroying elem' + self.name)

class DerivedDict(dict):
    def __init__(self):
       super(DerivedDict, self).__init__()

    def __del__():
        for k in self.keys():
            del self[k]


elem = Elem('myname')
ddict = DerivedDict()
ddict['myname'] = elem

# this line should delete the both the elem the entry in ddict.
del ddict

When try this I am geting this error

RuntimeError: dictionary changed size during iteration

Answer 1

You are using Python 3.x and the "keys" method gives you a live view of the dictionary keys. When these change, due to you deleting items, Python can't consistently continue iterating over them.

To fix it, just pass your call to self.keys to the list constructor: therefore you get a list with a snapshot of the existing keys prior to the iteration:

def __del__():
    for k in list(self.keys()):
        del self[k]

Now, there are some tricks here and there for proper subclassing a dict that might take you by surprise. If the only behavior you want is to explictly delete your elements on dict deletion, there is no need for that at all - otherwise, see the docs about collection.UserDict - which makes subclassing easier, or collections.abc.MutableSequence - both will warrant you full dict behavior with the need to override a minimum set of methods.

One other note: it is not considered good practice in Python to rely on __del__ to actually be run when your objects go out of scope: there might be other references to them, and them del self.key[x] simply won't call the __del__ method on the object. And during interpreter shutdown (At the end of your program), there is no guarantee at all __del__ will be called even for objects that correctly are no longer referenced.

You'd better add a explicit delete (not special __del__ ) method and call it instead of relying on the del statement mechanism.

Answer 2

It's better not to delete item while iterating. Actually I don't see there is any need to override __del__ . Simply using:

class DerivedDict(dict):
    def __init__(self):
       super(DerivedDict, self).__init__()

This will also cause __del__ of Elem being called.