class DictMixin: '''Mixin defining all dictionary methods for classes that already have a minimum dictionary interface including getitem, setitem, delitem, and keys ''' # first level definitions should be implemented by the sub-class def __getitem__(self, key): raise NotImplementedError def __setitem__(self, key, value): raise NotImplementedError def __delitem__(self, key): raise NotImplementedError def keys(self): raise NotImplementedError # second level definitions which assume only getitem and keys def has_key(self, key): return key in self.keys() def __iter__(self): for k in self.keys(): yield k # third level uses second level instead of first def __contains__(self, key): return self.has_key(key) def iteritems(self): for k in self: yield (k, self[k]) # fourth level uses second and third levels instead of first def iterkeys(self): return self.__iter__() def itervalues(self): for _, v in self.iteritems(): yield v def values(self): return list(self.itervalues()) def items(self): return list(self.iteritems()) def clear(self): for key in self.keys(): del self[key] def setdefault(self, key, default): if key not in self: self[key] = default return default return self[key] def popitem(self): key = self.keys()[0] value = self[key] del self[key] return (key, value) def update(self, other): for key in other.keys(): self[key] = other[key] def get(self, key, default): if key in self: return self[key] return default def __repr__(self): return repr(dict(self.items())) def MakeFullDict(tgt): 'Extends the dictionary interface for existing classes' tgt.__bases__ = tuple(list(tgt.__bases__) + [DictMixin]) ### Example of extending to have a full dictionary interface import shelve MakeFullDict(shelve.Shelf) s ='a.shl') s['name'] = 'john' s['world'] = 'earth' print s.has_key('name') print s.__contains__('name') print 'name' in s for k in s: print k for k,v in s.iteritems(): print k,v for k in s.iterkeys(): print k for v in s.itervalues(): print v print s.values() print s.setdefault( 'addr', 1 ) print s.setdefault( 'addr', 2 ) del s['addr'] print s.popitem() s.update( {'age':38} ) print s.keys() print s.get('age',17) print s.get('salary', 2000) print s print `s` ### Example of a binary tree expanding to a full dictionary iterface class TreeDict(object, DictMixin): __slots__ = [left, right, key, value] def __init__(self, key, value): self.left, self.right, self.key, self.value = None, None, key, value def __getitem__(self, key): if key == self.key: return value next = self.left if key > self.key: next=self.right if next is None: raise KeyError, key return next[key] def __setitem__(self, key, value): if key == self.key: self.value = value return if key < self.key: if self.left is None: self.left = TreeDict(key,value) else: self.left[key]=value else: if self.right is None: self.right = TreeDict(key,value) else: self.right[key]=value def keys(self): ans = [self.key] if self.left is not None: ans.extend(self.left.keys()) if self.right is not None: ans.extend(self.right.keys()) return ans def items(self): 'DictMixin does this; but it can be done faster by the base class' ans = [(self.key, self.value)] if self.left is not None: ans.extend(self.left.items()) if self.right is not None: ans.extend(self.right.items()) return ans def iteritems(self): 'DictMixin does this; but it can be done faster by the base class' for item in self.items(): yield item