1 class Counter(dict):
  2     '''Dict subclass for counting hashable items.  Sometimes called a bag
  3     or multiset.  Elements are stored as dictionary keys and their counts
  4     are stored as dictionary values.
  5
  6     >>> c = Counter('abcdeabcdabcaba')  # count elements from a string
  7
  8     >>> c.most_common(3)                # three most common elements
  9     [('a', 5), ('b', 4), ('c', 3)]
 10     >>> sorted(c)                       # list all unique elements
 11     ['a', 'b', 'c', 'd', 'e']
 12     >>> ''.join(sorted(c.elements()))   # list elements with repetitions
 13     'aaaaabbbbcccdde'
 14     >>> sum(c.values())                 # total of all counts
 15     15
 16
 17     >>> c['a']                          # count of letter 'a'
 18     5
 19     >>> for elem in 'shazam':           # update counts from an iterable
 20     ...     c[elem] += 1                # by adding 1 to each element's count
 21     >>> c['a']                          # now there are seven 'a'
 22     7
 23     >>> del c['b']                      # remove all 'b'
 24     >>> c['b']                          # now there are zero 'b'
 25     0
 26
 27     >>> d = Counter('simsalabim')       # make another counter
 28     >>> c.update(d)                     # add in the second counter
 29     >>> c['a']                          # now there are nine 'a'
 30     9
 31
 32     >>> c.clear()                       # empty the counter
 33     >>> c
 34     Counter()
 35
 36     Note:  If a count is set to zero or reduced to zero, it will remain
 37     in the counter until the entry is deleted or the counter is cleared:
 38
 39     >>> c = Counter('aaabbc')
 40     >>> c['b'] -= 2                     # reduce the count of 'b' by two
 41     >>> c.most_common()                 # 'b' is still in, but its count is zero
 42     [('a', 3), ('c', 1), ('b', 0)]
 43
 44     '''
 45     # References:
 46     #   http://en.wikipedia.org/wiki/Multiset
 47     #   http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html
 48     #   http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm
 49     #   http://code.activestate.com/recipes/259174/
 50     #   Knuth, TAOCP Vol. II section 4.6.3
 51
 52     def __init__(*args, **kwds):
 53         '''Create a new, empty Counter object.  And if given, count elements
 54         from an input iterable.  Or, initialize the count from another mapping
 55         of elements to their counts.
 56
 57         >>> c = Counter()                           # a new, empty counter
 58         >>> c = Counter('gallahad')                 # a new counter from an iterable
 59         >>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping
 60         >>> c = Counter(a=4, b=2)                   # a new counter from keyword args
 61
 62         '''
 63         if not args:
 64             raise TypeError("descriptor '__init__' of 'Counter' object "
 65                             "needs an argument")
 66         self, *args = args
 67         if len(args) > 1:
 68             raise TypeError('expected at most 1 arguments, got %d' % len(args))
 69         super(Counter, self).__init__()
 70         self.update(*args, **kwds)
 71
 72     def __missing__(self, key):
 73         'The count of elements not in the Counter is zero.'
 74         # Needed so that self[missing_item] does not raise KeyError
 75         return 0
 76
 77     def most_common(self, n=None):
 78         '''List the n most common elements and their counts from the most
 79         common to the least.  If n is None, then list all element counts.
 80
 81         >>> Counter('abcdeabcdabcaba').most_common(3)
 82         [('a', 5), ('b', 4), ('c', 3)]
 83
 84         '''
 85         # Emulate Bag.sortedByCount from Smalltalk
 86         if n is None:
 87             return sorted(self.items(), key=_itemgetter(1), reverse=True)
 88         return _heapq.nlargest(n, self.items(), key=_itemgetter(1))
 89
 90     def elements(self):
 91         '''Iterator over elements repeating each as many times as its count.
 92
 93         >>> c = Counter('ABCABC')
 94         >>> sorted(c.elements())
 95         ['A', 'A', 'B', 'B', 'C', 'C']
 96
 97         # Knuth's example for prime factors of 1836:  2**2 * 3**3 * 17**1
 98         >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
 99         >>> product = 1
100         >>> for factor in prime_factors.elements():     # loop over factors
101         ...     product *= factor                       # and multiply them
102         >>> product
103         1836
104
105         Note, if an element's count has been set to zero or is a negative
106         number, elements() will ignore it.
107
108         '''
109         # Emulate Bag.do from Smalltalk and Multiset.begin from C++.
110         return _chain.from_iterable(_starmap(_repeat, self.items()))
111
112     # Override dict methods where necessary
113
114     @classmethod
115     def fromkeys(cls, iterable, v=None):
116         # There is no equivalent method for counters because setting v=1
117         # means that no element can have a count greater than one.
118         raise NotImplementedError(
119             'Counter.fromkeys() is undefined.  Use Counter(iterable) instead.')
120
121     def update(*args, **kwds):
122         '''Like dict.update() but add counts instead of replacing them.
123
124         Source can be an iterable, a dictionary, or another Counter instance.
125
126         >>> c = Counter('which')
127         >>> c.update('witch')           # add elements from another iterable
128         >>> d = Counter('watch')
129         >>> c.update(d)                 # add elements from another counter
130         >>> c['h']                      # four 'h' in which, witch, and watch
131         4
132
133         '''
134         # The regular dict.update() operation makes no sense here because the
135         # replace behavior results in the some of original untouched counts
136         # being mixed-in with all of the other counts for a mismash that
137         # doesn't have a straight-forward interpretation in most counting
138         # contexts.  Instead, we implement straight-addition.  Both the inputs
139         # and outputs are allowed to contain zero and negative counts.
140
141         if not args:
142             raise TypeError("descriptor 'update' of 'Counter' object "
143                             "needs an argument")
144         self, *args = args
145         if len(args) > 1:
146             raise TypeError('expected at most 1 arguments, got %d' % len(args))
147         iterable = args[0] if args else None
148         if iterable is not None:
149             if isinstance(iterable, Mapping):
150                 if self:
151                     self_get = self.get
152                     for elem, count in iterable.items():
153                         self[elem] = count + self_get(elem, 0)
154                 else:
155                     super(Counter, self).update(iterable) # fast path when counter is empty
156             else:
157                 _count_elements(self, iterable)
158         if kwds:
159             self.update(kwds)
160
161     def subtract(*args, **kwds):
162         '''Like dict.update() but subtracts counts instead of replacing them.
163         Counts can be reduced below zero.  Both the inputs and outputs are
164         allowed to contain zero and negative counts.
165
166         Source can be an iterable, a dictionary, or another Counter instance.
167
168         >>> c = Counter('which')
169         >>> c.subtract('witch')             # subtract elements from another iterable
170         >>> c.subtract(Counter('watch'))    # subtract elements from another counter
171         >>> c['h']                          # 2 in which, minus 1 in witch, minus 1 in watch
172         0
173         >>> c['w']                          # 1 in which, minus 1 in witch, minus 1 in watch
174         -1
175
176         '''
177         if not args:
178             raise TypeError("descriptor 'subtract' of 'Counter' object "
179                             "needs an argument")
180         self, *args = args
181         if len(args) > 1:
182             raise TypeError('expected at most 1 arguments, got %d' % len(args))
183         iterable = args[0] if args else None
184         if iterable is not None:
185             self_get = self.get
186             if isinstance(iterable, Mapping):
187                 for elem, count in iterable.items():
188                     self[elem] = self_get(elem, 0) - count
189             else:
190                 for elem in iterable:
191                     self[elem] = self_get(elem, 0) - 1
192         if kwds:
193             self.subtract(kwds)
194
195     def copy(self):
196         'Return a shallow copy.'
197         return self.__class__(self)
198
199     def __reduce__(self):
200         return self.__class__, (dict(self),)
201
202     def __delitem__(self, elem):
203         'Like dict.__delitem__() but does not raise KeyError for missing values.'
204         if elem in self:
205             super().__delitem__(elem)
206
207     def __repr__(self):
208         if not self:
209             return '%s()' % self.__class__.__name__
210         try:
211             items = ', '.join(map('%r: %r'.__mod__, self.most_common()))
212             return '%s({%s})' % (self.__class__.__name__, items)
213         except TypeError:
214             # handle case where values are not orderable
215             return '{0}({1!r})'.format(self.__class__.__name__, dict(self))
216
217     # Multiset-style mathematical operations discussed in:
218     #       Knuth TAOCP Volume II section 4.6.3 exercise 19
219     #       and at http://en.wikipedia.org/wiki/Multiset
220     #
221     # Outputs guaranteed to only include positive counts.
222     #
223     # To strip negative and zero counts, add-in an empty counter:
224     #       c += Counter()
225
226     def __add__(self, other):
227         '''Add counts from two counters.
228
229         >>> Counter('abbb') + Counter('bcc')
230         Counter({'b': 4, 'c': 2, 'a': 1})
231
232         '''
233         if not isinstance(other, Counter):
234             return NotImplemented
235         result = Counter()
236         for elem, count in self.items():
237             newcount = count + other[elem]
238             if newcount > 0:
239                 result[elem] = newcount
240         for elem, count in other.items():
241             if elem not in self and count > 0:
242                 result[elem] = count
243         return result
244
245     def __sub__(self, other):
246         ''' Subtract count, but keep only results with positive counts.
247
248         >>> Counter('abbbc') - Counter('bccd')
249         Counter({'b': 2, 'a': 1})
250
251         '''
252         if not isinstance(other, Counter):
253             return NotImplemented
254         result = Counter()
255         for elem, count in self.items():
256             newcount = count - other[elem]
257             if newcount > 0:
258                 result[elem] = newcount
259         for elem, count in other.items():
260             if elem not in self and count < 0:
261                 result[elem] = 0 - count
262         return result
263
264     def __or__(self, other):
265         '''Union is the maximum of value in either of the input counters.
266
267         >>> Counter('abbb') | Counter('bcc')
268         Counter({'b': 3, 'c': 2, 'a': 1})
269
270         '''
271         if not isinstance(other, Counter):
272             return NotImplemented
273         result = Counter()
274         for elem, count in self.items():
275             other_count = other[elem]
276             newcount = other_count if count < other_count else count
277             if newcount > 0:
278                 result[elem] = newcount
279         for elem, count in other.items():
280             if elem not in self and count > 0:
281                 result[elem] = count
282         return result
283
284     def __and__(self, other):
285         ''' Intersection is the minimum of corresponding counts.
286
287         >>> Counter('abbb') & Counter('bcc')
288         Counter({'b': 1})
289
290         '''
291         if not isinstance(other, Counter):
292             return NotImplemented
293         result = Counter()
294         for elem, count in self.items():
295             other_count = other[elem]
296             newcount = count if count < other_count else other_count
297             if newcount > 0:
298                 result[elem] = newcount
299         return result
300
301     def __pos__(self):
302         'Adds an empty counter, effectively stripping negative and zero counts'
303         result = Counter()
304         for elem, count in self.items():
305             if count > 0:
306                 result[elem] = count
307         return result
308
309     def __neg__(self):
310         '''Subtracts from an empty counter.  Strips positive and zero counts,
311         and flips the sign on negative counts.
312
313         '''
314         result = Counter()
315         for elem, count in self.items():
316             if count < 0:
317                 result[elem] = 0 - count
318         return result
319
320     def _keep_positive(self):
321         '''Internal method to strip elements with a negative or zero count'''
322         nonpositive = [elem for elem, count in self.items() if not count > 0]
323         for elem in nonpositive:
324             del self[elem]
325         return self
326
327     def __iadd__(self, other):
328         '''Inplace add from another counter, keeping only positive counts.
329
330         >>> c = Counter('abbb')
331         >>> c += Counter('bcc')
332         >>> c
333         Counter({'b': 4, 'c': 2, 'a': 1})
334
335         '''
336         for elem, count in other.items():
337             self[elem] += count
338         return self._keep_positive()
339
340     def __isub__(self, other):
341         '''Inplace subtract counter, but keep only results with positive counts.
342
343         >>> c = Counter('abbbc')
344         >>> c -= Counter('bccd')
345         >>> c
346         Counter({'b': 2, 'a': 1})
347
348         '''
349         for elem, count in other.items():
350             self[elem] -= count
351         return self._keep_positive()
352
353     def __ior__(self, other):
354         '''Inplace union is the maximum of value from either counter.
355
356         >>> c = Counter('abbb')
357         >>> c |= Counter('bcc')
358         >>> c
359         Counter({'b': 3, 'c': 2, 'a': 1})
360
361         '''
362         for elem, other_count in other.items():
363             count = self[elem]
364             if other_count > count:
365                 self[elem] = other_count
366         return self._keep_positive()
367
368     def __iand__(self, other):
369         '''Inplace intersection is the minimum of corresponding counts.
370
371         >>> c = Counter('abbb')
372         >>> c &= Counter('bcc')
373         >>> c
374         Counter({'b': 1})
375
376         '''
377         for elem, count in self.items():
378             other_count = other[elem]
379             if other_count < count:
380                 self[elem] = other_count
381         return self._keep_positive()

 1 a=Counter({'a':2,'b':6,'c':4,'d':0,'e':-2})
 2 print(a)
 3 a['a']=0    #修改了计数器元素里的值
 4 print(a)
 5 del a['b']   #删除了元素
 6 print(a)
 7
 8 #运行结果
 9 Counter({'b': 6, 'c': 4, 'a': 2, 'd': 0, 'e': -2})
