Raymond Hettinger | 01a0957 | 2007-10-23 20:37:41 +0000 | [diff] [blame] | 1 | __all__ = ['deque', 'defaultdict', 'namedtuple'] |
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 | c37e5e0 | 2007-03-01 06:16:43 +0000 | [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 | 35288c6 | 2009-01-13 04:50:35 +0000 | [diff] [blame^] | 13 | from itertools import repeat as _repeat, chain as _chain, starmap as _starmap |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 14 | |
| 15 | ######################################################################## |
| 16 | ### namedtuple ####################################################### |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 17 | |
Raymond Hettinger | 01a0957 | 2007-10-23 20:37:41 +0000 | [diff] [blame] | 18 | def namedtuple(typename, field_names, verbose=False): |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 19 | """Returns a new subclass of tuple with named fields. |
| 20 | |
Raymond Hettinger | 01a0957 | 2007-10-23 20:37:41 +0000 | [diff] [blame] | 21 | >>> Point = namedtuple('Point', 'x y') |
Raymond Hettinger | d36a60e | 2007-09-17 00:55:00 +0000 | [diff] [blame] | 22 | >>> Point.__doc__ # docstring for the new class |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 23 | 'Point(x, y)' |
Raymond Hettinger | d36a60e | 2007-09-17 00:55:00 +0000 | [diff] [blame] | 24 | >>> p = Point(11, y=22) # instantiate with positional args or keywords |
Raymond Hettinger | 8777bca | 2007-12-18 22:21:27 +0000 | [diff] [blame] | 25 | >>> p[0] + p[1] # indexable like a plain tuple |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 26 | 33 |
Raymond Hettinger | 88880b2 | 2007-12-18 00:13:45 +0000 | [diff] [blame] | 27 | >>> x, y = p # unpack like a regular tuple |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 28 | >>> x, y |
| 29 | (11, 22) |
Raymond Hettinger | d36a60e | 2007-09-17 00:55:00 +0000 | [diff] [blame] | 30 | >>> p.x + p.y # fields also accessable by name |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 31 | 33 |
Raymond Hettinger | 42da874 | 2007-12-14 02:49:47 +0000 | [diff] [blame] | 32 | >>> d = p._asdict() # convert to a dictionary |
Raymond Hettinger | a7fc4b1 | 2007-10-05 02:47:07 +0000 | [diff] [blame] | 33 | >>> d['x'] |
| 34 | 11 |
| 35 | >>> Point(**d) # convert from a dictionary |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 36 | Point(x=11, y=22) |
Raymond Hettinger | 42da874 | 2007-12-14 02:49:47 +0000 | [diff] [blame] | 37 | >>> 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] | 38 | Point(x=100, y=22) |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 39 | |
| 40 | """ |
| 41 | |
Raymond Hettinger | 5816714 | 2008-01-08 02:02:05 +0000 | [diff] [blame] | 42 | # Parse and validate the field names. Validation serves two purposes, |
| 43 | # generating informative error messages and preventing template injection attacks. |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 44 | if isinstance(field_names, basestring): |
Raymond Hettinger | 0e1d606 | 2007-10-08 10:11:51 +0000 | [diff] [blame] | 45 | field_names = field_names.replace(',', ' ').split() # names separated by whitespace and/or commas |
Raymond Hettinger | 6ee7bc0 | 2008-09-25 23:31:52 +0000 | [diff] [blame] | 46 | field_names = tuple(map(str, field_names)) |
Raymond Hettinger | 050afbf | 2007-10-16 19:18:30 +0000 | [diff] [blame] | 47 | for name in (typename,) + field_names: |
Raymond Hettinger | 2e1af25 | 2007-12-05 18:11:08 +0000 | [diff] [blame] | 48 | if not all(c.isalnum() or c=='_' for c in name): |
Raymond Hettinger | 050afbf | 2007-10-16 19:18:30 +0000 | [diff] [blame] | 49 | raise ValueError('Type names and field names can only contain alphanumeric characters and underscores: %r' % name) |
Raymond Hettinger | abfd8df | 2007-10-16 21:28:32 +0000 | [diff] [blame] | 50 | if _iskeyword(name): |
| 51 | raise ValueError('Type names and field names cannot be a keyword: %r' % name) |
Raymond Hettinger | 050afbf | 2007-10-16 19:18:30 +0000 | [diff] [blame] | 52 | if name[0].isdigit(): |
| 53 | raise ValueError('Type names and field names cannot start with a number: %r' % name) |
Raymond Hettinger | 163f622 | 2007-10-09 01:36:23 +0000 | [diff] [blame] | 54 | seen_names = set() |
| 55 | for name in field_names: |
Raymond Hettinger | 42da874 | 2007-12-14 02:49:47 +0000 | [diff] [blame] | 56 | if name.startswith('_'): |
| 57 | raise ValueError('Field names cannot start with an underscore: %r' % name) |
Raymond Hettinger | 163f622 | 2007-10-09 01:36:23 +0000 | [diff] [blame] | 58 | if name in seen_names: |
Raymond Hettinger | 050afbf | 2007-10-16 19:18:30 +0000 | [diff] [blame] | 59 | raise ValueError('Encountered duplicate field name: %r' % name) |
Raymond Hettinger | 163f622 | 2007-10-09 01:36:23 +0000 | [diff] [blame] | 60 | seen_names.add(name) |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 61 | |
| 62 | # Create and fill-in the class template |
Raymond Hettinger | 02740f7 | 2008-01-05 01:35:43 +0000 | [diff] [blame] | 63 | numfields = len(field_names) |
Raymond Hettinger | 2b03d45 | 2007-09-18 03:33:19 +0000 | [diff] [blame] | 64 | argtxt = repr(field_names).replace("'", "")[1:-1] # tuple repr without parens or quotes |
Raymond Hettinger | 5a41daf | 2007-05-19 01:11:16 +0000 | [diff] [blame] | 65 | reprtxt = ', '.join('%s=%%r' % name for name in field_names) |
Raymond Hettinger | 8777bca | 2007-12-18 22:21:27 +0000 | [diff] [blame] | 66 | dicttxt = ', '.join('%r: t[%d]' % (name, pos) for pos, name in enumerate(field_names)) |
Raymond Hettinger | 5a41daf | 2007-05-19 01:11:16 +0000 | [diff] [blame] | 67 | template = '''class %(typename)s(tuple): |
Raymond Hettinger | 48eca67 | 2007-12-14 18:08:20 +0000 | [diff] [blame] | 68 | '%(typename)s(%(argtxt)s)' \n |
| 69 | __slots__ = () \n |
Raymond Hettinger | e0734e7 | 2008-01-04 03:22:53 +0000 | [diff] [blame] | 70 | _fields = %(field_names)r \n |
Raymond Hettinger | 5a41daf | 2007-05-19 01:11:16 +0000 | [diff] [blame] | 71 | def __new__(cls, %(argtxt)s): |
Raymond Hettinger | 48eca67 | 2007-12-14 18:08:20 +0000 | [diff] [blame] | 72 | return tuple.__new__(cls, (%(argtxt)s)) \n |
Raymond Hettinger | 02740f7 | 2008-01-05 01:35:43 +0000 | [diff] [blame] | 73 | @classmethod |
Raymond Hettinger | 844f71b | 2008-01-06 22:11:54 +0000 | [diff] [blame] | 74 | def _make(cls, iterable, new=tuple.__new__, len=len): |
Raymond Hettinger | 02740f7 | 2008-01-05 01:35:43 +0000 | [diff] [blame] | 75 | 'Make a new %(typename)s object from a sequence or iterable' |
Raymond Hettinger | 844f71b | 2008-01-06 22:11:54 +0000 | [diff] [blame] | 76 | result = new(cls, iterable) |
Raymond Hettinger | 02740f7 | 2008-01-05 01:35:43 +0000 | [diff] [blame] | 77 | if len(result) != %(numfields)d: |
| 78 | raise TypeError('Expected %(numfields)d arguments, got %%d' %% len(result)) |
| 79 | return result \n |
Raymond Hettinger | 5a41daf | 2007-05-19 01:11:16 +0000 | [diff] [blame] | 80 | def __repr__(self): |
Raymond Hettinger | 48eca67 | 2007-12-14 18:08:20 +0000 | [diff] [blame] | 81 | return '%(typename)s(%(reprtxt)s)' %% self \n |
Raymond Hettinger | 8777bca | 2007-12-18 22:21:27 +0000 | [diff] [blame] | 82 | def _asdict(t): |
Raymond Hettinger | 48eca67 | 2007-12-14 18:08:20 +0000 | [diff] [blame] | 83 | 'Return a new dict which maps field names to their values' |
Raymond Hettinger | 8777bca | 2007-12-18 22:21:27 +0000 | [diff] [blame] | 84 | return {%(dicttxt)s} \n |
Raymond Hettinger | 42da874 | 2007-12-14 02:49:47 +0000 | [diff] [blame] | 85 | def _replace(self, **kwds): |
Raymond Hettinger | eeeb9c4 | 2007-11-15 02:44:53 +0000 | [diff] [blame] | 86 | 'Return a new %(typename)s object replacing specified fields with new values' |
Raymond Hettinger | 1166872 | 2008-01-06 09:02:24 +0000 | [diff] [blame] | 87 | result = self._make(map(kwds.pop, %(field_names)r, self)) |
Raymond Hettinger | 1b50fd7 | 2008-01-05 02:17:24 +0000 | [diff] [blame] | 88 | if kwds: |
| 89 | raise ValueError('Got unexpected field names: %%r' %% kwds.keys()) |
Raymond Hettinger | e98839a | 2008-06-09 01:28:30 +0000 | [diff] [blame] | 90 | return result \n |
| 91 | def __getnewargs__(self): |
| 92 | return tuple(self) \n\n''' % locals() |
Raymond Hettinger | 5a41daf | 2007-05-19 01:11:16 +0000 | [diff] [blame] | 93 | for i, name in enumerate(field_names): |
Raymond Hettinger | 2b03d45 | 2007-09-18 03:33:19 +0000 | [diff] [blame] | 94 | template += ' %s = property(itemgetter(%d))\n' % (name, i) |
| 95 | if verbose: |
| 96 | print template |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 97 | |
Raymond Hettinger | 3c2523c | 2008-05-30 07:16:53 +0000 | [diff] [blame] | 98 | # Execute the template string in a temporary namespace and |
| 99 | # support tracing utilities by setting a value for frame.f_globals['__name__'] |
| 100 | namespace = dict(itemgetter=_itemgetter, __name__='namedtuple_%s' % typename) |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 101 | try: |
Raymond Hettinger | 0e1d606 | 2007-10-08 10:11:51 +0000 | [diff] [blame] | 102 | exec template in namespace |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 103 | except SyntaxError, e: |
| 104 | raise SyntaxError(e.message + ':\n' + template) |
Raymond Hettinger | 0e1d606 | 2007-10-08 10:11:51 +0000 | [diff] [blame] | 105 | result = namespace[typename] |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 106 | |
| 107 | # For pickling to work, the __module__ variable needs to be set to the frame |
| 108 | # where the named tuple is created. Bypass this step in enviroments where |
| 109 | # sys._getframe is not defined (Jython for example). |
Raymond Hettinger | 5a41daf | 2007-05-19 01:11:16 +0000 | [diff] [blame] | 110 | if hasattr(_sys, '_getframe'): |
| 111 | result.__module__ = _sys._getframe(1).f_globals['__name__'] |
Raymond Hettinger | 2115bbc | 2007-10-08 09:14:28 +0000 | [diff] [blame] | 112 | |
Raymond Hettinger | 5a41daf | 2007-05-19 01:11:16 +0000 | [diff] [blame] | 113 | return result |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 114 | |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 115 | |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 116 | ######################################################################## |
| 117 | ### Counter ########################################################## |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 118 | |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 119 | class Counter(dict): |
| 120 | '''Dict subclass for counting hashable items. Sometimes called a bag |
| 121 | or multiset. Elements are stored as dictionary keys and their counts |
| 122 | are stored as dictionary values. |
| 123 | |
| 124 | >>> c = Counter('abracadabra') # count elements from a string |
| 125 | |
| 126 | >>> c.most_common(3) # three most common elements |
| 127 | [('a', 5), ('r', 2), ('b', 2)] |
| 128 | >>> sorted(c) # list all unique elements |
| 129 | ['a', 'b', 'c', 'd', 'r'] |
| 130 | >>> ''.join(sorted(c.elements())) # list elements with repetitions |
| 131 | 'aaaaabbcdrr' |
| 132 | >>> sum(c.values()) # total of all counts |
| 133 | 11 |
| 134 | |
| 135 | >>> c['a'] # count of letter 'a' |
| 136 | 5 |
| 137 | >>> for elem in 'shazam': # update counts from an iterable |
| 138 | ... c[elem] += 1 # by adding 1 to each element's count |
| 139 | >>> c['a'] # now there are seven 'a' |
| 140 | 7 |
| 141 | >>> del c['r'] # remove all 'r' |
| 142 | >>> c['r'] # now there are zero 'r' |
| 143 | 0 |
| 144 | |
| 145 | >>> d = Counter('simsalabim') # make another counter |
| 146 | >>> c.update(d) # add in the second counter |
| 147 | >>> c['a'] # now there are nine 'a' |
| 148 | 9 |
| 149 | |
| 150 | >>> c.clear() # empty the counter |
| 151 | >>> c |
| 152 | Counter() |
| 153 | |
| 154 | Note: If a count is set to zero or reduced to zero, it will remain |
| 155 | in the counter until the entry is deleted or the counter is cleared: |
| 156 | |
| 157 | >>> c = Counter('aaabbc') |
| 158 | >>> c['b'] -= 2 # reduce the count of 'b' by two |
| 159 | >>> c.most_common() # 'b' is still in, but its count is zero |
| 160 | [('a', 3), ('c', 1), ('b', 0)] |
| 161 | |
| 162 | ''' |
| 163 | # References: |
| 164 | # http://en.wikipedia.org/wiki/Multiset |
| 165 | # http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html |
| 166 | # http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm |
| 167 | # http://code.activestate.com/recipes/259174/ |
| 168 | # Knuth, TAOCP Vol. II section 4.6.3 |
| 169 | |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 170 | def __init__(self, iterable=None): |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 171 | '''Create a new, empty Counter object. And if given, count elements |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 172 | from an input iterable. Or, initialize the count from another mapping |
| 173 | of elements to their counts. |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 174 | |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 175 | >>> c = Counter() # a new, empty counter |
Raymond Hettinger | 783d73f | 2009-01-13 04:13:53 +0000 | [diff] [blame] | 176 | >>> c = Counter('gallahad') # a new counter from an iterable |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 177 | >>> c = Counter({'a': 4, 'b': 2}) # a new counter from a mapping |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 178 | |
| 179 | ''' |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 180 | self.update(iterable) |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 181 | |
| 182 | def __missing__(self, key): |
| 183 | 'The count of elements not in the Counter is zero.' |
| 184 | # Needed so that self[missing_item] does not raise KeyError |
| 185 | return 0 |
| 186 | |
| 187 | def most_common(self, n=None): |
| 188 | '''List the n most common elements and their counts from the most |
| 189 | common to the least. If n is None, then list all element counts. |
| 190 | |
| 191 | >>> Counter('abracadabra').most_common(3) |
| 192 | [('a', 5), ('r', 2), ('b', 2)] |
| 193 | |
| 194 | ''' |
| 195 | # Emulate Bag.sortedByCount from Smalltalk |
| 196 | if n is None: |
| 197 | return sorted(self.iteritems(), key=_itemgetter(1), reverse=True) |
| 198 | return _heapq.nlargest(n, self.iteritems(), key=_itemgetter(1)) |
| 199 | |
| 200 | def elements(self): |
| 201 | '''Iterator over elements repeating each as many times as its count. |
| 202 | |
| 203 | >>> c = Counter('ABCABC') |
| 204 | >>> sorted(c.elements()) |
| 205 | ['A', 'A', 'B', 'B', 'C', 'C'] |
| 206 | |
Raymond Hettinger | 783d73f | 2009-01-13 04:13:53 +0000 | [diff] [blame] | 207 | # Knuth's example for prime factors of 1836: 2**2 * 3**3 * 17**1 |
| 208 | >>> prime_factors = Counter({2: 2, 3: 3, 17: 1}) |
| 209 | >>> product = 1 |
| 210 | >>> for factor in prime_factors.elements(): # loop over factors |
| 211 | ... product *= factor # and multiply them |
| 212 | >>> product |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 213 | 1836 |
| 214 | |
Raymond Hettinger | 783d73f | 2009-01-13 04:13:53 +0000 | [diff] [blame] | 215 | Note, if an element's count has been set to zero or is a negative |
| 216 | number, elements() will ignore it. |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 217 | |
| 218 | ''' |
| 219 | # Emulate Bag.do from Smalltalk and Multiset.begin from C++. |
Raymond Hettinger | 35288c6 | 2009-01-13 04:50:35 +0000 | [diff] [blame^] | 220 | return _chain.from_iterable(_starmap(_repeat, self.iteritems())) |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 221 | |
| 222 | # Override dict methods where necessary |
| 223 | |
| 224 | @classmethod |
| 225 | def fromkeys(cls, iterable, v=None): |
| 226 | # There is no equivalent method for counters because setting v=1 |
| 227 | # means that no element can have a count greater than one. |
| 228 | raise NotImplementedError( |
| 229 | 'Counter.fromkeys() is undefined. Use Counter(iterable) instead.') |
| 230 | |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 231 | def update(self, iterable=None): |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 232 | '''Like dict.update() but add counts instead of replacing them. |
| 233 | |
Raymond Hettinger | 783d73f | 2009-01-13 04:13:53 +0000 | [diff] [blame] | 234 | Source can be an iterable, a dictionary, or another Counter instance. |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 235 | |
| 236 | >>> c = Counter('which') |
Raymond Hettinger | 783d73f | 2009-01-13 04:13:53 +0000 | [diff] [blame] | 237 | >>> c.update('witch') # add elements from another iterable |
| 238 | >>> d = Counter('watch') |
| 239 | >>> c.update(d) # add elements from another counter |
| 240 | >>> c['h'] # four 'h' in which, witch, and watch |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 241 | 4 |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 242 | |
| 243 | ''' |
| 244 | # The regular dict.update() operation makes no sense here because the |
| 245 | # replace behavior results in the some of original untouched counts |
| 246 | # being mixed-in with all of the other counts for a mismash that |
| 247 | # doesn't have a straight-forward interpretation in most counting |
| 248 | # contexts. Instead, we look to Knuth for suggested operations on |
| 249 | # multisets and implement the union-add operation discussed in |
| 250 | # TAOCP Volume II section 4.6.3 exercise 19. The Wikipedia entry for |
| 251 | # multisets calls that operation a sum or join. |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 252 | |
| 253 | if iterable is not None: |
| 254 | if isinstance(iterable, Mapping): |
| 255 | for elem, count in iterable.iteritems(): |
| 256 | self[elem] += count |
| 257 | else: |
| 258 | for elem in iterable: |
| 259 | self[elem] += 1 |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 260 | |
| 261 | def copy(self): |
| 262 | 'Like dict.copy() but returns a Counter instance instead of a dict.' |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 263 | return Counter(self) |
Raymond Hettinger | f94d7fa | 2009-01-12 22:58:41 +0000 | [diff] [blame] | 264 | |
| 265 | def __repr__(self): |
| 266 | if not self: |
| 267 | return '%s()' % self.__class__.__name__ |
Raymond Hettinger | 35288c6 | 2009-01-13 04:50:35 +0000 | [diff] [blame^] | 268 | items = ', '.join(map('%r: %r'.__mod__, self.most_common())) |
Raymond Hettinger | aaa6e63 | 2009-01-13 01:05:03 +0000 | [diff] [blame] | 269 | return '%s({%s})' % (self.__class__.__name__, items) |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 270 | |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 271 | |
| 272 | |
| 273 | if __name__ == '__main__': |
Raymond Hettinger | d36a60e | 2007-09-17 00:55:00 +0000 | [diff] [blame] | 274 | # verify that instances can be pickled |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 275 | from cPickle import loads, dumps |
Raymond Hettinger | 01a0957 | 2007-10-23 20:37:41 +0000 | [diff] [blame] | 276 | Point = namedtuple('Point', 'x, y', True) |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 277 | p = Point(x=10, y=20) |
| 278 | assert p == loads(dumps(p)) |
| 279 | |
Raymond Hettinger | eeeb9c4 | 2007-11-15 02:44:53 +0000 | [diff] [blame] | 280 | # test and demonstrate ability to override methods |
Raymond Hettinger | b8e0072 | 2008-01-07 04:24:49 +0000 | [diff] [blame] | 281 | class Point(namedtuple('Point', 'x y')): |
Raymond Hettinger | e165508 | 2008-01-10 19:15:10 +0000 | [diff] [blame] | 282 | __slots__ = () |
Raymond Hettinger | b8e0072 | 2008-01-07 04:24:49 +0000 | [diff] [blame] | 283 | @property |
| 284 | def hypot(self): |
| 285 | return (self.x ** 2 + self.y ** 2) ** 0.5 |
Raymond Hettinger | 9a35921 | 2008-01-07 20:07:38 +0000 | [diff] [blame] | 286 | def __str__(self): |
Raymond Hettinger | 15b5e55 | 2008-01-10 23:00:01 +0000 | [diff] [blame] | 287 | 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] | 288 | |
Raymond Hettinger | e165508 | 2008-01-10 19:15:10 +0000 | [diff] [blame] | 289 | for p in Point(3, 4), Point(14, 5/7.): |
Raymond Hettinger | 9a35921 | 2008-01-07 20:07:38 +0000 | [diff] [blame] | 290 | print p |
Raymond Hettinger | eeeb9c4 | 2007-11-15 02:44:53 +0000 | [diff] [blame] | 291 | |
Raymond Hettinger | dc55f35 | 2008-01-07 09:03:49 +0000 | [diff] [blame] | 292 | class Point(namedtuple('Point', 'x y')): |
| 293 | 'Point class with optimized _make() and _replace() without error-checking' |
Raymond Hettinger | e165508 | 2008-01-10 19:15:10 +0000 | [diff] [blame] | 294 | __slots__ = () |
Raymond Hettinger | dc55f35 | 2008-01-07 09:03:49 +0000 | [diff] [blame] | 295 | _make = classmethod(tuple.__new__) |
| 296 | def _replace(self, _map=map, **kwds): |
Raymond Hettinger | f5e8af1 | 2008-01-07 20:56:05 +0000 | [diff] [blame] | 297 | return self._make(_map(kwds.get, ('x', 'y'), self)) |
Raymond Hettinger | dc55f35 | 2008-01-07 09:03:49 +0000 | [diff] [blame] | 298 | |
| 299 | print Point(11, 22)._replace(x=100) |
| 300 | |
Raymond Hettinger | e850c46 | 2008-01-10 20:37:12 +0000 | [diff] [blame] | 301 | Point3D = namedtuple('Point3D', Point._fields + ('z',)) |
| 302 | print Point3D.__doc__ |
| 303 | |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 304 | import doctest |
Raymond Hettinger | 01a0957 | 2007-10-23 20:37:41 +0000 | [diff] [blame] | 305 | TestResults = namedtuple('TestResults', 'failed attempted') |
Raymond Hettinger | c37e5e0 | 2007-03-01 06:16:43 +0000 | [diff] [blame] | 306 | print TestResults(*doctest.testmod()) |