Python collection模块与深浅拷贝
collection模块是对专业的容器数据类型：
- Counter（计数器）：dict子类，用于计算可哈希性对象的个数。
- OrderedDict（有序字典）：dict 子类，记录着数据成员添加的顺序。
- defaultdict(默认字典）：调用一个工厂函数来为dict的values值缺失提供一个默认值。
- namedtuple(可命名元组）：工厂函数生成有命名字段的tuple子类。
- deque(双向队列）：能在“队列”两端快速出队、入队的函数，类似于队列的（list-like）的容器。
- ChainMap:为多个映射创建单一视图的类字典类型。
- 将字典包裹起来使得创建字典的子类更容易。
- 将列表对象包裹起来使得创建列表的子类更容易。
- 将字符串对象包裹起来使得创建字符串的子类更容易。
参考网页：https://docs.python.org/3.5/library/collections.html
1.计数器（counter）
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):
把计数器转化成列表，元素转化成元组，具有相等计数的元素是任意排序的。
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):
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):
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 OrderedDict2
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):
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 defaultdict2
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'.'y']。
如果verbose 为 True, 在类被建立后将打印类的定义。_source 属性，也就是打印源代码。
如果 rename参数 为 True, 无效的field_names会被自动转换成位置的名称.abc。
2）可命名元组的创建
需要先创建一个类。
from collections import namedtuplemyTupleClass=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 dequea=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 queuea=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
以上是 Python collection模块与深浅拷贝 的全部内容， 来源链接： utcz.com/z/388720.html