10 Counter({'b': 6, 'c': 4, 'a': 0, 'd': 0, 'e': -2})
11 Counter({'c': 4, 'a': 0, 'd': 0, 'e': -2})

 1 a=Counter({'a':2,'b':6,'c':4,'d':0,'e':-2})
 2 b=a.most_common()
 3 c=a.most_common(2)
 4 print(a)
 5 print(b,type(b))
 6 print(c,type(c))
 7
 8 #运行结果
 9 Counter({'b': 6, 'c': 4, 'a': 2, 'd': 0, 'e': -2})
10 [('b', 6), ('c', 4), ('a', 2), ('d', 0), ('e', -2)] <class 'list'>
11 [('b', 6), ('c', 4)] <class 'list'>

 1 a=Counter({'a':2,'b':6,'c':4,'d':0,'e':-2})
 2 b=a.elements()
 3 c=sorted(a.elements())
 4 print(a)
 5 print(b,type(b))
 6 print(c,type(c))
 7
 8 #运行结果
 9 Counter({'b': 6, 'c': 4, 'a': 2, 'd': 0, 'e': -2})
10 <itertools.chain object at 0x00225A50> <class 'itertools.chain'>
11 ['a', 'a', 'b', 'b', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'c'] <class 'list'>

1 a=Counter({'a':2,'b':6,'c':4,'d':0,'e':-2})
2 a.update('abe')
3 a.update({'g':1})
4 print(a)
5
6 #运行结果
7 Counter({'b': 7, 'c': 4, 'a': 3, 'g': 1, 'd': 0, 'e': -1})

