collection模块是对Python的通用内置容器：字典、列表、元组和集合的扩展，它包含一些专业的容器数据类型：

  • Counter（计数器）：dict子类，用于计算可哈希性对象的个数。
  • OrderedDict（有序字典）：dict 子类，记录着数据成员添加的顺序。
  • defaultdict(默认字典）：dict 子类，调用一个工厂函数来为dict的values值缺失提供一个默认值。
  • namedtuple(可命名元组）：工厂函数生成有命名字段的tuple子类。
  • deque(双向队列）：能在“队列”两端快速出队、入队的函数，类似于队列的（list-like）的容器。
  • ChainMap:为多个映射创建单一视图的类字典类型。
  • UserDict：将字典包裹起来使得创建字典的子类更容易。
  • UserList：将列表对象包裹起来使得创建列表的子类更容易。
  • UserString：将字符串对象包裹起来使得创建字符串的子类更容易。

参考网页：https://docs.python.org/3.5/library/collections.html

 

1.计数器（counter）

Counter是dict的子类，用于计数可哈希性对象。它是一个无序的容器，元素存储为字典键，计数值存储为字典值。计数允许任何整数值，包括零或负计数。Counter类相似于bags或multisets等语言类。

它的元素从一个可迭代对象计数，或从另一个映射（或计数器）初始化。

  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()
Counter

1）计数器的创建

from collections import Counter    #Counter 需要申明

a=Counter()                            # 创建空计数器
b=Counter('aabbbcccc')                 # 可迭代对象计数的方式创建对象
c = Counter({'red': 4, 'blue': 2})     # 映射方法创建计数器
d = Counter(cats=4, dogs=8)            # 键值的方法创建计数器

2)计数器元素的删除

 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})
del

3)计数器的部分功能属性

most_common(self, n=None):

把计数器转化成列表，元素转化成元组，返回n个最常见的元素及其计数的列表，从最常见到最少见。如果省略n或为None，most_common()返回计数器中所有元素。具有相等计数的元素是任意排序的。

 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'>
demo

elements(self):

返回一个迭代器，对元素重复迭代其计数次。元素以随机顺序返回。如果元素的计数小于1，elements()将忽略它。

 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'>
demo

update(*args, **kwds):

元素从一个可迭代对象计数或从另一个映射（或计数器）增加。类似dict.update()，但增加计数，而不是替换它们。此外，可迭代对象应为一系列元素，而不是(key, value)对。

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})
demo
subtract(*args, **kwds):
从一个可迭代对象或另一个映射（或计数器）中减去元素。类似dict.update()，但减去计数，而不是替换它们。输入和输出都可以为零或负。
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})
demo

2.有序字典(OrderedDict )
有序字典与常规字典类似，但它们记住键值对插入的顺序。当对有序字典进行迭代时，项目按它们的键首次添加的顺序返回。
  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
OrderedDict
1）有序字典的创建：
 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'>
demo
2）有序字典的功能：
有序字典继承了字典的功能，下面只介绍与字典不同功能。
popitem(self, last=True):
返回并删除字典中的键值对。如果last为True（默认值），则以LIFO顺序返回这些键值对，如果为False，则以FIFO顺序返回。
 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)
demo
move_to_end(self, key, last=True):
将一个已存在key移动到有序字典的另一端。如果last为True（默认值），则项目移动到末尾，如果last为False，则移动到开始。如果key不存在，引发KeyError。
 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)])
demo

3.默认字典(defaultdict) 
defaultdict可以把字典指定一个默认value，可以是字典/列表等。返回一个新的类似字典的对象，功能与dict类相同。
如：
 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 {}
demo
应用：
 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'>
demo

默认字典的功能：

 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__()."""
defaultdict


4.可命名元组(namedtuple) 

1）可命名元组的说明

给元组中每个位置上的元素命名，它们可以使用常规的元组方法，可以让访问元素可以按名称而不是按位置索引。

collections.namedtuple(typename, field_names, verbose=False, rename=False)：

返回一个叫做 typename 的tuple子类，这个新的子类用来创建类tuple(tuple-like)的对象，这个对象拥有可以通过属性访问的字段，并且可以通过下标索引和迭代。

field_names 是一个单独的字符串，这个字符串中包含的所有字段用空格或逗号隔开，例如 'xy' 或 'x,y'.另外, field_names 也可以是字符串的列表，例如 ['x', 'y']。

如果verbose 为 True, 在类被建立后将打印类的定义。相反，它打印的是类的 _source 属性，也就是打印源代码。

如果 rename参数 为 True, 无效的field_names会被自动转换成位置的名称.例如, ['abc', 'def', 'ghi', 'abc'] 将被转换为 ['abc', '_1', 'ghi', '_3'], 来消除关键字 def 和重复的字段名 abc。

2）可命名元组的创建

需要先创建一个类。

from collections import namedtuple

myTupleClass=namedtuple('myTupleClass',['x','y'])
a=point(1,2)
b=point(2,0)
print(a,a.x,a.y,type(a))
print(b,b.x,b.y,type(b))

#运行结果
myTupleClass(x=1, y=2) 1 2 <class '__main__.myTupleClass'>
myTupleClass(x=2, y=0) 2 0 <class '__main__.myTupleClass'>

3）可命名元组新创建类的功能属性

如上面创建的myTupleCalss类： 

  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
myTupleCalss

 

5.队列(deque)

1）双向队列（deque)

双向队列（Deque）是栈和队列的一般化。可以在两端添加和删除元素。

双向队列的创建：

from collections import deque

a=deque()
b=deque('abcd')
print(a,type(a))
print(b,type(b))

#运行结果
deque([]) <class 'collections.deque'>
deque(['a', 'b', 'c', 'd']) <class 'collections.deque'>

双向队列的功能属性：

  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
deque

2)单向队列（queue.Queue)

class queue.Queue(maxsize=0)

单向队列与双向队列的区别是FIFO（先进先出），maxsize是个整数，指明了队列中能存放的数据个数的上限。一旦达到上限，插入会导致阻塞，直到队列中的数据被取出。如果maxsize小于或者等于0，则队列大小没有限制。

单向队列的创建：

import queue

a=queue.Queue()
b=queue.Queue('abcd')
print(a,type(a))
print(b,type(b))

#运行结果
<queue.Queue object at 0x00FBB310> <class 'queue.Queue'>
<queue.Queue object at 0x01522DF0> <class 'queue.Queue'>

单向队列的功能属性：

  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()
queue.Queue

 

6.深浅拷贝

官方文档网址：https://docs.python.org/3/library/copy.html

浅拷贝和深拷贝的主要区别在与操作后内存地址的变化是不同的。

具体区别参见博文：http://www.cnblogs.com/wupeiqi/articles/5453708.html