Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 1 | __all__ = ['Counter', 'deque', 'defaultdict', 'namedtuple', 'OrderedDict'] |
Raymond Hettinger | 88880b2 | 2007-12-18 00:13:45 +0000 | [diff] [blame] | 2 | # For bootstrapping reasons, the collection ABCs are defined in _abcoll.py. |
| 3 | # They should however be considered an integral part of collections.py. |
| 4 | from _abcoll import * |
| 5 | import _abcoll |
| 6 | __all__ += _abcoll.__all__ |
Raymond Hettinger | eb97988 | 2007-02-28 18:37:52 +0000 | [diff] [blame] | 7 | |
| 8 | from _collections import deque, defaultdict |
Raymond Hettinger | b36f747 | 2011-04-23 18:37:37 -0700 | [diff] [blame] | 9 | from operator import itemgetter as _itemgetter |
Raymond Hettinger | abfd8df | 2007-10-16 21:28:32 +0000 | [diff] [blame] | 10 | from keyword import iskeyword as _iskeyword |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 11 | import sys as _sys |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 12 | import heapq as _heapq |
Raymond Hettinger | b36f747 | 2011-04-23 18:37:37 -0700 | [diff] [blame] | 13 | from itertools import repeat as _repeat, chain as _chain, starmap as _starmap |
| 14 | |
Raymond Hettinger | 74f869e | 2010-09-13 22:14:36 +0000 | [diff] [blame] | 15 | try: |
Raymond Hettinger | 7ce6d97 | 2011-04-22 18:49:53 -0700 | [diff] [blame] | 16 | from thread import get_ident as _get_ident |
Amaury Forgeot d'Arc | 71431ef | 2010-11-09 07:35:26 +0000 | [diff] [blame] | 17 | except ImportError: |
Raymond Hettinger | 7ce6d97 | 2011-04-22 18:49:53 -0700 | [diff] [blame] | 18 | from dummy_thread import get_ident as _get_ident |
Raymond Hettinger | 74f869e | 2010-09-13 22:14:36 +0000 | [diff] [blame] | 19 | |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 20 | |
| 21 | ################################################################################ |
| 22 | ### OrderedDict |
| 23 | ################################################################################ |
| 24 | |
Raymond Hettinger | 8ebebd8 | 2011-01-02 01:03:26 +0000 | [diff] [blame] | 25 | class OrderedDict(dict): |
Raymond Hettinger | e980d2d | 2009-03-19 23:12:41 +0000 | [diff] [blame] | 26 | 'Dictionary that remembers insertion order' |
Raymond Hettinger | f1e2df9 | 2009-03-23 00:08:09 +0000 | [diff] [blame] | 27 | # An inherited dict maps keys to values. |
Raymond Hettinger | e980d2d | 2009-03-19 23:12:41 +0000 | [diff] [blame] | 28 | # The inherited dict provides __getitem__, __len__, __contains__, and get. |
| 29 | # The remaining methods are order-aware. |
Raymond Hettinger | c646743 | 2011-04-24 12:30:39 -0700 | [diff] [blame] | 30 | # Big-O running times for all methods are the same as regular dictionaries. |
Raymond Hettinger | f1e2df9 | 2009-03-23 00:08:09 +0000 | [diff] [blame] | 31 | |
Raymond Hettinger | c646743 | 2011-04-24 12:30:39 -0700 | [diff] [blame] | 32 | # The internal self.__map dict maps keys to links in a doubly linked list. |
Raymond Hettinger | f1e2df9 | 2009-03-23 00:08:09 +0000 | [diff] [blame] | 33 | # The circular doubly linked list starts and ends with a sentinel element. |
| 34 | # The sentinel element never gets deleted (this simplifies the algorithm). |
Raymond Hettinger | aba2293 | 2010-03-09 09:58:53 +0000 | [diff] [blame] | 35 | # Each link is stored as a list of length three: [PREV, NEXT, KEY]. |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 36 | |
| 37 | def __init__(self, *args, **kwds): |
Raymond Hettinger | 3f2b184 | 2011-04-24 12:55:28 -0700 | [diff] [blame] | 38 | '''Initialize an ordered dictionary. The signature is the same as |
| 39 | regular dictionaries, but keyword arguments are not recommended because |
| 40 | their insertion order is arbitrary. |
Raymond Hettinger | a5cd637 | 2009-04-08 05:39:38 +0000 | [diff] [blame] | 41 | |
| 42 | ''' |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 43 | if len(args) > 1: |
| 44 | raise TypeError('expected at most 1 arguments, got %d' % len(args)) |
Raymond Hettinger | 9353ea2 | 2009-03-03 20:53:51 +0000 | [diff] [blame] | 45 | try: |
Raymond Hettinger | f1e2df9 | 2009-03-23 00:08:09 +0000 | [diff] [blame] | 46 | self.__root |
Raymond Hettinger | 9353ea2 | 2009-03-03 20:53:51 +0000 | [diff] [blame] | 47 | except AttributeError: |
Raymond Hettinger | 0b795e5 | 2011-04-23 15:41:38 -0700 | [diff] [blame] | 48 | self.__root = root = [] # sentinel node |
| 49 | root[:] = [root, root, None] |
Raymond Hettinger | 2dc90fd | 2009-03-25 22:41:32 +0000 | [diff] [blame] | 50 | self.__map = {} |
Raymond Hettinger | 8ebebd8 | 2011-01-02 01:03:26 +0000 | [diff] [blame] | 51 | self.__update(*args, **kwds) |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 52 | |
Raymond Hettinger | dd2fedc | 2010-04-03 07:57:09 +0000 | [diff] [blame] | 53 | def __setitem__(self, key, value, PREV=0, NEXT=1, dict_setitem=dict.__setitem__): |
Raymond Hettinger | a5cd637 | 2009-04-08 05:39:38 +0000 | [diff] [blame] | 54 | 'od.__setitem__(i, y) <==> od[i]=y' |
Raymond Hettinger | c646743 | 2011-04-24 12:30:39 -0700 | [diff] [blame] | 55 | # Setting a new item creates a new link at the end of the linked list, |
| 56 | # and the inherited dictionary is updated with the new key/value pair. |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 57 | if key not in self: |
Raymond Hettinger | f1e2df9 | 2009-03-23 00:08:09 +0000 | [diff] [blame] | 58 | root = self.__root |
Raymond Hettinger | aba2293 | 2010-03-09 09:58:53 +0000 | [diff] [blame] | 59 | last = root[PREV] |
| 60 | last[NEXT] = root[PREV] = self.__map[key] = [last, root, key] |
Raymond Hettinger | ec5046b | 2012-11-20 21:11:26 -0800 | [diff] [blame] | 61 | return dict_setitem(self, key, value) |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 62 | |
Raymond Hettinger | dd2fedc | 2010-04-03 07:57:09 +0000 | [diff] [blame] | 63 | def __delitem__(self, key, PREV=0, NEXT=1, dict_delitem=dict.__delitem__): |
Raymond Hettinger | a5cd637 | 2009-04-08 05:39:38 +0000 | [diff] [blame] | 64 | 'od.__delitem__(y) <==> del od[y]' |
Raymond Hettinger | c646743 | 2011-04-24 12:30:39 -0700 | [diff] [blame] | 65 | # Deleting an existing item uses self.__map to find the link which gets |
| 66 | # removed by updating the links in the predecessor and successor nodes. |
Raymond Hettinger | dd2fedc | 2010-04-03 07:57:09 +0000 | [diff] [blame] | 67 | dict_delitem(self, key) |
Raymond Hettinger | 43a5641 | 2011-04-23 15:51:38 -0700 | [diff] [blame] | 68 | link_prev, link_next, key = self.__map.pop(key) |
Raymond Hettinger | 3928276 | 2010-04-03 00:39:26 +0000 | [diff] [blame] | 69 | link_prev[NEXT] = link_next |
| 70 | link_next[PREV] = link_prev |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 71 | |
Raymond Hettinger | 3f2b184 | 2011-04-24 12:55:28 -0700 | [diff] [blame] | 72 | def __iter__(self): |
Raymond Hettinger | a5cd637 | 2009-04-08 05:39:38 +0000 | [diff] [blame] | 73 | 'od.__iter__() <==> iter(od)' |
Raymond Hettinger | f1e2df9 | 2009-03-23 00:08:09 +0000 | [diff] [blame] | 74 | # Traverse the linked list in order. |
Raymond Hettinger | 3f2b184 | 2011-04-24 12:55:28 -0700 | [diff] [blame] | 75 | NEXT, KEY = 1, 2 |
Raymond Hettinger | f1e2df9 | 2009-03-23 00:08:09 +0000 | [diff] [blame] | 76 | root = self.__root |
Raymond Hettinger | aba2293 | 2010-03-09 09:58:53 +0000 | [diff] [blame] | 77 | curr = root[NEXT] |
Raymond Hettinger | f1e2df9 | 2009-03-23 00:08:09 +0000 | [diff] [blame] | 78 | while curr is not root: |
Raymond Hettinger | aba2293 | 2010-03-09 09:58:53 +0000 | [diff] [blame] | 79 | yield curr[KEY] |
| 80 | curr = curr[NEXT] |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 81 | |
Raymond Hettinger | 3f2b184 | 2011-04-24 12:55:28 -0700 | [diff] [blame] | 82 | def __reversed__(self): |
Raymond Hettinger | a5cd637 | 2009-04-08 05:39:38 +0000 | [diff] [blame] | 83 | 'od.__reversed__() <==> reversed(od)' |
Raymond Hettinger | f1e2df9 | 2009-03-23 00:08:09 +0000 | [diff] [blame] | 84 | # Traverse the linked list in reverse order. |
Raymond Hettinger | 3f2b184 | 2011-04-24 12:55:28 -0700 | [diff] [blame] | 85 | PREV, KEY = 0, 2 |
Raymond Hettinger | f1e2df9 | 2009-03-23 00:08:09 +0000 | [diff] [blame] | 86 | root = self.__root |
Raymond Hettinger | aba2293 | 2010-03-09 09:58:53 +0000 | [diff] [blame] | 87 | curr = root[PREV] |
Raymond Hettinger | f1e2df9 | 2009-03-23 00:08:09 +0000 | [diff] [blame] | 88 | while curr is not root: |
Raymond Hettinger | aba2293 | 2010-03-09 09:58:53 +0000 | [diff] [blame] | 89 | yield curr[KEY] |
| 90 | curr = curr[PREV] |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 91 | |
Raymond Hettinger | 3928276 | 2010-04-03 00:39:26 +0000 | [diff] [blame] | 92 | def clear(self): |
| 93 | 'od.clear() -> None. Remove all items from od.' |
Raymond Hettinger | c646743 | 2011-04-24 12:30:39 -0700 | [diff] [blame] | 94 | root = self.__root |
| 95 | root[:] = [root, root, None] |
| 96 | self.__map.clear() |
Raymond Hettinger | 6b96ecb | 2010-04-03 03:14:28 +0000 | [diff] [blame] | 97 | dict.clear(self) |
Raymond Hettinger | 3928276 | 2010-04-03 00:39:26 +0000 | [diff] [blame] | 98 | |
Raymond Hettinger | 7ce6d97 | 2011-04-22 18:49:53 -0700 | [diff] [blame] | 99 | # -- the following methods do not depend on the internal structure -- |
| 100 | |
| 101 | def keys(self): |
| 102 | 'od.keys() -> list of keys in od' |
| 103 | return list(self) |
| 104 | |
| 105 | def values(self): |
| 106 | 'od.values() -> list of values in od' |
| 107 | return [self[key] for key in self] |
| 108 | |
| 109 | def items(self): |
| 110 | 'od.items() -> list of (key, value) pairs in od' |
| 111 | return [(key, self[key]) for key in self] |
| 112 | |
| 113 | def iterkeys(self): |
| 114 | 'od.iterkeys() -> an iterator over the keys in od' |
| 115 | return iter(self) |
| 116 | |
| 117 | def itervalues(self): |
| 118 | 'od.itervalues -> an iterator over the values in od' |
| 119 | for k in self: |
| 120 | yield self[k] |
| 121 | |
| 122 | def iteritems(self): |
Raymond Hettinger | 3f2b184 | 2011-04-24 12:55:28 -0700 | [diff] [blame] | 123 | 'od.iteritems -> an iterator over the (key, value) pairs in od' |
Raymond Hettinger | 7ce6d97 | 2011-04-22 18:49:53 -0700 | [diff] [blame] | 124 | for k in self: |
| 125 | yield (k, self[k]) |
| 126 | |
| 127 | update = MutableMapping.update |
| 128 | |
Raymond Hettinger | c646743 | 2011-04-24 12:30:39 -0700 | [diff] [blame] | 129 | __update = update # let subclasses override update without breaking __init__ |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 130 | |
Raymond Hettinger | 8ebebd8 | 2011-01-02 01:03:26 +0000 | [diff] [blame] | 131 | __marker = object() |
| 132 | |
| 133 | def pop(self, key, default=__marker): |
Raymond Hettinger | 3f2b184 | 2011-04-24 12:55:28 -0700 | [diff] [blame] | 134 | '''od.pop(k[,d]) -> v, remove specified key and return the corresponding |
| 135 | value. If key is not found, d is returned if given, otherwise KeyError |
| 136 | is raised. |
| 137 | |
| 138 | ''' |
Raymond Hettinger | 8ebebd8 | 2011-01-02 01:03:26 +0000 | [diff] [blame] | 139 | if key in self: |
| 140 | result = self[key] |
| 141 | del self[key] |
| 142 | return result |
| 143 | if default is self.__marker: |
| 144 | raise KeyError(key) |
| 145 | return default |
| 146 | |
| 147 | def setdefault(self, key, default=None): |
| 148 | 'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od' |
| 149 | if key in self: |
| 150 | return self[key] |
| 151 | self[key] = default |
| 152 | return default |
| 153 | |
Raymond Hettinger | e980d2d | 2009-03-19 23:12:41 +0000 | [diff] [blame] | 154 | def popitem(self, last=True): |
Raymond Hettinger | a5cd637 | 2009-04-08 05:39:38 +0000 | [diff] [blame] | 155 | '''od.popitem() -> (k, v), return and remove a (key, value) pair. |
| 156 | Pairs are returned in LIFO order if last is true or FIFO order if false. |
| 157 | |
| 158 | ''' |
Raymond Hettinger | e980d2d | 2009-03-19 23:12:41 +0000 | [diff] [blame] | 159 | if not self: |
| 160 | raise KeyError('dictionary is empty') |
Raymond Hettinger | 1355a3d | 2009-04-08 08:26:55 +0000 | [diff] [blame] | 161 | key = next(reversed(self) if last else iter(self)) |
Raymond Hettinger | e980d2d | 2009-03-19 23:12:41 +0000 | [diff] [blame] | 162 | value = self.pop(key) |
| 163 | return key, value |
| 164 | |
Raymond Hettinger | 7ce6d97 | 2011-04-22 18:49:53 -0700 | [diff] [blame] | 165 | def __repr__(self, _repr_running={}): |
Raymond Hettinger | a5cd637 | 2009-04-08 05:39:38 +0000 | [diff] [blame] | 166 | 'od.__repr__() <==> repr(od)' |
Raymond Hettinger | 7ce6d97 | 2011-04-22 18:49:53 -0700 | [diff] [blame] | 167 | call_key = id(self), _get_ident() |
| 168 | if call_key in _repr_running: |
| 169 | return '...' |
| 170 | _repr_running[call_key] = 1 |
| 171 | try: |
| 172 | if not self: |
| 173 | return '%s()' % (self.__class__.__name__,) |
| 174 | return '%s(%r)' % (self.__class__.__name__, self.items()) |
| 175 | finally: |
| 176 | del _repr_running[call_key] |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 177 | |
Raymond Hettinger | 3674c85 | 2011-04-20 13:11:38 -0700 | [diff] [blame] | 178 | def __reduce__(self): |
| 179 | 'Return state information for pickling' |
| 180 | items = [[k, self[k]] for k in self] |
| 181 | inst_dict = vars(self).copy() |
| 182 | for k in vars(OrderedDict()): |
| 183 | inst_dict.pop(k, None) |
| 184 | if inst_dict: |
| 185 | return (self.__class__, (items,), inst_dict) |
| 186 | return self.__class__, (items,) |
| 187 | |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 188 | def copy(self): |
Raymond Hettinger | a5cd637 | 2009-04-08 05:39:38 +0000 | [diff] [blame] | 189 | 'od.copy() -> a shallow copy of od' |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 190 | return self.__class__(self) |
| 191 | |
| 192 | @classmethod |
| 193 | def fromkeys(cls, iterable, value=None): |
Raymond Hettinger | 3f2b184 | 2011-04-24 12:55:28 -0700 | [diff] [blame] | 194 | '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S. |
| 195 | If not specified, the value defaults to None. |
Raymond Hettinger | a5cd637 | 2009-04-08 05:39:38 +0000 | [diff] [blame] | 196 | |
| 197 | ''' |
Raymond Hettinger | c646743 | 2011-04-24 12:30:39 -0700 | [diff] [blame] | 198 | self = cls() |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 199 | for key in iterable: |
Raymond Hettinger | c646743 | 2011-04-24 12:30:39 -0700 | [diff] [blame] | 200 | self[key] = value |
| 201 | return self |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 202 | |
| 203 | def __eq__(self, other): |
Raymond Hettinger | a5cd637 | 2009-04-08 05:39:38 +0000 | [diff] [blame] | 204 | '''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive |
| 205 | while comparison to a regular mapping is order-insensitive. |
| 206 | |
| 207 | ''' |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 208 | if isinstance(other, OrderedDict): |
Raymond Hettinger | 7ce6d97 | 2011-04-22 18:49:53 -0700 | [diff] [blame] | 209 | return len(self)==len(other) and self.items() == other.items() |
Raymond Hettinger | bc512d3 | 2009-03-03 04:45:34 +0000 | [diff] [blame] | 210 | return dict.__eq__(self, other) |
| 211 | |
Raymond Hettinger | 7ce6d97 | 2011-04-22 18:49:53 -0700 | [diff] [blame] | 212 | def __ne__(self, other): |
| 213 | 'od.__ne__(y) <==> od!=y' |
| 214 | return not self == other |
| 215 | |
Raymond Hettinger | 43a5641 | 2011-04-23 15:51:38 -0700 | [diff] [blame] | 216 | # -- the following methods support python 3.x style dictionary views -- |
| 217 | |
| 218 | def viewkeys(self): |
| 219 | "od.viewkeys() -> a set-like object providing a view on od's keys" |
| 220 | return KeysView(self) |
| 221 | |
| 222 | def viewvalues(self): |
| 223 | "od.viewvalues() -> an object providing a view on od's values" |
| 224 | return ValuesView(self) |
| 225 | |
| 226 | def viewitems(self): |
| 227 | "od.viewitems() -> a set-like object providing a view on od's items" |
| 228 | return ItemsView(self) |
| 229 | |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 230 | |
Raymond Hettinger | ae3f068 | 2009-01-20 03:36:36 +0000 | [diff] [blame] | 231 | ################################################################################ |
| 232 | ### namedtuple |
| 233 | ################################################################################ |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 234 | |
Raymond Hettinger | 491f707 | 2012-06-08 13:24:12 -0700 | [diff] [blame] | 235 | _class_template = '''\ |
| 236 | class {typename}(tuple): |
| 237 | '{typename}({arg_list})' |
| 238 | |
| 239 | __slots__ = () |
| 240 | |
| 241 | _fields = {field_names!r} |
| 242 | |
| 243 | def __new__(_cls, {arg_list}): |
| 244 | 'Create new instance of {typename}({arg_list})' |
| 245 | return _tuple.__new__(_cls, ({arg_list})) |
| 246 | |
| 247 | @classmethod |
| 248 | def _make(cls, iterable, new=tuple.__new__, len=len): |
| 249 | 'Make a new {typename} object from a sequence or iterable' |
| 250 | result = new(cls, iterable) |
| 251 | if len(result) != {num_fields:d}: |
| 252 | raise TypeError('Expected {num_fields:d} arguments, got %d' % len(result)) |
| 253 | return result |
| 254 | |
| 255 | def __repr__(self): |
| 256 | 'Return a nicely formatted representation string' |
| 257 | return '{typename}({repr_fmt})' % self |
| 258 | |
| 259 | def _asdict(self): |
| 260 | 'Return a new OrderedDict which maps field names to their values' |
| 261 | return OrderedDict(zip(self._fields, self)) |
| 262 | |
| 263 | __dict__ = property(_asdict) |
| 264 | |
| 265 | def _replace(_self, **kwds): |
| 266 | 'Return a new {typename} object replacing specified fields with new values' |
| 267 | result = _self._make(map(kwds.pop, {field_names!r}, _self)) |
| 268 | if kwds: |
| 269 | raise ValueError('Got unexpected field names: %r' % kwds.keys()) |
| 270 | return result |
| 271 | |
| 272 | def __getnewargs__(self): |
| 273 | 'Return self as a plain tuple. Used by copy and pickle.' |
| 274 | return tuple(self) |
| 275 | |
| 276 | {field_defs} |
| 277 | ''' |
| 278 | |
| 279 | _repr_template = '{name}=%r' |
| 280 | |
| 281 | _field_template = '''\ |
| 282 | {name} = _property(_itemgetter({index:d}), doc='Alias for field number {index:d}') |
| 283 | ''' |
| 284 | |
Raymond Hettinger | 322daea | 2009-02-10 01:24:05 +0000 | [diff] [blame] | 285 | def namedtuple(typename, field_names, verbose=False, rename=False): |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 286 | """Returns a new subclass of tuple with named fields. |
| 287 | |
Raymond Hettinger | 491f707 | 2012-06-08 13:24:12 -0700 | [diff] [blame] | 288 | >>> Point = namedtuple('Point', ['x', 'y']) |
Raymond Hettinger | d36a60e | 2007-09-17 00:55:00 +0000 | [diff] [blame] | 289 | >>> Point.__doc__ # docstring for the new class |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 290 | 'Point(x, y)' |
Raymond Hettinger | d36a60e | 2007-09-17 00:55:00 +0000 | [diff] [blame] | 291 | >>> p = Point(11, y=22) # instantiate with positional args or keywords |
Raymond Hettinger | 8777bca | 2007-12-18 22:21:27 +0000 | [diff] [blame] | 292 | >>> p[0] + p[1] # indexable like a plain tuple |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 293 | 33 |
Raymond Hettinger | 88880b2 | 2007-12-18 00:13:45 +0000 | [diff] [blame] | 294 | >>> x, y = p # unpack like a regular tuple |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 295 | >>> x, y |
| 296 | (11, 22) |
Raymond Hettinger | d36a60e | 2007-09-17 00:55:00 +0000 | [diff] [blame] | 297 | >>> p.x + p.y # fields also accessable by name |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 298 | 33 |
Raymond Hettinger | 42da874 | 2007-12-14 02:49:47 +0000 | [diff] [blame] | 299 | >>> d = p._asdict() # convert to a dictionary |
Raymond Hettinger | a7fc4b1 | 2007-10-05 02:47:07 +0000 | [diff] [blame] | 300 | >>> d['x'] |
| 301 | 11 |
| 302 | >>> Point(**d) # convert from a dictionary |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 303 | Point(x=11, y=22) |
Raymond Hettinger | 42da874 | 2007-12-14 02:49:47 +0000 | [diff] [blame] | 304 | >>> p._replace(x=100) # _replace() is like str.replace() but targets named fields |
Raymond Hettinger | d36a60e | 2007-09-17 00:55:00 +0000 | [diff] [blame] | 305 | Point(x=100, y=22) |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 306 | |
| 307 | """ |
| 308 | |
Raymond Hettinger | 3395fda | 2012-06-09 13:04:29 -0700 | [diff] [blame] | 309 | # Validate the field names. At the user's option, either generate an error |
| 310 | # message or automatically replace the field name with a valid name. |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 311 | if isinstance(field_names, basestring): |
Raymond Hettinger | 3395fda | 2012-06-09 13:04:29 -0700 | [diff] [blame] | 312 | field_names = field_names.replace(',', ' ').split() |
| 313 | field_names = map(str, field_names) |
Raymond Hettinger | 322daea | 2009-02-10 01:24:05 +0000 | [diff] [blame] | 314 | if rename: |
Raymond Hettinger | 322daea | 2009-02-10 01:24:05 +0000 | [diff] [blame] | 315 | seen = set() |
Raymond Hettinger | 3395fda | 2012-06-09 13:04:29 -0700 | [diff] [blame] | 316 | for index, name in enumerate(field_names): |
Raymond Hettinger | 491f707 | 2012-06-08 13:24:12 -0700 | [diff] [blame] | 317 | if (not all(c.isalnum() or c=='_' for c in name) |
| 318 | or _iskeyword(name) |
| 319 | or not name |
| 320 | or name[0].isdigit() |
| 321 | or name.startswith('_') |
Raymond Hettinger | 322daea | 2009-02-10 01:24:05 +0000 | [diff] [blame] | 322 | or name in seen): |
Raymond Hettinger | 3395fda | 2012-06-09 13:04:29 -0700 | [diff] [blame] | 323 | field_names[index] = '_%d' % index |
Raymond Hettinger | 322daea | 2009-02-10 01:24:05 +0000 | [diff] [blame] | 324 | seen.add(name) |
Raymond Hettinger | 3395fda | 2012-06-09 13:04:29 -0700 | [diff] [blame] | 325 | for name in [typename] + field_names: |
Raymond Hettinger | 2e1af25 | 2007-12-05 18:11:08 +0000 | [diff] [blame] | 326 | if not all(c.isalnum() or c=='_' for c in name): |
Raymond Hettinger | 3395fda | 2012-06-09 13:04:29 -0700 | [diff] [blame] | 327 | raise ValueError('Type names and field names can only contain ' |
| 328 | 'alphanumeric characters and underscores: %r' % name) |
Raymond Hettinger | abfd8df | 2007-10-16 21:28:32 +0000 | [diff] [blame] | 329 | if _iskeyword(name): |
Raymond Hettinger | 3395fda | 2012-06-09 13:04:29 -0700 | [diff] [blame] | 330 | raise ValueError('Type names and field names cannot be a ' |
| 331 | 'keyword: %r' % name) |
Raymond Hettinger | 050afbf | 2007-10-16 19:18:30 +0000 | [diff] [blame] | 332 | if name[0].isdigit(): |
Raymond Hettinger | 3395fda | 2012-06-09 13:04:29 -0700 | [diff] [blame] | 333 | raise ValueError('Type names and field names cannot start with ' |
| 334 | 'a number: %r' % name) |
Raymond Hettinger | 491f707 | 2012-06-08 13:24:12 -0700 | [diff] [blame] | 335 | seen = set() |
Raymond Hettinger | 163f622 | 2007-10-09 01:36:23 +0000 | [diff] [blame] | 336 | for name in field_names: |
Raymond Hettinger | 322daea | 2009-02-10 01:24:05 +0000 | [diff] [blame] | 337 | if name.startswith('_') and not rename: |
Raymond Hettinger | 0c2c692 | 2012-06-09 17:27:23 -0700 | [diff] [blame] | 338 | raise ValueError('Field names cannot start with an underscore: ' |
Raymond Hettinger | 3395fda | 2012-06-09 13:04:29 -0700 | [diff] [blame] | 339 | '%r' % name) |
Raymond Hettinger | 491f707 | 2012-06-08 13:24:12 -0700 | [diff] [blame] | 340 | if name in seen: |
Raymond Hettinger | 050afbf | 2007-10-16 19:18:30 +0000 | [diff] [blame] | 341 | raise ValueError('Encountered duplicate field name: %r' % name) |
Raymond Hettinger | 491f707 | 2012-06-08 13:24:12 -0700 | [diff] [blame] | 342 | seen.add(name) |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 343 | |
Raymond Hettinger | 491f707 | 2012-06-08 13:24:12 -0700 | [diff] [blame] | 344 | # Fill-in the class template |
| 345 | class_definition = _class_template.format( |
| 346 | typename = typename, |
| 347 | field_names = tuple(field_names), |
| 348 | num_fields = len(field_names), |
| 349 | arg_list = repr(tuple(field_names)).replace("'", "")[1:-1], |
Raymond Hettinger | 3395fda | 2012-06-09 13:04:29 -0700 | [diff] [blame] | 350 | repr_fmt = ', '.join(_repr_template.format(name=name) |
| 351 | for name in field_names), |
Raymond Hettinger | 491f707 | 2012-06-08 13:24:12 -0700 | [diff] [blame] | 352 | field_defs = '\n'.join(_field_template.format(index=index, name=name) |
| 353 | for index, name in enumerate(field_names)) |
| 354 | ) |
Raymond Hettinger | 2b03d45 | 2007-09-18 03:33:19 +0000 | [diff] [blame] | 355 | if verbose: |
Raymond Hettinger | 491f707 | 2012-06-08 13:24:12 -0700 | [diff] [blame] | 356 | print class_definition |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 357 | |
Raymond Hettinger | 3395fda | 2012-06-09 13:04:29 -0700 | [diff] [blame] | 358 | # Execute the template string in a temporary namespace and support |
| 359 | # tracing utilities by setting a value for frame.f_globals['__name__'] |
Raymond Hettinger | a68cad1 | 2009-05-27 02:24:45 +0000 | [diff] [blame] | 360 | namespace = dict(_itemgetter=_itemgetter, __name__='namedtuple_%s' % typename, |
| 361 | OrderedDict=OrderedDict, _property=property, _tuple=tuple) |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 362 | try: |
Raymond Hettinger | 491f707 | 2012-06-08 13:24:12 -0700 | [diff] [blame] | 363 | exec class_definition in namespace |
| 364 | except SyntaxError as e: |
Raymond Hettinger | 3395fda | 2012-06-09 13:04:29 -0700 | [diff] [blame] | 365 | raise SyntaxError(e.message + ':\n' + class_definition) |
Raymond Hettinger | 0e1d606 | 2007-10-08 10:11:51 +0000 | [diff] [blame] | 366 | result = namespace[typename] |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 367 | |
| 368 | # For pickling to work, the __module__ variable needs to be set to the frame |
| 369 | # where the named tuple is created. Bypass this step in enviroments where |
Benjamin Peterson | 7c67b03 | 2009-05-05 00:55:24 +0000 | [diff] [blame] | 370 | # sys._getframe is not defined (Jython for example) or sys._getframe is not |
| 371 | # defined for arguments greater than 0 (IronPython). |
| 372 | try: |
Raymond Hettinger | ecf252a | 2009-01-27 10:03:04 +0000 | [diff] [blame] | 373 | result.__module__ = _sys._getframe(1).f_globals.get('__name__', '__main__') |
Benjamin Peterson | 7c67b03 | 2009-05-05 00:55:24 +0000 | [diff] [blame] | 374 | except (AttributeError, ValueError): |
| 375 | pass |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 376 | |
Raymond Hettinger | 5a41daf | 2007-05-19 01:11:16 +0000 | [diff] [blame] | 377 | return result |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 378 | |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 379 | |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 380 | ######################################################################## |
Raymond Hettinger | ae3f068 | 2009-01-20 03:36:36 +0000 | [diff] [blame] | 381 | ### Counter |
| 382 | ######################################################################## |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 383 | |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 384 | class Counter(dict): |
| 385 | '''Dict subclass for counting hashable items. Sometimes called a bag |
| 386 | or multiset. Elements are stored as dictionary keys and their counts |
| 387 | are stored as dictionary values. |
| 388 | |
Raymond Hettinger | c886a84 | 2011-01-03 08:59:18 +0000 | [diff] [blame] | 389 | >>> c = Counter('abcdeabcdabcaba') # count elements from a string |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 390 | |
| 391 | >>> c.most_common(3) # three most common elements |
Raymond Hettinger | c886a84 | 2011-01-03 08:59:18 +0000 | [diff] [blame] | 392 | [('a', 5), ('b', 4), ('c', 3)] |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 393 | >>> sorted(c) # list all unique elements |
Raymond Hettinger | c886a84 | 2011-01-03 08:59:18 +0000 | [diff] [blame] | 394 | ['a', 'b', 'c', 'd', 'e'] |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 395 | >>> ''.join(sorted(c.elements())) # list elements with repetitions |
Raymond Hettinger | c886a84 | 2011-01-03 08:59:18 +0000 | [diff] [blame] | 396 | 'aaaaabbbbcccdde' |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 397 | >>> sum(c.values()) # total of all counts |
Raymond Hettinger | c886a84 | 2011-01-03 08:59:18 +0000 | [diff] [blame] | 398 | 15 |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 399 | |
| 400 | >>> c['a'] # count of letter 'a' |
| 401 | 5 |
| 402 | >>> for elem in 'shazam': # update counts from an iterable |
| 403 | ... c[elem] += 1 # by adding 1 to each element's count |
| 404 | >>> c['a'] # now there are seven 'a' |
| 405 | 7 |
Raymond Hettinger | c886a84 | 2011-01-03 08:59:18 +0000 | [diff] [blame] | 406 | >>> del c['b'] # remove all 'b' |
| 407 | >>> c['b'] # now there are zero 'b' |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 408 | 0 |
| 409 | |
| 410 | >>> d = Counter('simsalabim') # make another counter |
| 411 | >>> c.update(d) # add in the second counter |
| 412 | >>> c['a'] # now there are nine 'a' |
| 413 | 9 |
| 414 | |
| 415 | >>> c.clear() # empty the counter |
| 416 | >>> c |
| 417 | Counter() |
| 418 | |
| 419 | Note: If a count is set to zero or reduced to zero, it will remain |
| 420 | in the counter until the entry is deleted or the counter is cleared: |
| 421 | |
| 422 | >>> c = Counter('aaabbc') |
| 423 | >>> c['b'] -= 2 # reduce the count of 'b' by two |
| 424 | >>> c.most_common() # 'b' is still in, but its count is zero |
| 425 | [('a', 3), ('c', 1), ('b', 0)] |
| 426 | |
| 427 | ''' |
| 428 | # References: |
| 429 | # http://en.wikipedia.org/wiki/Multiset |
| 430 | # http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html |
| 431 | # http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm |
| 432 | # http://code.activestate.com/recipes/259174/ |
| 433 | # Knuth, TAOCP Vol. II section 4.6.3 |
| 434 | |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 435 | def __init__(self, iterable=None, **kwds): |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 436 | '''Create a new, empty Counter object. And if given, count elements |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 437 | from an input iterable. Or, initialize the count from another mapping |
| 438 | of elements to their counts. |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 439 | |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 440 | >>> c = Counter() # a new, empty counter |
Raymond Hettinger | 783d73f | 2009-01-13 04:13:53 +0000 | [diff] [blame] | 441 | >>> c = Counter('gallahad') # a new counter from an iterable |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 442 | >>> c = Counter({'a': 4, 'b': 2}) # a new counter from a mapping |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 443 | >>> c = Counter(a=4, b=2) # a new counter from keyword args |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 444 | |
| 445 | ''' |
Raymond Hettinger | c886a84 | 2011-01-03 08:59:18 +0000 | [diff] [blame] | 446 | super(Counter, self).__init__() |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 447 | self.update(iterable, **kwds) |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 448 | |
| 449 | def __missing__(self, key): |
| 450 | 'The count of elements not in the Counter is zero.' |
| 451 | # Needed so that self[missing_item] does not raise KeyError |
| 452 | return 0 |
| 453 | |
| 454 | def most_common(self, n=None): |
| 455 | '''List the n most common elements and their counts from the most |
| 456 | common to the least. If n is None, then list all element counts. |
| 457 | |
Raymond Hettinger | c886a84 | 2011-01-03 08:59:18 +0000 | [diff] [blame] | 458 | >>> Counter('abcdeabcdabcaba').most_common(3) |
| 459 | [('a', 5), ('b', 4), ('c', 3)] |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 460 | |
| 461 | ''' |
| 462 | # Emulate Bag.sortedByCount from Smalltalk |
| 463 | if n is None: |
| 464 | return sorted(self.iteritems(), key=_itemgetter(1), reverse=True) |
| 465 | return _heapq.nlargest(n, self.iteritems(), key=_itemgetter(1)) |
| 466 | |
| 467 | def elements(self): |
| 468 | '''Iterator over elements repeating each as many times as its count. |
| 469 | |
| 470 | >>> c = Counter('ABCABC') |
| 471 | >>> sorted(c.elements()) |
| 472 | ['A', 'A', 'B', 'B', 'C', 'C'] |
| 473 | |
Raymond Hettinger | 783d73f | 2009-01-13 04:13:53 +0000 | [diff] [blame] | 474 | # Knuth's example for prime factors of 1836: 2**2 * 3**3 * 17**1 |
| 475 | >>> prime_factors = Counter({2: 2, 3: 3, 17: 1}) |
| 476 | >>> product = 1 |
| 477 | >>> for factor in prime_factors.elements(): # loop over factors |
| 478 | ... product *= factor # and multiply them |
| 479 | >>> product |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 480 | 1836 |
| 481 | |
Raymond Hettinger | 783d73f | 2009-01-13 04:13:53 +0000 | [diff] [blame] | 482 | Note, if an element's count has been set to zero or is a negative |
| 483 | number, elements() will ignore it. |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 484 | |
| 485 | ''' |
| 486 | # Emulate Bag.do from Smalltalk and Multiset.begin from C++. |
Raymond Hettinger | 35288c6 | 2009-01-13 04:50:35 +0000 | [diff] [blame] | 487 | return _chain.from_iterable(_starmap(_repeat, self.iteritems())) |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 488 | |
| 489 | # Override dict methods where necessary |
| 490 | |
| 491 | @classmethod |
| 492 | def fromkeys(cls, iterable, v=None): |
| 493 | # There is no equivalent method for counters because setting v=1 |
| 494 | # means that no element can have a count greater than one. |
| 495 | raise NotImplementedError( |
| 496 | 'Counter.fromkeys() is undefined. Use Counter(iterable) instead.') |
| 497 | |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 498 | def update(self, iterable=None, **kwds): |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 499 | '''Like dict.update() but add counts instead of replacing them. |
| 500 | |
Raymond Hettinger | 783d73f | 2009-01-13 04:13:53 +0000 | [diff] [blame] | 501 | Source can be an iterable, a dictionary, or another Counter instance. |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 502 | |
| 503 | >>> c = Counter('which') |
Raymond Hettinger | 783d73f | 2009-01-13 04:13:53 +0000 | [diff] [blame] | 504 | >>> c.update('witch') # add elements from another iterable |
| 505 | >>> d = Counter('watch') |
| 506 | >>> c.update(d) # add elements from another counter |
| 507 | >>> c['h'] # four 'h' in which, witch, and watch |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 508 | 4 |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 509 | |
| 510 | ''' |
| 511 | # The regular dict.update() operation makes no sense here because the |
| 512 | # replace behavior results in the some of original untouched counts |
| 513 | # being mixed-in with all of the other counts for a mismash that |
| 514 | # doesn't have a straight-forward interpretation in most counting |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 515 | # contexts. Instead, we implement straight-addition. Both the inputs |
| 516 | # and outputs are allowed to contain zero and negative counts. |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 517 | |
| 518 | if iterable is not None: |
| 519 | if isinstance(iterable, Mapping): |
Raymond Hettinger | 1bc1c8a | 2009-01-22 09:05:43 +0000 | [diff] [blame] | 520 | if self: |
Raymond Hettinger | 5dfc7f9 | 2009-06-29 19:10:29 +0000 | [diff] [blame] | 521 | self_get = self.get |
Raymond Hettinger | 1bc1c8a | 2009-01-22 09:05:43 +0000 | [diff] [blame] | 522 | for elem, count in iterable.iteritems(): |
Raymond Hettinger | 5dfc7f9 | 2009-06-29 19:10:29 +0000 | [diff] [blame] | 523 | self[elem] = self_get(elem, 0) + count |
Raymond Hettinger | 1bc1c8a | 2009-01-22 09:05:43 +0000 | [diff] [blame] | 524 | else: |
Raymond Hettinger | c886a84 | 2011-01-03 08:59:18 +0000 | [diff] [blame] | 525 | super(Counter, self).update(iterable) # fast path when counter is empty |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 526 | else: |
Raymond Hettinger | 5dfc7f9 | 2009-06-29 19:10:29 +0000 | [diff] [blame] | 527 | self_get = self.get |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 528 | for elem in iterable: |
Raymond Hettinger | 5dfc7f9 | 2009-06-29 19:10:29 +0000 | [diff] [blame] | 529 | self[elem] = self_get(elem, 0) + 1 |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 530 | if kwds: |
| 531 | self.update(kwds) |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 532 | |
Raymond Hettinger | 34c35b2 | 2010-04-03 10:22:00 +0000 | [diff] [blame] | 533 | def subtract(self, iterable=None, **kwds): |
| 534 | '''Like dict.update() but subtracts counts instead of replacing them. |
| 535 | Counts can be reduced below zero. Both the inputs and outputs are |
| 536 | allowed to contain zero and negative counts. |
| 537 | |
| 538 | Source can be an iterable, a dictionary, or another Counter instance. |
| 539 | |
| 540 | >>> c = Counter('which') |
| 541 | >>> c.subtract('witch') # subtract elements from another iterable |
| 542 | >>> c.subtract(Counter('watch')) # subtract elements from another counter |
| 543 | >>> c['h'] # 2 in which, minus 1 in witch, minus 1 in watch |
| 544 | 0 |
| 545 | >>> c['w'] # 1 in which, minus 1 in witch, minus 1 in watch |
| 546 | -1 |
| 547 | |
| 548 | ''' |
| 549 | if iterable is not None: |
Raymond Hettinger | fdf1b56 | 2010-04-11 20:39:28 +0000 | [diff] [blame] | 550 | self_get = self.get |
Raymond Hettinger | 34c35b2 | 2010-04-03 10:22:00 +0000 | [diff] [blame] | 551 | if isinstance(iterable, Mapping): |
Raymond Hettinger | 34c35b2 | 2010-04-03 10:22:00 +0000 | [diff] [blame] | 552 | for elem, count in iterable.items(): |
| 553 | self[elem] = self_get(elem, 0) - count |
| 554 | else: |
Raymond Hettinger | 34c35b2 | 2010-04-03 10:22:00 +0000 | [diff] [blame] | 555 | for elem in iterable: |
| 556 | self[elem] = self_get(elem, 0) - 1 |
| 557 | if kwds: |
| 558 | self.subtract(kwds) |
| 559 | |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 560 | def copy(self): |
Raymond Hettinger | 37c0fe5 | 2011-04-15 13:12:21 -0700 | [diff] [blame] | 561 | 'Return a shallow copy.' |
| 562 | return self.__class__(self) |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 563 | |
Raymond Hettinger | c886a84 | 2011-01-03 08:59:18 +0000 | [diff] [blame] | 564 | def __reduce__(self): |
| 565 | return self.__class__, (dict(self),) |
| 566 | |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 567 | def __delitem__(self, elem): |
| 568 | 'Like dict.__delitem__() but does not raise KeyError for missing values.' |
| 569 | if elem in self: |
Raymond Hettinger | c886a84 | 2011-01-03 08:59:18 +0000 | [diff] [blame] | 570 | super(Counter, self).__delitem__(elem) |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 571 | |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 572 | def __repr__(self): |
| 573 | if not self: |
| 574 | return '%s()' % self.__class__.__name__ |
Raymond Hettinger | 35288c6 | 2009-01-13 04:50:35 +0000 | [diff] [blame] | 575 | items = ', '.join(map('%r: %r'.__mod__, self.most_common())) |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 576 | return '%s({%s})' % (self.__class__.__name__, items) |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 577 | |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 578 | # Multiset-style mathematical operations discussed in: |
| 579 | # Knuth TAOCP Volume II section 4.6.3 exercise 19 |
| 580 | # and at http://en.wikipedia.org/wiki/Multiset |
| 581 | # |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 582 | # Outputs guaranteed to only include positive counts. |
| 583 | # |
| 584 | # To strip negative and zero counts, add-in an empty counter: |
| 585 | # c += Counter() |
| 586 | |
| 587 | def __add__(self, other): |
| 588 | '''Add counts from two counters. |
| 589 | |
| 590 | >>> Counter('abbb') + Counter('bcc') |
| 591 | Counter({'b': 4, 'c': 2, 'a': 1}) |
| 592 | |
| 593 | ''' |
| 594 | if not isinstance(other, Counter): |
| 595 | return NotImplemented |
| 596 | result = Counter() |
Raymond Hettinger | efeb8bd | 2011-04-17 20:08:41 -0700 | [diff] [blame] | 597 | for elem, count in self.items(): |
| 598 | newcount = count + other[elem] |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 599 | if newcount > 0: |
| 600 | result[elem] = newcount |
Raymond Hettinger | efeb8bd | 2011-04-17 20:08:41 -0700 | [diff] [blame] | 601 | for elem, count in other.items(): |
| 602 | if elem not in self and count > 0: |
| 603 | result[elem] = count |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 604 | return result |
| 605 | |
| 606 | def __sub__(self, other): |
| 607 | ''' Subtract count, but keep only results with positive counts. |
| 608 | |
| 609 | >>> Counter('abbbc') - Counter('bccd') |
| 610 | Counter({'b': 2, 'a': 1}) |
| 611 | |
| 612 | ''' |
| 613 | if not isinstance(other, Counter): |
| 614 | return NotImplemented |
| 615 | result = Counter() |
Raymond Hettinger | efeb8bd | 2011-04-17 20:08:41 -0700 | [diff] [blame] | 616 | for elem, count in self.items(): |
| 617 | newcount = count - other[elem] |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 618 | if newcount > 0: |
| 619 | result[elem] = newcount |
Raymond Hettinger | efeb8bd | 2011-04-17 20:08:41 -0700 | [diff] [blame] | 620 | for elem, count in other.items(): |
| 621 | if elem not in self and count < 0: |
| 622 | result[elem] = 0 - count |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 623 | return result |
| 624 | |
| 625 | def __or__(self, other): |
| 626 | '''Union is the maximum of value in either of the input counters. |
| 627 | |
| 628 | >>> Counter('abbb') | Counter('bcc') |
| 629 | Counter({'b': 3, 'c': 2, 'a': 1}) |
| 630 | |
| 631 | ''' |
| 632 | if not isinstance(other, Counter): |
| 633 | return NotImplemented |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 634 | result = Counter() |
Raymond Hettinger | efeb8bd | 2011-04-17 20:08:41 -0700 | [diff] [blame] | 635 | for elem, count in self.items(): |
| 636 | other_count = other[elem] |
| 637 | newcount = other_count if count < other_count else count |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 638 | if newcount > 0: |
| 639 | result[elem] = newcount |
Raymond Hettinger | efeb8bd | 2011-04-17 20:08:41 -0700 | [diff] [blame] | 640 | for elem, count in other.items(): |
| 641 | if elem not in self and count > 0: |
| 642 | result[elem] = count |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 643 | return result |
| 644 | |
| 645 | def __and__(self, other): |
| 646 | ''' Intersection is the minimum of corresponding counts. |
| 647 | |
| 648 | >>> Counter('abbb') & Counter('bcc') |
| 649 | Counter({'b': 1}) |
| 650 | |
| 651 | ''' |
| 652 | if not isinstance(other, Counter): |
| 653 | return NotImplemented |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 654 | result = Counter() |
Raymond Hettinger | efeb8bd | 2011-04-17 20:08:41 -0700 | [diff] [blame] | 655 | for elem, count in self.items(): |
| 656 | other_count = other[elem] |
| 657 | newcount = count if count < other_count else other_count |
Raymond Hettinger | bad1eb2 | 2009-01-20 01:19:26 +0000 | [diff] [blame] | 658 | if newcount > 0: |
| 659 | result[elem] = newcount |
| 660 | return result |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 661 | |
| 662 | |
| 663 | if __name__ == '__main__': |
Raymond Hettinger | d36a60e | 2007-09-17 00:55:00 +0000 | [diff] [blame] | 664 | # verify that instances can be pickled |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 665 | from cPickle import loads, dumps |
Raymond Hettinger | 01a0957 | 2007-10-23 20:37:41 +0000 | [diff] [blame] | 666 | Point = namedtuple('Point', 'x, y', True) |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 667 | p = Point(x=10, y=20) |
| 668 | assert p == loads(dumps(p)) |
| 669 | |
Raymond Hettinger | eeeb9c4 | 2007-11-15 02:44:53 +0000 | [diff] [blame] | 670 | # test and demonstrate ability to override methods |
Raymond Hettinger | b8e0072 | 2008-01-07 04:24:49 +0000 | [diff] [blame] | 671 | class Point(namedtuple('Point', 'x y')): |
Raymond Hettinger | e165508 | 2008-01-10 19:15:10 +0000 | [diff] [blame] | 672 | __slots__ = () |
Raymond Hettinger | b8e0072 | 2008-01-07 04:24:49 +0000 | [diff] [blame] | 673 | @property |
| 674 | def hypot(self): |
| 675 | return (self.x ** 2 + self.y ** 2) ** 0.5 |
Raymond Hettinger | 9a35921 | 2008-01-07 20:07:38 +0000 | [diff] [blame] | 676 | def __str__(self): |
Raymond Hettinger | 15b5e55 | 2008-01-10 23:00:01 +0000 | [diff] [blame] | 677 | return 'Point: x=%6.3f y=%6.3f hypot=%6.3f' % (self.x, self.y, self.hypot) |
Raymond Hettinger | b8e0072 | 2008-01-07 04:24:49 +0000 | [diff] [blame] | 678 | |
Raymond Hettinger | e165508 | 2008-01-10 19:15:10 +0000 | [diff] [blame] | 679 | for p in Point(3, 4), Point(14, 5/7.): |
Raymond Hettinger | 9a35921 | 2008-01-07 20:07:38 +0000 | [diff] [blame] | 680 | print p |
Raymond Hettinger | eeeb9c4 | 2007-11-15 02:44:53 +0000 | [diff] [blame] | 681 | |
Raymond Hettinger | dc55f35 | 2008-01-07 09:03:49 +0000 | [diff] [blame] | 682 | class Point(namedtuple('Point', 'x y')): |
| 683 | 'Point class with optimized _make() and _replace() without error-checking' |
Raymond Hettinger | e165508 | 2008-01-10 19:15:10 +0000 | [diff] [blame] | 684 | __slots__ = () |
Raymond Hettinger | dc55f35 | 2008-01-07 09:03:49 +0000 | [diff] [blame] | 685 | _make = classmethod(tuple.__new__) |
| 686 | def _replace(self, _map=map, **kwds): |
Raymond Hettinger | f5e8af1 | 2008-01-07 20:56:05 +0000 | [diff] [blame] | 687 | return self._make(_map(kwds.get, ('x', 'y'), self)) |
Raymond Hettinger | dc55f35 | 2008-01-07 09:03:49 +0000 | [diff] [blame] | 688 | |
| 689 | print Point(11, 22)._replace(x=100) |
| 690 | |
Raymond Hettinger | e850c46 | 2008-01-10 20:37:12 +0000 | [diff] [blame] | 691 | Point3D = namedtuple('Point3D', Point._fields + ('z',)) |
| 692 | print Point3D.__doc__ |
| 693 | |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 694 | import doctest |
Raymond Hettinger | 01a0957 | 2007-10-23 20:37:41 +0000 | [diff] [blame] | 695 | TestResults = namedtuple('TestResults', 'failed attempted') |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 696 | print TestResults(*doctest.testmod()) |