1 a=Counter({'a':2,'b':6,'c':4,'d':0,'e':-2})
2 a.subtract('ade')
3 print(a)
4
5 #运行结果
6 Counter({'b': 6, 'c': 4, 'a': 1, 'd': -1, 'e': -3})

  1 class OrderedDict(dict):
  2     'Dictionary that remembers insertion order'
  3     # An inherited dict maps keys to values.
  4     # The inherited dict provides __getitem__, __len__, __contains__, and get.
  5     # The remaining methods are order-aware.
  6     # Big-O running times for all methods are the same as regular dictionaries.
  7
  8     # The internal self.__map dict maps keys to links in a doubly linked list.
  9     # The circular doubly linked list starts and ends with a sentinel element.
 10     # The sentinel element never gets deleted (this simplifies the algorithm).
 11     # The sentinel is in self.__hardroot with a weakref proxy in self.__root.
 12     # The prev links are weakref proxies (to prevent circular references).
 13     # Individual links are kept alive by the hard reference in self.__map.
 14     # Those hard references disappear when a key is deleted from an OrderedDict.
 15
 16     def __init__(*args, **kwds):
 17         '''Initialize an ordered dictionary.  The signature is the same as
 18         regular dictionaries, but keyword arguments are not recommended because
 19         their insertion order is arbitrary.
 20
 21         '''
 22         if not args:
 23             raise TypeError("descriptor '__init__' of 'OrderedDict' object "
 24                             "needs an argument")
 25         self, *args = args
 26         if len(args) > 1:
 27             raise TypeError('expected at most 1 arguments, got %d' % len(args))
 28         try:
 29             self.__root
 30         except AttributeError:
 31             self.__hardroot = _Link()
 32             self.__root = root = _proxy(self.__hardroot)
 33             root.prev = root.next = root
 34             self.__map = {}
 35         self.__update(*args, **kwds)
 36
 37     def __setitem__(self, key, value,
 38                     dict_setitem=dict.__setitem__, proxy=_proxy, Link=_Link):
 39         'od.__setitem__(i, y) <==> od[i]=y'
 40         # Setting a new item creates a new link at the end of the linked list,
 41         # and the inherited dictionary is updated with the new key/value pair.
 42         if key not in self:
 43             self.__map[key] = link = Link()
 44             root = self.__root
 45             last = root.prev
 46             link.prev, link.next, link.key = last, root, key
 47             last.next = link
 48             root.prev = proxy(link)
 49         dict_setitem(self, key, value)
 50
 51     def __delitem__(self, key, dict_delitem=dict.__delitem__):
 52         'od.__delitem__(y) <==> del od[y]'
 53         # Deleting an existing item uses self.__map to find the link which gets
 54         # removed by updating the links in the predecessor and successor nodes.
 55         dict_delitem(self, key)
 56         link = self.__map.pop(key)
 57         link_prev = link.prev
 58         link_next = link.next
 59         link_prev.next = link_next
 60         link_next.prev = link_prev
 61         link.prev = None
 62         link.next = None
 63
 64     def __iter__(self):
 65         'od.__iter__() <==> iter(od)'
 66         # Traverse the linked list in order.
 67         root = self.__root
 68         curr = root.next
 69         while curr is not root:
 70             yield curr.key
 71             curr = curr.next
 72
 73     def __reversed__(self):
 74         'od.__reversed__() <==> reversed(od)'
 75         # Traverse the linked list in reverse order.
 76         root = self.__root
 77         curr = root.prev
 78         while curr is not root:
 79             yield curr.key
 80             curr = curr.prev
 81
 82     def clear(self):
 83         'od.clear() -> None.  Remove all items from od.'
 84         root = self.__root
 85         root.prev = root.next = root
 86         self.__map.clear()
 87         dict.clear(self)
 88
 89     def popitem(self, last=True):
 90         '''od.popitem() -> (k, v), return and remove a (key, value) pair.
 91         Pairs are returned in LIFO order if last is true or FIFO order if false.
 92
 93         '''
 94         if not self:
 95             raise KeyError('dictionary is empty')
 96         root = self.__root
 97         if last:
 98             link = root.prev
 99             link_prev = link.prev
