|
__all__ = ['Counter', 'deque', 'defaultdict', 'namedtuple', 'OrderedDict'] |
|
# For bootstrapping reasons, the collection ABCs are defined in _abcoll.py. |
|
# They should however be considered an integral part of collections.py. |
|
from _abcoll import * |
|
import _abcoll |
|
__all__ += _abcoll.__all__ |
|
|
|
from _collections import deque, defaultdict |
|
from operator import itemgetter as _itemgetter, eq as _eq |
|
from keyword import iskeyword as _iskeyword |
|
import sys as _sys |
|
import heapq as _heapq |
|
from itertools import repeat as _repeat, chain as _chain, starmap as _starmap |
|
from itertools import imap as _imap |
|
|
|
try: |
|
from thread import get_ident as _get_ident |
|
except ImportError: |
|
from dummy_thread import get_ident as _get_ident |
|
|
|
|
|
################################################################################ |
|
### OrderedDict |
|
################################################################################ |
|
|
|
class OrderedDict(dict): |
|
'Dictionary that remembers insertion order' |
|
# An inherited dict maps keys to values. |
|
# The inherited dict provides __getitem__, __len__, __contains__, and get. |
|
# The remaining methods are order-aware. |
|
# Big-O running times for all methods are the same as regular dictionaries. |
|
|
|
# The internal self.__map dict maps keys to links in a doubly linked list. |
|
# The circular doubly linked list starts and ends with a sentinel element. |
|
# The sentinel element never gets deleted (this simplifies the algorithm). |
|
# Each link is stored as a list of length three: [PREV, NEXT, KEY]. |
|
|
|
def __init__(*args, **kwds): |
|
'''Initialize an ordered dictionary. The signature is the same as |
|
regular dictionaries, but keyword arguments are not recommended because |
|
their insertion order is arbitrary. |
|
|
|
''' |
|
if not args: |
|
raise TypeError("descriptor '__init__' of 'OrderedDict' object " |
|
"needs an argument") |
|
self = args[0] |
|
args = args[1:] |
|
if len(args) > 1: |
|
raise TypeError('expected at most 1 arguments, got %d' % len(args)) |
|
try: |
|
self.__root |
|
except AttributeError: |
|
self.__root = root = [] # sentinel node |
|
root[:] = [root, root, None] |
|
self.__map = {} |
|
self.__update(*args, **kwds) |
|
|
|
def __setitem__(self, key, value, dict_setitem=dict.__setitem__): |
|
'od.__setitem__(i, y) <==> od[i]=y' |
|
# Setting a new item creates a new link at the end of the linked list, |
|
# and the inherited dictionary is updated with the new key/value pair. |
|
if key not in self: |
|
root = self.__root |
|
last = root[0] |
|
last[1] = root[0] = self.__map[key] = [last, root, key] |
|
return dict_setitem(self, key, value) |
|
|
|
def __delitem__(self, key, dict_delitem=dict.__delitem__): |
|
'od.__delitem__(y) <==> del od[y]' |
|
# Deleting an existing item uses self.__map to find the link which gets |
|
# removed by updating the links in the predecessor and successor nodes. |
|
dict_delitem(self, key) |
|
link_prev, link_next, _ = self.__map.pop(key) |
|
link_prev[1] = link_next # update link_prev[NEXT] |
|
link_next[0] = link_prev # update link_next[PREV] |
|
|
|
def __iter__(self): |
|
'od.__iter__() <==> iter(od)' |
|
# Traverse the linked list in order. |
|
root = self.__root |
|
curr = root[1] # start at the first node |
|
while curr is not root: |
|
yield curr[2] # yield the curr[KEY] |
|
curr = curr[1] # move to next node |
|
|
|
def __reversed__(self): |
|
'od.__reversed__() <==> reversed(od)' |
|
# Traverse the linked list in reverse order. |
|
root = self.__root |
|
curr = root[0] # start at the last node |
|
while curr is not root: |
|
yield curr[2] # yield the curr[KEY] |
|
curr = curr[0] # move to previous node |
|
|
|
def clear(self): |
|
'od.clear() -> None. Remove all items from od.' |
|
root = self.__root |
|
root[:] = [root, root, None] |
|
self.__map.clear() |
|
dict.clear(self) |
|
|
|
# -- the following methods do not depend on the internal structure -- |
|
|
|
def keys(self): |
|
'od.keys() -> list of keys in od' |
|
return list(self) |
|
|
|
def values(self): |
|
'od.values() -> list of values in od' |
|
return [self[key] for key in self] |
|
|
|
def items(self): |
|
'od.items() -> list of (key, value) pairs in od' |
|
return [(key, self[key]) for key in self] |
|
|
|
def iterkeys(self): |
|
'od.iterkeys() -> an iterator over the keys in od' |
|
return iter(self) |
|
|
|
def itervalues(self): |
|
'od.itervalues -> an iterator over the values in od' |
|
for k in self: |
|
yield self[k] |
|
|
|
def iteritems(self): |
|
'od.iteritems -> an iterator over the (key, value) pairs in od' |
|
for k in self: |
|
yield (k, self[k]) |
|
|
|
update = MutableMapping.update |
|
|
|
__update = update # let subclasses override update without breaking __init__ |
|
|
|
__marker = object() |
|
|
|
def pop(self, key, default=__marker): |
|
'''od.pop(k[,d]) -> v, remove specified key and return the corresponding |
|
value. If key is not found, d is returned if given, otherwise KeyError |
|
is raised. |
|
|
|
''' |
|
if key in self: |
|
result = self[key] |
|
del self[key] |
|
return result |
|
if default is self.__marker: |
|
raise KeyError(key) |
|
return default |
|
|
|
def setdefault(self, key, default=None): |
|
'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od' |
|
if key in self: |
|
return self[key] |
|
self[key] = default |
|
return default |
|
|
|
def popitem(self, last=True): |
|
'''od.popitem() -> (k, v), return and remove a (key, value) pair. |
|
Pairs are returned in LIFO order if last is true or FIFO order if false. |
|
|
|
''' |
|
if not self: |
|
raise KeyError('dictionary is empty') |
|
key = next(reversed(self) if last else iter(self)) |
|
value = self.pop(key) |
|
return key, value |
|
|
|
def __repr__(self, _repr_running={}): |
|
'od.__repr__() <==> repr(od)' |
|
call_key = id(self), _get_ident() |
|
if call_key in _repr_running: |
|
return '...' |
|
_repr_running[call_key] = 1 |
|
try: |
|
if not self: |
|
return '%s()' % (self.__class__.__name__,) |
|
return '%s(%r)' % (self.__class__.__name__, self.items()) |
|
finally: |
|
del _repr_running[call_key] |
|
|
|
def __reduce__(self): |
|
'Return state information for pickling' |
|
items = [[k, self[k]] for k in self] |
|
inst_dict = vars(self).copy() |
|
for k in vars(OrderedDict()): |
|
inst_dict.pop(k, None) |
|
if inst_dict: |
|
return (self.__class__, (items,), inst_dict) |
|
return self.__class__, (items,) |
|
|
|
def copy(self): |
|
'od.copy() -> a shallow copy of od' |
|
return self.__class__(self) |
|
|
|
@classmethod |
|
def fromkeys(cls, iterable, value=None): |
|
'''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S. |
|
If not specified, the value defaults to None. |
|
|
|
''' |
|
self = cls() |
|
for key in iterable: |
|
self[key] = value |
|
return self |
|
|
|
def __eq__(self, other): |
|
'''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive |
|
while comparison to a regular mapping is order-insensitive. |
|
|
|
''' |
|
if isinstance(other, OrderedDict): |
|
return dict.__eq__(self, other) and all(_imap(_eq, self, other)) |
|
return dict.__eq__(self, other) |
|
|
|
def __ne__(self, other): |
|
'od.__ne__(y) <==> od!=y' |
|
return not self == other |
|
|
|
# -- the following methods support python 3.x style dictionary views -- |
|
|
|
def viewkeys(self): |
|
"od.viewkeys() -> a set-like object providing a view on od's keys" |
|
return KeysView(self) |
|
|
|
def viewvalues(self): |
|
"od.viewvalues() -> an object providing a view on od's values" |
|
return ValuesView(self) |
|
|
|
def viewitems(self): |
|
"od.viewitems() -> a set-like object providing a view on od's items" |
|
return ItemsView(self) |
|
|
|
|
|
################################################################################ |
|
### namedtuple |
|
################################################################################ |
|
|
|
class namedtuple(tuple): |
|
def __new__(_cls, *args): |
|
if _cls is namedtuple: return _namedtuple(*args) |
|
return tuple.__new__(_cls, *args) |
|
|
|
_class_template = '''\ |
|
class {typename}(namedtuple): |
|
'{typename}({arg_list})' |
|
|
|
__slots__ = () |
|
|
|
_fields = {field_names!r} |
|
|
|
def __new__(_cls, {arg_list}): |
|
'Create new instance of {typename}({arg_list})' |
|
return namedtuple.__new__(_cls, ({arg_list})) |
|
|
|
@classmethod |
|
def _make(cls, iterable, new=tuple.__new__, len=len): |
|
'Make a new {typename} object from a sequence or iterable' |
|
result = new(cls, iterable) |
|
if len(result) != {num_fields:d}: |
|
raise TypeError('Expected {num_fields:d} arguments, got %d' % len(result)) |
|
return result |
|
|
|
def __repr__(self): |
|
'Return a nicely formatted representation string' |
|
return '{typename}({repr_fmt})' % self |
|
|
|
def _asdict(self): |
|
'Return a new OrderedDict which maps field names to their values' |
|
return OrderedDict(zip(self._fields, self)) |
|
|
|
def _replace(_self, **kwds): |
|
'Return a new {typename} object replacing specified fields with new values' |
|
result = _self._make(map(kwds.pop, {field_names!r}, _self)) |
|
if kwds: |
|
raise ValueError('Got unexpected field names: %r' % kwds.keys()) |
|
return result |
|
|
|
def __getnewargs__(self): |
|
'Return self as a plain tuple. Used by copy and pickle.' |
|
return tuple(self) |
|
|
|
__dict__ = _property(_asdict) |
|
|
|
def __getstate__(self): |
|
'Exclude the OrderedDict from pickling' |
|
pass |
|
|
|
{field_defs} |
|
''' |
|
|
|
_repr_template = '{name}=%r' |
|
|
|
_field_template = '''\ |
|
{name} = _property(_itemgetter({index:d}), doc='Alias for field number {index:d}') |
|
''' |
|
|
|
def _namedtuple(typename, field_names, verbose=False, rename=False): |
|
"""Returns a new subclass of tuple with named fields. |
|
|
|
>>> Point = namedtuple('Point', ['x', 'y']) |
|
>>> Point.__doc__ # docstring for the new class |
|
'Point(x, y)' |
|
>>> p = Point(11, y=22) # instantiate with positional args or keywords |
|
>>> p[0] + p[1] # indexable like a plain tuple |
|
33 |
|
>>> x, y = p # unpack like a regular tuple |
|
>>> x, y |
|
(11, 22) |
|
>>> p.x + p.y # fields also accessable by name |
|
33 |
|
>>> d = p._asdict() # convert to a dictionary |
|
>>> d['x'] |
|
11 |
|
>>> Point(**d) # convert from a dictionary |
|
Point(x=11, y=22) |
|
>>> p._replace(x=100) # _replace() is like str.replace() but targets named fields |
|
Point(x=100, y=22) |
|
|
|
""" |
|
|
|
# Validate the field names. At the user's option, either generate an error |
|
# message or automatically replace the field name with a valid name. |
|
if isinstance(field_names, basestring): |
|
field_names = field_names.replace(',', ' ').split() |
|
field_names = map(str, field_names) |
|
typename = str(typename) |
|
if rename: |
|
seen = set() |
|
for index, name in enumerate(field_names): |
|
if (not all(c.isalnum() or c=='_' for c in name) |
|
or _iskeyword(name) |
|
or not name |
|
or name[0].isdigit() |
|
or name.startswith('_') |
|
or name in seen): |
|
field_names[index] = '_%d' % index |
|
seen.add(name) |
|
for name in [typename] + field_names: |
|
if type(name) != str: |
|
raise TypeError('Type names and field names must be strings') |
|
if not all(c.isalnum() or c=='_' for c in name): |
|
raise ValueError('Type names and field names can only contain ' |
|
'alphanumeric characters and underscores: %r' % name) |
|
if _iskeyword(name): |
|
raise ValueError('Type names and field names cannot be a ' |
|
'keyword: %r' % name) |
|
if name[0].isdigit(): |
|
raise ValueError('Type names and field names cannot start with ' |
|
'a number: %r' % name) |
|
seen = set() |
|
for name in field_names: |
|
if name.startswith('_') and not rename: |
|
raise ValueError('Field names cannot start with an underscore: ' |
|
'%r' % name) |
|
if name in seen: |
|
raise ValueError('Encountered duplicate field name: %r' % name) |
|
seen.add(name) |
|
|
|
# Fill-in the class template |
|
class_definition = _class_template.format( |
|
typename = typename, |
|
field_names = tuple(field_names), |
|
num_fields = len(field_names), |
|
arg_list = repr(tuple(field_names)).replace("'", "")[1:-1], |
|
repr_fmt = ', '.join(_repr_template.format(name=name) |
|
for name in field_names), |
|
field_defs = '\n'.join(_field_template.format(index=index, name=name) |
|
for index, name in enumerate(field_names)) |
|
) |
|
if verbose: |
|
print class_definition |
|
|
|
# Execute the template string in a temporary namespace and support |
|
# tracing utilities by setting a value for frame.f_globals['__name__'] |
|
namespace = dict(_itemgetter=_itemgetter, __name__='namedtuple_%s' % typename, |
|
OrderedDict=OrderedDict, _property=property, namedtuple=namedtuple) |
|
try: |
|
exec class_definition in namespace |
|
except SyntaxError as e: |
|
raise SyntaxError(e.message + ':\n' + class_definition) |
|
result = namespace[typename] |
|
|
|
# For pickling to work, the __module__ variable needs to be set to the frame |
|
# where the named tuple is created. Bypass this step in environments where |
|
# sys._getframe is not defined (Jython for example) or sys._getframe is not |
|
# defined for arguments greater than 0 (IronPython). |
|
try: |
|
result.__module__ = _sys._getframe(1).f_globals.get('__name__', '__main__') |
|
except (AttributeError, ValueError): |
|
pass |
|
|
|
return result |
|
|
|
|
|
######################################################################## |
|
### Counter |
|
######################################################################## |
|
|
|
class Counter(dict): |
|
'''Dict subclass for counting hashable items. Sometimes called a bag |
|
or multiset. Elements are stored as dictionary keys and their counts |
|
are stored as dictionary values. |
|
|
|
>>> c = Counter('abcdeabcdabcaba') # count elements from a string |
|
|
|
>>> c.most_common(3) # three most common elements |
|
[('a', 5), ('b', 4), ('c', 3)] |
|
>>> sorted(c) # list all unique elements |
|
['a', 'b', 'c', 'd', 'e'] |
|
>>> ''.join(sorted(c.elements())) # list elements with repetitions |
|
'aaaaabbbbcccdde' |
|
>>> sum(c.values()) # total of all counts |
|
15 |
|
|
|
>>> c['a'] # count of letter 'a' |
|
5 |
|
>>> for elem in 'shazam': # update counts from an iterable |
|
... c[elem] += 1 # by adding 1 to each element's count |
|
>>> c['a'] # now there are seven 'a' |
|
7 |
|
>>> del c['b'] # remove all 'b' |
|
>>> c['b'] # now there are zero 'b' |
|
0 |
|
|
|
>>> d = Counter('simsalabim') # make another counter |
|
>>> c.update(d) # add in the second counter |
|
>>> c['a'] # now there are nine 'a' |
|
9 |
|
|
|
>>> c.clear() # empty the counter |
|
>>> c |
|
Counter() |
|
|
|
Note: If a count is set to zero or reduced to zero, it will remain |
|
in the counter until the entry is deleted or the counter is cleared: |
|
|
|
>>> c = Counter('aaabbc') |
|
>>> c['b'] -= 2 # reduce the count of 'b' by two |
|
>>> c.most_common() # 'b' is still in, but its count is zero |
|
[('a', 3), ('c', 1), ('b', 0)] |
|
|
|
''' |
|
# References: |
|
# http://en.wikipedia.org/wiki/Multiset |
|
# http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html |
|
# http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm |
|
# http://code.activestate.com/recipes/259174/ |
|
# Knuth, TAOCP Vol. II section 4.6.3 |
|
|
|
def __init__(*args, **kwds): |
|
'''Create a new, empty Counter object. And if given, count elements |
|
from an input iterable. Or, initialize the count from another mapping |
|
of elements to their counts. |
|
|
|
>>> c = Counter() # a new, empty counter |
|
>>> c = Counter('gallahad') # a new counter from an iterable |
|
>>> c = Counter({'a': 4, 'b': 2}) # a new counter from a mapping |
|
>>> c = Counter(a=4, b=2) # a new counter from keyword args |
|
|
|
''' |
|
if not args: |
|
raise TypeError("descriptor '__init__' of 'Counter' object " |
|
"needs an argument") |
|
self = args[0] |
|
args = args[1:] |
|
if len(args) > 1: |
|
raise TypeError('expected at most 1 arguments, got %d' % len(args)) |
|
super(Counter, self).__init__() |
|
self.update(*args, **kwds) |
|
|
|
def __missing__(self, key): |
|
'The count of elements not in the Counter is zero.' |
|
# Needed so that self[missing_item] does not raise KeyError |
|
return 0 |
|
|
|
def most_common(self, n=None): |
|
'''List the n most common elements and their counts from the most |
|
common to the least. If n is None, then list all element counts. |
|
|
|
>>> Counter('abcdeabcdabcaba').most_common(3) |
|
[('a', 5), ('b', 4), ('c', 3)] |
|
|
|
''' |
|
# Emulate Bag.sortedByCount from Smalltalk |
|
if n is None: |
|
return sorted(self.iteritems(), key=_itemgetter(1), reverse=True) |
|
return _heapq.nlargest(n, self.iteritems(), key=_itemgetter(1)) |
|
|
|
def elements(self): |
|
'''Iterator over elements repeating each as many times as its count. |
|
|
|
>>> c = Counter('ABCABC') |
|
>>> sorted(c.elements()) |
|
['A', 'A', 'B', 'B', 'C', 'C'] |
|
|
|
# Knuth's example for prime factors of 1836: 2**2 * 3**3 * 17**1 |
|
>>> prime_factors = Counter({2: 2, 3: 3, 17: 1}) |
|
>>> product = 1 |
|
>>> for factor in prime_factors.elements(): # loop over factors |
|
... product *= factor # and multiply them |
|
>>> product |
|
1836 |
|
|
|
Note, if an element's count has been set to zero or is a negative |
|
number, elements() will ignore it. |
|
|
|
''' |
|
# Emulate Bag.do from Smalltalk and Multiset.begin from C++. |
|
return _chain.from_iterable(_starmap(_repeat, self.iteritems())) |
|
|
|
# Override dict methods where necessary |
|
|
|
@classmethod |
|
def fromkeys(cls, iterable, v=None): |
|
# There is no equivalent method for counters because setting v=1 |
|
# means that no element can have a count greater than one. |
|
raise NotImplementedError( |
|
'Counter.fromkeys() is undefined. Use Counter(iterable) instead.') |
|
|
|
def update(*args, **kwds): |
|
'''Like dict.update() but add counts instead of replacing them. |
|
|
|
Source can be an iterable, a dictionary, or another Counter instance. |
|
|
|
>>> c = Counter('which') |
|
>>> c.update('witch') # add elements from another iterable |
|
>>> d = Counter('watch') |
|
>>> c.update(d) # add elements from another counter |
|
>>> c['h'] # four 'h' in which, witch, and watch |
|
4 |
|
|
|
''' |
|
# The regular dict.update() operation makes no sense here because the |
|
# replace behavior results in the some of original untouched counts |
|
# being mixed-in with all of the other counts for a mismash that |
|
# doesn't have a straight-forward interpretation in most counting |
|
# contexts. Instead, we implement straight-addition. Both the inputs |
|
# and outputs are allowed to contain zero and negative counts. |
|
|
|
if not args: |
|
raise TypeError("descriptor 'update' of 'Counter' object " |
|
"needs an argument") |
|
self = args[0] |
|
args = args[1:] |
|
if len(args) > 1: |
|
raise TypeError('expected at most 1 arguments, got %d' % len(args)) |
|
iterable = args[0] if args else None |
|
if iterable is not None: |
|
if isinstance(iterable, Mapping): |
|
if self: |
|
self_get = self.get |
|
for elem, count in iterable.iteritems(): |
|
self[elem] = self_get(elem, 0) + count |
|
else: |
|
super(Counter, self).update(iterable) # fast path when counter is empty |
|
else: |
|
self_get = self.get |
|
for elem in iterable: |
|
self[elem] = self_get(elem, 0) + 1 |
|
if kwds: |
|
self.update(kwds) |
|
|
|
def subtract(*args, **kwds): |
|
'''Like dict.update() but subtracts counts instead of replacing them. |
|
Counts can be reduced below zero. Both the inputs and outputs are |
|
allowed to contain zero and negative counts. |
|
|
|
Source can be an iterable, a dictionary, or another Counter instance. |
|
|
|
>>> c = Counter('which') |
|
>>> c.subtract('witch') # subtract elements from another iterable |
|
>>> c.subtract(Counter('watch')) # subtract elements from another counter |
|
>>> c['h'] # 2 in which, minus 1 in witch, minus 1 in watch |
|
0 |
|
>>> c['w'] # 1 in which, minus 1 in witch, minus 1 in watch |
|
-1 |
|
|
|
''' |
|
if not args: |
|
raise TypeError("descriptor 'subtract' of 'Counter' object " |
|
"needs an argument") |
|
self = args[0] |
|
args = args[1:] |
|
if len(args) > 1: |
|
raise TypeError('expected at most 1 arguments, got %d' % len(args)) |
|
iterable = args[0] if args else None |
|
if iterable is not None: |
|
self_get = self.get |
|
if isinstance(iterable, Mapping): |
|
for elem, count in iterable.items(): |
|
self[elem] = self_get(elem, 0) - count |
|
else: |
|
for elem in iterable: |
|
self[elem] = self_get(elem, 0) - 1 |
|
if kwds: |
|
self.subtract(kwds) |
|
|
|
def copy(self): |
|
'Return a shallow copy.' |
|
return self.__class__(self) |
|
|
|
def __reduce__(self): |
|
return self.__class__, (dict(self),) |
|
|
|
def __delitem__(self, elem): |
|
'Like dict.__delitem__() but does not raise KeyError for missing values.' |
|
if elem in self: |
|
super(Counter, self).__delitem__(elem) |
|
|
|
def __repr__(self): |
|
if not self: |
|
return '%s()' % self.__class__.__name__ |
|
items = ', '.join(map('%r: %r'.__mod__, self.most_common())) |
|
return '%s({%s})' % (self.__class__.__name__, items) |
|
|
|
# Multiset-style mathematical operations discussed in: |
|
# Knuth TAOCP Volume II section 4.6.3 exercise 19 |
|
# and at http://en.wikipedia.org/wiki/Multiset |
|
# |
|
# Outputs guaranteed to only include positive counts. |
|
# |
|
# To strip negative and zero counts, add-in an empty counter: |
|
# c += Counter() |
|
|
|
def __add__(self, other): |
|
'''Add counts from two counters. |
|
|
|
>>> Counter('abbb') + Counter('bcc') |
|
Counter({'b': 4, 'c': 2, 'a': 1}) |
|
|
|
''' |
|
if not isinstance(other, Counter): |
|
return NotImplemented |
|
result = Counter() |
|
for elem, count in self.items(): |
|
newcount = count + other[elem] |
|
if newcount > 0: |
|
result[elem] = newcount |
|
for elem, count in other.items(): |
|
if elem not in self and count > 0: |
|
result[elem] = count |
|
return result |
|
|
|
def __sub__(self, other): |
|
''' Subtract count, but keep only results with positive counts. |
|
|
|
>>> Counter('abbbc') - Counter('bccd') |
|
Counter({'b': 2, 'a': 1}) |
|
|
|
''' |
|
if not isinstance(other, Counter): |
|
return NotImplemented |
|
result = Counter() |
|
for elem, count in self.items(): |
|
newcount = count - other[elem] |
|
if newcount > 0: |
|
result[elem] = newcount |
|
for elem, count in other.items(): |
|
if elem not in self and count < 0: |
|
result[elem] = 0 - count |
|
return result |
|
|
|
def __or__(self, other): |
|
'''Union is the maximum of value in either of the input counters. |
|
|
|
>>> Counter('abbb') | Counter('bcc') |
|
Counter({'b': 3, 'c': 2, 'a': 1}) |
|
|
|
''' |
|
if not isinstance(other, Counter): |
|
return NotImplemented |
|
result = Counter() |
|
for elem, count in self.items(): |
|
other_count = other[elem] |
|
newcount = other_count if count < other_count else count |
|
if newcount > 0: |
|
result[elem] = newcount |
|
for elem, count in other.items(): |
|
if elem not in self and count > 0: |
|
result[elem] = count |
|
return result |
|
|
|
def __and__(self, other): |
|
''' Intersection is the minimum of corresponding counts. |
|
|
|
>>> Counter('abbb') & Counter('bcc') |
|
Counter({'b': 1}) |
|
|
|
''' |
|
if not isinstance(other, Counter): |
|
return NotImplemented |
|
result = Counter() |
|
for elem, count in self.items(): |
|
other_count = other[elem] |
|
newcount = count if count < other_count else other_count |
|
if newcount > 0: |
|
result[elem] = newcount |
|
return result |
|
|
|
|
|
if __name__ == '__main__': |
|
# verify that instances can be pickled |
|
from cPickle import loads, dumps |
|
Point = namedtuple('Point', 'x, y', True) |
|
p = Point(x=10, y=20) |
|
assert p == loads(dumps(p)) |
|
|
|
# test and demonstrate ability to override methods |
|
class Point(namedtuple('Point', 'x y')): |
|
__slots__ = () |
|
@property |
|
def hypot(self): |
|
return (self.x ** 2 + self.y ** 2) ** 0.5 |
|
def __str__(self): |
|
return 'Point: x=%6.3f y=%6.3f hypot=%6.3f' % (self.x, self.y, self.hypot) |
|
|
|
for p in Point(3, 4), Point(14, 5/7.): |
|
print p |
|
|
|
class Point(namedtuple('Point', 'x y')): |
|
'Point class with optimized _make() and _replace() without error-checking' |
|
__slots__ = () |
|
_make = classmethod(tuple.__new__) |
|
def _replace(self, _map=map, **kwds): |
|
return self._make(_map(kwds.get, ('x', 'y'), self)) |
|
|
|
print Point(11, 22)._replace(x=100) |
|
|
|
Point3D = namedtuple('Point3D', Point._fields + ('z',)) |
|
print Point3D.__doc__ |
|
|
|
import doctest |
|
TestResults = namedtuple('TestResults', 'failed attempted') |
|
print TestResults(*doctest.testmod()) |
