Lib/UserDict.py

   1 """A more or less complete user-defined wrapper around dictionary objects."""
   2
   3 class UserDict:
   4     def __init__(self, dict=None, **kwargs):
   5         self.data = {}
   6         if dict is not None:
   7             if not hasattr(dict,'keys'):
   8                 dict = type({})(dict)   # make mapping from a sequence
   9             self.update(dict)
  10         if len(kwargs):
  11             self.update(kwargs)
  12     def __repr__(self): return repr(self.data)
  13     def __cmp__(self, dict):
  14         if isinstance(dict, UserDict):
  15             return cmp(self.data, dict.data)
  16         else:
  17             return cmp(self.data, dict)
  18     def __len__(self): return len(self.data)
  19     def __getitem__(self, key): return self.data[key]
  20     def __setitem__(self, key, item): self.data[key] = item
  21     def __delitem__(self, key): del self.data[key]
  22     def clear(self): self.data.clear()
  23     def copy(self):
  24         if self.__class__ is UserDict:
  25             return UserDict(self.data)
  26         import copy
  27         data = self.data
  28         try:
  29             self.data = {}
  30             c = copy.copy(self)
  31         finally:
  32             self.data = data
  33         c.update(self)
  34         return c
  35     def keys(self): return self.data.keys()
  36     def items(self): return self.data.items()
  37     def iteritems(self): return self.data.iteritems()
  38     def iterkeys(self): return self.data.iterkeys()
  39     def itervalues(self): return self.data.itervalues()
  40     def values(self): return self.data.values()
  41     def has_key(self, key): return self.data.has_key(key)
  42     def update(self, dict):
  43         if isinstance(dict, UserDict):
  44             self.data.update(dict.data)
  45         elif isinstance(dict, type(self.data)):
  46             self.data.update(dict)
  47         else:
  48             for k, v in dict.items():
  49                 self[k] = v
  50     def get(self, key, failobj=None):
  51         if not self.has_key(key):
  52             return failobj
  53         return self[key]
  54     def setdefault(self, key, failobj=None):
  55         if not self.has_key(key):
  56             self[key] = failobj
  57         return self[key]
  58     def pop(self, key):
  59         return self.data.pop(key)
  60     def popitem(self):
  61         return self.data.popitem()
  62     def __contains__(self, key):
  63         return key in self.data
  64     def fromkeys(cls, iterable, value=None):
  65         d = cls()
  66         for key in iterable:
  67             d[key] = value
  68         return d
  69     fromkeys = classmethod(fromkeys)
  70
  71 class IterableUserDict(UserDict):
  72     def __iter__(self):
  73         return iter(self.data)
  74
  75 class DictMixin:
  76     # Mixin defining all dictionary methods for classes that already have
  77     # a minimum dictionary interface including getitem, setitem, delitem,
  78     # and keys. Without knowledge of the subclass constructor, the mixin
  79     # does not define __init__() or copy().  In addition to the four base
  80     # methods, progessively more efficiency comes with defining
  81     # __contains__(), __iter__(), and iteritems().
  82
  83     # second level definitions support higher levels
  84     def __iter__(self):
  85         for k in self.keys():
  86             yield k
  87     def has_key(self, key):
  88         try:
  89             value = self[key]
  90         except KeyError:
  91             return False
  92         return True
  93     __contains__ = has_key
  94
  95     # third level takes advantage of second level definitions
  96     def iteritems(self):
  97         for k in self:
  98             yield (k, self[k])
  99     iterkeys = __iter__
 100
 101     # fourth level uses definitions from lower levels
 102     def itervalues(self):
 103         for _, v in self.iteritems():
 104             yield v
 105     def values(self):
 106         return [v for _, v in self.iteritems()]
 107     def items(self):
 108         return list(self.iteritems())
 109     def clear(self):
 110         for key in self.keys():
 111             del self[key]
 112     def setdefault(self, key, default):
 113         try:
 114             return self[key]
 115         except KeyError:
 116             self[key] = default
 117         return default
 118     def pop(self, key):
 119         value = self[key]
 120         del self[key]
 121         return value
 122     def popitem(self):
 123         try:
 124             k, v = self.iteritems().next()
 125         except StopIteration:
 126             raise KeyError, 'container is empty'
 127         del self[k]
 128         return (k, v)
 129     def update(self, other):
 130         # Make progressively weaker assumptions about "other"
 131         if hasattr(other, 'iteritems'):  # iteritems saves memory and lookups
 132             for k, v in other.iteritems():
 133                 self[k] = v
 134         elif hasattr(other, '__iter__'): # iter saves memory
 135             for k in other:
 136                 self[k] = other[k]
 137         else:
 138             for k in other.keys():
 139                 self[k] = other[k]
 140     def get(self, key, default=None):
 141         try:
 142             return self[key]
 143         except KeyError:
 144             return default
 145     def __repr__(self):
 146         return repr(dict(self.iteritems()))
 147     def __cmp__(self, other):
 148         if isinstance(other, DictMixin):
 149             other = dict(other.iteritems())
 150         return cmp(dict(self.iteritems()), other)
 151     def __len__(self):
 152         return len(self.keys())