100             link_prev.next = root
101             root.prev = link_prev
102         else:
103             link = root.next
104             link_next = link.next
105             root.next = link_next
106             link_next.prev = root
107         key = link.key
108         del self.__map[key]
109         value = dict.pop(self, key)
110         return key, value
111
112     def move_to_end(self, key, last=True):
113         '''Move an existing element to the end (or beginning if last==False).
114
115         Raises KeyError if the element does not exist.
116         When last=True, acts like a fast version of self[key]=self.pop(key).
117
118         '''
119         link = self.__map[key]
120         link_prev = link.prev
121         link_next = link.next
122         link_prev.next = link_next
123         link_next.prev = link_prev
124         root = self.__root
125         if last:
126             last = root.prev
127             link.prev = last
128             link.next = root
129             last.next = root.prev = link
130         else:
131             first = root.next
132             link.prev = root
133             link.next = first
134             root.next = first.prev = link
135
136     def __sizeof__(self):
137         sizeof = _sys.getsizeof
138         n = len(self) + 1                       # number of links including root
139         size = sizeof(self.__dict__)            # instance dictionary
140         size += sizeof(self.__map) * 2          # internal dict and inherited dict
141         size += sizeof(self.__hardroot) * n     # link objects
142         size += sizeof(self.__root) * n         # proxy objects
143         return size
144
145     update = __update = MutableMapping.update
146
147     def keys(self):
148         "D.keys() -> a set-like object providing a view on D's keys"
149         return _OrderedDictKeysView(self)
150
151     def items(self):
152         "D.items() -> a set-like object providing a view on D's items"
153         return _OrderedDictItemsView(self)
154
155     def values(self):
156         "D.values() -> an object providing a view on D's values"
157         return _OrderedDictValuesView(self)
158
159     __ne__ = MutableMapping.__ne__
160
161     __marker = object()
162
163     def pop(self, key, default=__marker):
164         '''od.pop(k[,d]) -> v, remove specified key and return the corresponding
165         value.  If key is not found, d is returned if given, otherwise KeyError
166         is raised.
167
168         '''
169         if key in self:
170             result = self[key]
171             del self[key]
172             return result
173         if default is self.__marker:
174             raise KeyError(key)
175         return default
176
177     def setdefault(self, key, default=None):
178         'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
179         if key in self:
180             return self[key]
181         self[key] = default
182         return default
183
184     @_recursive_repr()
185     def __repr__(self):
186         'od.__repr__() <==> repr(od)'
187         if not self:
188             return '%s()' % (self.__class__.__name__,)
189         return '%s(%r)' % (self.__class__.__name__, list(self.items()))
190
191     def __reduce__(self):
192         'Return state information for pickling'
193         inst_dict = vars(self).copy()
194         for k in vars(OrderedDict()):
195             inst_dict.pop(k, None)
196         return self.__class__, (), inst_dict or None, None, iter(self.items())
197
198     def copy(self):
199         'od.copy() -> a shallow copy of od'
200         return self.__class__(self)
201
202     @classmethod
203     def fromkeys(cls, iterable, value=None):
204         '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
205         If not specified, the value defaults to None.
206
207         '''
208         self = cls()
209         for key in iterable:
210             self[key] = value
211         return self
212
213     def __eq__(self, other):
214         '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
215         while comparison to a regular mapping is order-insensitive.
216
217         '''
218         if isinstance(other, OrderedDict):
219             return dict.__eq__(self, other) and all(map(_eq, self, other))
220         return dict.__eq__(self, other)
221
222
223 try:
224     from _collections import OrderedDict
225 except ImportError:
226     # Leave the pure Python version in place.
227     pass

 1 from collections import OrderedDict
 2
 3 a=dict()                 #
 4 b=OrderedDict()
 5 a['a']=1
 6 a['b']=2
 7 a['c']=3
 8 a['d']=4
 9 b['a']=1
10 b['b']=2
11 b['c']=3
12 b['d']=4
13 print(a,type(a))
14 print(b,type(b))
15
16 #运行结果
17 {'a': 1, 'c': 3, 'd': 4, 'b': 2} <class 'dict'>
18 OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4)]) <class 'collections.OrderedDict'>

 1 a=OrderedDict()
 2 a['a']=1
 3 a['b']=2
 4 a['c']=3
 5 a['d']=4
 6 b=a.popitem()
 7 print(a)
 8 print(b)
 9
10 #运行结果
11 OrderedDict([('a', 1), ('b', 2), ('c', 3)])
12 ('d', 4)

 1 a=OrderedDict()
 2 a['a']=1
 3 a['b']=2
 4 a['c']=3
 5 a['d']=4
 6 print(a)
 7 b=a.move_to_end('b')
 8 print(a)
 9
10 #运行结果
11 OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
12 OrderedDict([('a', 1), ('c', 3), ('d', 4), ('b', 2)])

 1 from collections import defaultdict
 2
 3 a=defaultdict(list)              #默认value为list
 4 b=defaultdict(tuple)             #默认value为tuple
 5 c=defaultdict(dict)             #默认value为dict
 6 d=dict()
 7 print(a)
 8 print(b)
 9 print(c)
10 print(d)
11
12 #运行结果
13 defaultdict(<class 'list'>, {})
14 defaultdict(<class 'tuple'>, {})
15 defaultdict(<class 'dict'>, {})
16 {}

 1 s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
 2 d = defaultdict(list)
 3 for k, v in s:
 4      d[k].append(v)            #如果使用普通字典，需要先给字典初始化键值对
 5 c=sorted(d.items())
 6 print(type(s))
 7 print(d)
 8 print(c,type(c))
 9
10 #运行结果
11 <class 'list'>
12 defaultdict(<class 'list'>, {'red': [1], 'blue': [2, 4], 'yellow': [1, 3]})
13 [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])] <class 'list'>

 1 class defaultdict(dict):
 2     """
 3     defaultdict(default_factory[, ...]) --> dict with default factory
 4
 5     The default factory is called without arguments to produce
 6     a new value when a key is not present, in __getitem__ only.
 7     A defaultdict compares equal to a dict with the same items.
 8     All remaining arguments are treated the same as if they were
 9     passed to the dict constructor, including keyword arguments.
10     """
11     def copy(self): # real signature unknown; restored from __doc__
12         """ D.copy() -> a shallow copy of D. """
13         pass
14
15     def __copy__(self, *args, **kwargs): # real signature unknown
16         """ D.copy() -> a shallow copy of D. """
17         pass
18
19     def __getattribute__(self, *args, **kwargs): # real signature unknown
20         """ Return getattr(self, name). """
21         pass
22
23     def __init__(self, default_factory=None, **kwargs): # known case of _collections.defaultdict.__init__
24         """
25         defaultdict(default_factory[, ...]) --> dict with default factory
26
27         The default factory is called without arguments to produce
28         a new value when a key is not present, in __getitem__ only.
29         A defaultdict compares equal to a dict with the same items.
30         All remaining arguments are treated the same as if they were
31         passed to the dict constructor, including keyword arguments.
32
33         # (copied from class doc)
34         """
35         pass
36
37     def __missing__(self, key): # real signature unknown; restored from __doc__
38         """
39         __missing__(key) # Called by __getitem__ for missing key; pseudo-code:
40           if self.default_factory is None: raise KeyError((key,))
41           self[key] = value = self.default_factory()
42           return value
43         """
44         pass
45
46     def __reduce__(self, *args, **kwargs): # real signature unknown
47         """ Return state information for pickling. """
48         pass
49
50     def __repr__(self, *args, **kwargs): # real signature unknown
51         """ Return repr(self). """
52         pass
53
54     default_factory = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
55     """Factory for default value called by __missing__()."""

  1 print(help(myTupleClass))    #运行help打印获取
  2
  3 class myTupleClass(builtins.tuple)
  4  |  myTupleClass(x, y)
  5  |
  6  |  Method resolution order:
  7  |      myTupleClass
  8  |      builtins.tuple
  9  |      builtins.object
 10  |
 11  |  Methods defined here:
 12  |
 13  |  __getnewargs__(self)
 14  |      Return self as a plain tuple.  Used by copy and pickle.
 15  |
 16  |  __repr__(self)
 17  |      Return a nicely formatted representation string
 18  |
 19  |  _asdict(self)
 20  |      Return a new OrderedDict which maps field names to their values.
 21  |
 22  |  _replace(_self, **kwds)
 23  |      Return a new myTupleClass object replacing specified fields with new values
 24  |
 25  |  ----------------------------------------------------------------------
 26  |  Class methods defined here:
 27  |
 28  |  _make(iterable, new=<built-in method __new__ of type object at 0x6143B5C8>, len=<built-in function len>) from builtins.type
 29  |      Make a new myTupleClass object from a sequence or iterable
 30  |
 31  |  ----------------------------------------------------------------------
 32  |  Static methods defined here:
 33  |
 34  |  __new__(_cls, x, y)
 35  |      Create new instance of myTupleClass(x, y)
 36  |
 37  |  ----------------------------------------------------------------------
 38  |  Data descriptors defined here:
 39  |
 40  |  x
 41  |      Alias for field number 0
 42  |
 43  |  y
 44  |      Alias for field number 1
 45  |
 46  |  ----------------------------------------------------------------------
 47  |  Data and other attributes defined here:
 48  |
 49  |  _fields = ('x', 'y')
 50  |
 51  |  _source = "from builtins import property as _property, tupl..._itemget...
 52  |
 53  |  ----------------------------------------------------------------------
 54  |  Methods inherited from builtins.tuple:
 55  |
 56  |  __add__(self, value, /)
 57  |      Return self+value.
 58  |
 59  |  __contains__(self, key, /)
 60  |      Return key in self.
 61  |
 62  |  __eq__(self, value, /)
 63  |      Return self==value.
 64  |
 65  |  __ge__(self, value, /)
 66  |      Return self>=value.
 67  |
 68  |  __getattribute__(self, name, /)
 69  |      Return getattr(self, name).
 70  |
 71  |  __getitem__(self, key, /)
 72  |      Return self[key].
 73  |
 74  |  __gt__(self, value, /)
 75  |      Return self>value.
 76  |
 77  |  __hash__(self, /)
 78  |      Return hash(self).
 79  |
 80  |  __iter__(self, /)
 81  |      Implement iter(self).
 82  |
 83  |  __le__(self, value, /)
 84  |      Return self<=value.
 85  |
 86  |  __len__(self, /)
 87  |      Return len(self).
 88  |
 89  |  __lt__(self, value, /)
 90  |      Return self<value.
 91  |
 92  |  __mul__(self, value, /)
 93  |      Return self*value.n
 94  |
 95  |  __ne__(self, value, /)
 96  |      Return self!=value.
 97  |
 98  |  __rmul__(self, value, /)
 99  |      Return self*value.
100  |
101  |  count(...)
102  |      T.count(value) -> integer -- return number of occurrences of value
103  |
104  |  index(...)
105  |      T.index(value, [start, [stop]]) -> integer -- return first index of value.
106  |      Raises ValueError if the value is not present.
107
108 None

  1 class deque(object):
  2     """
  3     deque([iterable[, maxlen]]) --> deque object
  4
  5     A list-like sequence optimized for data accesses near its endpoints.
  6     """
  7     def append(self, *args, **kwargs): # real signature unknown
  8         """ Add an element to the right side of the deque. """
  9         pass
 10
 11     def appendleft(self, *args, **kwargs): # real signature unknown
 12         """ Add an element to the left side of the deque. """
 13         pass
 14
 15     def clear(self, *args, **kwargs): # real signature unknown
 16         """ Remove all elements from the deque. """
 17         pass
 18
 19     def copy(self, *args, **kwargs): # real signature unknown
 20         """ Return a shallow copy of a deque. """
 21         pass
 22
 23     def count(self, value): # real signature unknown; restored from __doc__
 24         """ D.count(value) -> integer -- return number of occurrences of value """
 25         return 0
 26
 27     def extend(self, *args, **kwargs): # real signature unknown
 28         """ Extend the right side of the deque with elements from the iterable """
 29         pass
 30
 31     def extendleft(self, *args, **kwargs): # real signature unknown
 32         """ Extend the left side of the deque with elements from the iterable """
 33         pass
 34
 35     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
 36         """
 37         D.index(value, [start, [stop]]) -> integer -- return first index of value.
 38         Raises ValueError if the value is not present.
 39         """
 40         return 0
 41
 42     def insert(self, index, p_object): # real signature unknown; restored from __doc__
 43         """ D.insert(index, object) -- insert object before index """
 44         pass
 45
 46     def pop(self, *args, **kwargs): # real signature unknown
 47         """ Remove and return the rightmost element. """
 48         pass
 49
 50     def popleft(self, *args, **kwargs): # real signature unknown
 51         """ Remove and return the leftmost element. """
 52         pass
 53
 54     def remove(self, value): # real signature unknown; restored from __doc__
 55         """ D.remove(value) -- remove first occurrence of value. """
 56         pass
 57
 58     def reverse(self): # real signature unknown; restored from __doc__
 59         """ D.reverse() -- reverse *IN PLACE* """
 60         pass
 61
 62     def rotate(self, *args, **kwargs): # real signature unknown
 63         """ Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """
 64         pass
 65
 66     def __add__(self, *args, **kwargs): # real signature unknown
 67         """ Return self+value. """
 68         pass
 69
 70     def __bool__(self, *args, **kwargs): # real signature unknown
 71         """ self != 0 """
 72         pass
 73
 74     def __contains__(self, *args, **kwargs): # real signature unknown
 75         """ Return key in self. """
 76         pass
 77
 78     def __copy__(self, *args, **kwargs): # real signature unknown
 79         """ Return a shallow copy of a deque. """
 80         pass
 81
 82     def __delitem__(self, *args, **kwargs): # real signature unknown
 83         """ Delete self[key]. """
 84         pass
 85
 86     def __eq__(self, *args, **kwargs): # real signature unknown
 87         """ Return self==value. """
 88         pass
 89
 90     def __getattribute__(self, *args, **kwargs): # real signature unknown
 91         """ Return getattr(self, name). """
 92         pass
 93
 94     def __getitem__(self, *args, **kwargs): # real signature unknown
 95         """ Return self[key]. """
 96         pass
 97
 98     def __ge__(self, *args, **kwargs): # real signature unknown
 99         """ Return self>=value. """
100         pass
101
102     def __gt__(self, *args, **kwargs): # real signature unknown
103         """ Return self>value. """
104         pass
105
106     def __iadd__(self, *args, **kwargs): # real signature unknown
107         """ Implement self+=value. """
108         pass
109
110     def __imul__(self, *args, **kwargs): # real signature unknown
111         """ Implement self*=value. """
112         pass
113
114     def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__
115         """
116         deque([iterable[, maxlen]]) --> deque object
117
118         A list-like sequence optimized for data accesses near its endpoints.
119         # (copied from class doc)
120         """
121         pass
122
123     def __iter__(self, *args, **kwargs): # real signature unknown
124         """ Implement iter(self). """
125         pass
126
127     def __len__(self, *args, **kwargs): # real signature unknown
128         """ Return len(self). """
129         pass
130
131     def __le__(self, *args, **kwargs): # real signature unknown
132         """ Return self<=value. """
133         pass
134
135     def __lt__(self, *args, **kwargs): # real signature unknown
136         """ Return self<value. """
137         pass
138
139     def __mul__(self, *args, **kwargs): # real signature unknown
140         """ Return self*value.n """
141         pass
142
143     @staticmethod # known case of __new__
144     def __new__(*args, **kwargs): # real signature unknown
145         """ Create and return a new object.  See help(type) for accurate signature. """
146         pass
147
148     def __ne__(self, *args, **kwargs): # real signature unknown
149         """ Return self!=value. """
150         pass
151
152     def __reduce__(self, *args, **kwargs): # real signature unknown
153         """ Return state information for pickling. """
154         pass
155
156     def __repr__(self, *args, **kwargs): # real signature unknown
157         """ Return repr(self). """
158         pass
159
160     def __reversed__(self): # real signature unknown; restored from __doc__
161         """ D.__reversed__() -- return a reverse iterator over the deque """
162         pass
163
164     def __rmul__(self, *args, **kwargs): # real signature unknown
165         """ Return self*value. """
166         pass
167
168     def __setitem__(self, *args, **kwargs): # real signature unknown
169         """ Set self[key] to value. """
170         pass
171
172     def __sizeof__(self): # real signature unknown; restored from __doc__
173         """ D.__sizeof__() -- size of D in memory, in bytes """
174         pass
175
176     maxlen = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
177     """maximum size of a deque or None if unbounded"""
178
179
180     __hash__ = None

  1 class Queue:
  2     '''Create a queue object with a given maximum size.
  3
  4     If maxsize is <= 0, the queue size is infinite.
  5     '''
  6
  7     def __init__(self, maxsize=0):
  8         self.maxsize = maxsize
  9         self._init(maxsize)
 10
 11         # mutex must be held whenever the queue is mutating.  All methods
 12         # that acquire mutex must release it before returning.  mutex
 13         # is shared between the three conditions, so acquiring and
 14         # releasing the conditions also acquires and releases mutex.
 15         self.mutex = threading.Lock()
 16
 17         # Notify not_empty whenever an item is added to the queue; a
 18         # thread waiting to get is notified then.
 19         self.not_empty = threading.Condition(self.mutex)
 20
 21         # Notify not_full whenever an item is removed from the queue;
 22         # a thread waiting to put is notified then.
 23         self.not_full = threading.Condition(self.mutex)
 24
 25         # Notify all_tasks_done whenever the number of unfinished tasks
 26         # drops to zero; thread waiting to join() is notified to resume
 27         self.all_tasks_done = threading.Condition(self.mutex)
 28         self.unfinished_tasks = 0
 29
 30     def task_done(self):
 31         '''Indicate that a formerly enqueued task is complete.
 32
 33         Used by Queue consumer threads.  For each get() used to fetch a task,
 34         a subsequent call to task_done() tells the queue that the processing
 35         on the task is complete.
 36
 37         If a join() is currently blocking, it will resume when all items
 38         have been processed (meaning that a task_done() call was received
 39         for every item that had been put() into the queue).
 40
 41         Raises a ValueError if called more times than there were items
 42         placed in the queue.
 43         '''
 44         with self.all_tasks_done:
 45             unfinished = self.unfinished_tasks - 1
 46             if unfinished <= 0:
 47                 if unfinished < 0:
 48                     raise ValueError('task_done() called too many times')
 49                 self.all_tasks_done.notify_all()
 50             self.unfinished_tasks = unfinished
 51
 52     def join(self):
 53         '''Blocks until all items in the Queue have been gotten and processed.
 54
 55         The count of unfinished tasks goes up whenever an item is added to the
 56         queue. The count goes down whenever a consumer thread calls task_done()
 57         to indicate the item was retrieved and all work on it is complete.
 58
 59         When the count of unfinished tasks drops to zero, join() unblocks.
 60         '''
 61         with self.all_tasks_done:
 62             while self.unfinished_tasks:
 63                 self.all_tasks_done.wait()
 64
 65     def qsize(self):
 66         '''Return the approximate size of the queue (not reliable!).'''
 67         with self.mutex:
 68             return self._qsize()
 69
 70     def empty(self):
 71         '''Return True if the queue is empty, False otherwise (not reliable!).
 72
 73         This method is likely to be removed at some point.  Use qsize() == 0
 74         as a direct substitute, but be aware that either approach risks a race
 75         condition where a queue can grow before the result of empty() or
 76         qsize() can be used.
 77
 78         To create code that needs to wait for all queued tasks to be
 79         completed, the preferred technique is to use the join() method.
 80         '''
 81         with self.mutex:
 82             return not self._qsize()
 83
 84     def full(self):
 85         '''Return True if the queue is full, False otherwise (not reliable!).
 86
 87         This method is likely to be removed at some point.  Use qsize() >= n
 88         as a direct substitute, but be aware that either approach risks a race
 89         condition where a queue can shrink before the result of full() or
 90         qsize() can be used.
 91         '''
 92         with self.mutex:
 93             return 0 < self.maxsize <= self._qsize()
 94
 95     def put(self, item, block=True, timeout=None):
 96         '''Put an item into the queue.
 97
 98         If optional args 'block' is true and 'timeout' is None (the default),
 99         block if necessary until a free slot is available. If 'timeout' is
100         a non-negative number, it blocks at most 'timeout' seconds and raises
101         the Full exception if no free slot was available within that time.
102         Otherwise ('block' is false), put an item on the queue if a free slot
103         is immediately available, else raise the Full exception ('timeout'
104         is ignored in that case).
105         '''
106         with self.not_full:
107             if self.maxsize > 0:
108                 if not block:
109                     if self._qsize() >= self.maxsize:
110                         raise Full
111                 elif timeout is None:
112                     while self._qsize() >= self.maxsize:
113                         self.not_full.wait()
114                 elif timeout < 0:
115                     raise ValueError("'timeout' must be a non-negative number")
116                 else:
117                     endtime = time() + timeout
118                     while self._qsize() >= self.maxsize:
119                         remaining = endtime - time()
120                         if remaining <= 0.0:
121                             raise Full
122                         self.not_full.wait(remaining)
123             self._put(item)
124             self.unfinished_tasks += 1
125             self.not_empty.notify()
126
127     def get(self, block=True, timeout=None):
128         '''Remove and return an item from the queue.
129
130         If optional args 'block' is true and 'timeout' is None (the default),
131         block if necessary until an item is available. If 'timeout' is
132         a non-negative number, it blocks at most 'timeout' seconds and raises
133         the Empty exception if no item was available within that time.
134         Otherwise ('block' is false), return an item if one is immediately
135         available, else raise the Empty exception ('timeout' is ignored
136         in that case).
137         '''
138         with self.not_empty:
139             if not block:
140                 if not self._qsize():
141                     raise Empty
142             elif timeout is None:
143                 while not self._qsize():
144                     self.not_empty.wait()
145             elif timeout < 0:
146                 raise ValueError("'timeout' must be a non-negative number")
147             else:
148                 endtime = time() + timeout
149                 while not self._qsize():
150                     remaining = endtime - time()
151                     if remaining <= 0.0:
152                         raise Empty
153                     self.not_empty.wait(remaining)
154             item = self._get()
155             self.not_full.notify()
156             return item
157
158     def put_nowait(self, item):
159         '''Put an item into the queue without blocking.
160
161         Only enqueue the item if a free slot is immediately available.
162         Otherwise raise the Full exception.
163         '''
164         return self.put(item, block=False)
165
166     def get_nowait(self):
167         '''Remove and return an item from the queue without blocking.
168
169         Only get an item if one is immediately available. Otherwise
170         raise the Empty exception.
171         '''
172         return self.get(block=False)
173
174     # Override these methods to implement other queue organizations
175     # (e.g. stack or priority queue).
176     # These will only be called with appropriate locks held
177
178     # Initialize the queue representation
179     def _init(self, maxsize):
180         self.queue = deque()
181
182     def _qsize(self):
183         return len(self.queue)
184
185     # Put a new item in the queue
186     def _put(self, item):
187         self.queue.append(item)
188
189     # Get an item from the queue
190     def _get(self):
191         return self.queue.popleft()