1、计数器（counter）
Counter是对字典类型的补充，用于追踪值的出现次数。
ps：具备字典的所有功能 + 自己的功能
1 ########################################################################
2 ### Counter
3 ########################################################################
4
5 class Counter(dict):
6 ‘‘‘Dict subclass for counting hashable items. Sometimes called a bag
7 or multiset. Elements are stored as dictionary keys and their counts
8 are stored as dictionary values.
9
10 >>> c = Counter(‘abcdeabcdabcaba‘) # count elements from a string
11
12 >>> c.most_common(3) # three most common elements
13 [(‘a‘, 5), (‘b‘, 4), (‘c‘, 3)]
14 >>> sorted(c) # list all unique elements
15 [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]
16 >>> ‘‘.join(sorted(c.elements())) # list elements with repetitions
17 ‘aaaaabbbbcccdde‘
18 >>> sum(c.values()) # total of all counts
19
20 >>> c[‘a‘] # count of letter ‘a‘
21 >>> for elem in ‘shazam‘: # update counts from an iterable
22 ... c[elem] += 1 # by adding 1 to each element‘s count
23 >>> c[‘a‘] # now there are seven ‘a‘
24 >>> del c[‘b‘] # remove all ‘b‘
25 >>> c[‘b‘] # now there are zero ‘b‘
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
31 >>> c.clear() # empty the counter
32 >>> c
33 Counter()
34
35 Note: If a count is set to zero or reduced to zero, it will remain
36 in the counter until the entry is deleted or the counter is cleared:
37
38 >>> c = Counter(‘aaabbc‘)
39 >>> c[‘b‘] -= 2 # reduce the count of ‘b‘ by two
40 >>> c.most_common() # ‘b‘ is still in, but its count is zero
41 [(‘a‘, 3), (‘c‘, 1), (‘b‘, 0)]
42
43 ‘‘‘
44 # References:
45 # http://en.wikipedia.org/wiki/Multiset
46 # http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html
47 # http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm
48 # http://code.activestate.com/recipes/259174/
49 # Knuth, TAOCP Vol. II section 4.6.3
50
51 def __init__(self, iterable=None, **kwds):
52 ‘‘‘Create a new, empty Counter object. And if given, count elements
53 from an input iterable. Or, initialize the count from another mapping
54 of elements to their counts.
55
56 >>> c = Counter() # a new, empty counter
57 >>> c = Counter(‘gallahad‘) # a new counter from an iterable
58 >>> c = Counter({‘a‘: 4, ‘b‘: 2}) # a new counter from a mapping
59 >>> c = Counter(a=4, b=2) # a new counter from keyword args
60
61 ‘‘‘
62 super(Counter, self).__init__()
63 self.update(iterable, **kwds)
64
65 def __missing__(self, key):
66 """ 对于不存在的元素，返回计数器为0 """
67 ‘The count of elements not in the Counter is zero.‘
68 # Needed so that self[missing_item] does not raise KeyError
69 return 0
70
71 def most_common(self, n=None):
72 """ 数量大于等n的所有元素和计数器 """
73 ‘‘‘List the n most common elements and their counts from the most
74 common to the least. If n is None, then list all element counts.
75
76 >>> Counter(‘abcdeabcdabcaba‘).most_common(3)
77 [(‘a‘, 5), (‘b‘, 4), (‘c‘, 3)]
78
79 ‘‘‘
80 # Emulate Bag.sortedByCount from Smalltalk
81 if n is None:
82 return sorted(self.iteritems(), key=_itemgetter(1), reverse=True)
83 return _heapq.nlargest(n, self.iteritems(), key=_itemgetter(1))
84
85 def elements(self):
86 """ 计数器中的所有元素，注：此处非所有元素集合，而是包含所有元素集合的迭代器 """
87 ‘‘‘Iterator over elements repeating each as many times as its count.
88
89 >>> c = Counter(‘ABCABC‘)
90 >>> sorted(c.elements())
91 [‘A‘, ‘A‘, ‘B‘, ‘B‘, ‘C‘, ‘C‘]
92
93 # Knuth‘s example for prime factors of 1836: 2**2 * 3**3 * 17**1
94 >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
95 >>> product = 1
96 >>> for factor in prime_factors.elements(): # loop over factors
97 ... product *= factor # and multiply them
98 >>> product
99
100 Note, if an element‘s count has been set to zero or is a negative
101 number, elements() will ignore it.
102
103 ‘‘‘
104 # Emulate Bag.do from Smalltalk and Multiset.begin from C++.
105 return _chain.from_iterable(_starmap(_repeat, self.iteritems()))
106
107 # Override dict methods where necessary
108
109 @classmethod
110 def fromkeys(cls, iterable, v=None):
111 # There is no equivalent method for counters because setting v=1
112 # means that no element can have a count greater than one.
113 raise NotImplementedError(
114 ‘Counter.fromkeys() is undefined. Use Counter(iterable) instead.‘)
115
116 def update(self, iterable=None, **kwds):
117 """ 更新计数器，其实就是增加；如果原来没有，则新建，如果有则加一 """
118 ‘‘‘Like dict.update() but add counts instead of replacing them.
119
120 Source can be an iterable, a dictionary, or another Counter instance.
121
122 >>> c = Counter(‘which‘)
123 >>> c.update(‘witch‘) # add elements from another iterable
124 >>> d = Counter(‘watch‘)
125 >>> c.update(d) # add elements from another counter
126 >>> c[‘h‘] # four ‘h‘ in which, witch, and watch
127
128 ‘‘‘
129 # The regular dict.update() operation makes no sense here because the
130 # replace behavior results in the some of original untouched counts
131 # being mixed-in with all of the other counts for a mismash that
132 # doesn‘t have a straight-forward interpretation in most counting
133 # contexts. Instead, we implement straight-addition. Both the inputs
134 # and outputs are allowed to contain zero and negative counts.
135
136 if iterable is not None:
137 if isinstance(iterable, Mapping):
138 if self:
139 self_get = self.get
140 for elem, count in iterable.iteritems():
141 self[elem] = self_get(elem, 0) + count
142 else:
143 super(Counter, self).update(iterable) # fast path when counter is empty
144 else:
145 self_get = self.get
146 for elem in iterable:
147 self[elem] = self_get(elem, 0) + 1
148 if kwds:
149 self.update(kwds)
150
151 def subtract(self, iterable=None, **kwds):
152 """ 相减，原来的计数器中的每一个元素的数量减去后添加的元素的数量 """
153 ‘‘‘Like dict.update() but subtracts counts instead of replacing them.
154 Counts can be reduced below zero. Both the inputs and outputs are
155 allowed to contain zero and negative counts.
156
157 Source can be an iterable, a dictionary, or another Counter instance.
158
159 >>> c = Counter(‘which‘)
160 >>> c.subtract(‘witch‘) # subtract elements from another iterable
161 >>> c.subtract(Counter(‘watch‘)) # subtract elements from another counter
162 >>> c[‘h‘] # 2 in which, minus 1 in witch, minus 1 in watch
163 >>> c[‘w‘] # 1 in which, minus 1 in witch, minus 1 in watch
164 -1
165
166 ‘‘‘
167 if iterable is not None:
168 self_get = self.get
169 if isinstance(iterable, Mapping):
170 for elem, count in iterable.items():
171 self[elem] = self_get(elem, 0) - count
172 else:
173 for elem in iterable:
174 self[elem] = self_get(elem, 0) - 1
175 if kwds:
176 self.subtract(kwds)
177
178 def copy(self):
179 """ 拷贝 """
180 ‘Return a shallow copy.‘
181 return self.__class__(self)
182
183 def __reduce__(self):
184 """ 返回一个元组（类型，元组） """
185 return self.__class__, (dict(self),)
186
187 def __delitem__(self, elem):
188 """ 删除元素 """
189 ‘Like dict.__delitem__() but does not raise KeyError for missing values.‘
190 if elem in self:
191 super(Counter, self).__delitem__(elem)
192
193 def __repr__(self):
194 if not self:
195 return ‘%s()‘ % self.__class__.__name__
196 items = ‘, ‘.join(map(‘%r: %r‘.__mod__, self.most_common()))
197 return ‘%s({%s})‘ % (self.__class__.__name__, items)
198
199 # Multiset-style mathematical operations discussed in:
200 # Knuth TAOCP Volume II section 4.6.3 exercise 19
201 # and at http://en.wikipedia.org/wiki/Multiset
202 #
203 # Outputs guaranteed to only include positive counts.
204 #
205 # To strip negative and zero counts, add-in an empty counter:
206 # c += Counter()
207
208 def __add__(self, other):
209 ‘‘‘Add counts from two counters.
210
211 >>> Counter(‘abbb‘) + Counter(‘bcc‘)
212 Counter({‘b‘: 4, ‘c‘: 2, ‘a‘: 1})
213
214 ‘‘‘
215 if not isinstance(other, Counter):
216 return NotImplemented
217 result = Counter()
218 for elem, count in self.items():
219 newcount = count + other[elem]
220 if newcount > 0:
221 result[elem] = newcount
222 for elem, count in other.items():
223 if elem not in self and count > 0:
224 result[elem] = count
225 return result
226
227 def __sub__(self, other):
228 ‘‘‘ Subtract count, but keep only results with positive counts.
229
230 >>> Counter(‘abbbc‘) - Counter(‘bccd‘)
231 Counter({‘b‘: 2, ‘a‘: 1})
232
233 ‘‘‘
234 if not isinstance(other, Counter):
235 return NotImplemented
236 result = Counter()
237 for elem, count in self.items():
238 newcount = count - other[elem]
239 if newcount > 0:
240 result[elem] = newcount
241 for elem, count in other.items():
242 if elem not in self and count < 0:
243 result[elem] = 0 - count
244 return result
245
246 def __or__(self, other):
247 ‘‘‘Union is the maximum of value in either of the input counters.
248
249 >>> Counter(‘abbb‘) | Counter(‘bcc‘)
250 Counter({‘b‘: 3, ‘c‘: 2, ‘a‘: 1})
251
252 ‘‘‘
253 if not isinstance(other, Counter):
254 return NotImplemented
255 result = Counter()
256 for elem, count in self.items():
257 other_count = other[elem]
258 newcount = other_count if count < other_count else count
259 if newcount > 0:
260 result[elem] = newcount
261 for elem, count in other.items():
262 if elem not in self and count > 0:
263 result[elem] = count
264 return result
265
266 def __and__(self, other):
267 ‘‘‘ Intersection is the minimum of corresponding counts.
268
269 >>> Counter(‘abbb‘) & Counter(‘bcc‘)
270 Counter({‘b‘: 1})
271
272 ‘‘‘
273 if not isinstance(other, Counter):
274 return NotImplemented
275 result = Counter()
276 for elem, count in self.items():
277 other_count = other[elem]
278 newcount = count if count < other_count else other_count
279 if newcount > 0:
280 result[elem] = newcount
281 return result
282
283 Counter
Counter Code
我们从中挑选一些相对常用的方法来举例：
在上面的例子我们可以看出，counter方法返回的是一个字典，它将字符串中出现的所有字符都进行了统计。在这里再介绍一下update方法，这个update方法是将两次统计的结果相加，和字典的update略有不同。
2、有序字典(orderedDict )
orderdDict是对字典类型的补充，他记住了字典元素添加的顺序
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 # Each link is stored as a list of length three: [PREV, NEXT, KEY].
12
13 def __init__(self, *args, **kwds):
14 ‘‘‘Initialize an ordered dictionary. The signature is the same as
15 regular dictionaries, but keyword arguments are not recommended because
16 their insertion order is arbitrary.
17
18 ‘‘‘
19 if len(args) > 1:
20 raise TypeError(‘expected at most 1 arguments, got %d‘ % len(args))
21 try:
22 self.__root
23 except AttributeError:
24 self.__root = root = [] # sentinel node
25 root[:] = [root, root, None]
26 self.__map = {}
27 self.__update(*args, **kwds)
28
29 def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
30 ‘od.__setitem__(i, y) <==> od[i]=y‘
31 # Setting a new item creates a new link at the end of the linked list,
32 # and the inherited dictionary is updated with the new key/value pair.
33 if key not in self:
34 root = self.__root
35 last = root[0]
36 last[1] = root[0] = self.__map[key] = [last, root, key]
37 return dict_setitem(self, key, value)
38
39 def __delitem__(self, key, dict_delitem=dict.__delitem__):
40 ‘od.__delitem__(y) <==> del od[y]‘
41 # Deleting an existing item uses self.__map to find the link which gets
42 # removed by updating the links in the predecessor and successor nodes.
43 dict_delitem(self, key)
44 link_prev, link_next, _ = self.__map.pop(key)
45 link_prev[1] = link_next # update link_prev[NEXT]
46 link_next[0] = link_prev # update link_next[PREV]
47
48 def __iter__(self):
49 ‘od.__iter__() <==> iter(od)‘
50 # Traverse the linked list in order.
51 root = self.__root
52 curr = root[1] # start at the first node
53 while curr is not root:
54 yield curr[2] # yield the curr[KEY]
55 curr = curr[1] # move to next node
56
57 def __reversed__(self):
58 ‘od.__reversed__() <==> reversed(od)‘
59 # Traverse the linked list in reverse order.
60 root = self.__root
61 curr = root[0] # start at the last node
62 while curr is not root:
63 yield curr[2] # yield the curr[KEY]
64 curr = curr[0] # move to previous node
65
66 def clear(self):
67 ‘od.clear() -> None. Remove all items from od.‘
68 root = self.__root
69 root[:] = [root, root, None]
70 self.__map.clear()
71 dict.clear(self)
72
73 # -- the following methods do not depend on the internal structure --
74
75 def keys(self):
76 ‘od.keys() -> list of keys in od‘
77 return list(self)
78
79 def values(self):
80 ‘od.values() -> list of values in od‘
81 return [self[key] for key in self]
82
83 def items(self):
84 ‘od.items() -> list of (key, value) pairs in od‘
85 return [(key, self[key]) for key in self]
86
87 def iterkeys(self):
88 ‘od.iterkeys() -> an iterator over the keys in od‘
89 return iter(self)
90
91 def itervalues(self):
92 ‘od.itervalues -> an iterator over the values in od‘
93 for k in self:
94 yield self[k]
95
96 def iteritems(self):
97 ‘od.iteritems -> an iterator over the (key, value) pairs in od‘
98 for k in self:
99 yield (k, self[k])
100
101 update = MutableMapping.update
102
103 __update = update # let subclasses override update without breaking __init__
104
105 __marker = object()
106
107 def pop(self, key, default=__marker):
108 ‘‘‘od.pop(k[,d]) -> v, remove specified key and return the corresponding
109 value. If key is not found, d is returned if given, otherwise KeyError
110 is raised.
111
112 ‘‘‘
113 if key in self:
114 result = self[key]
115 del self[key]
116 return result
117 if default is self.__marker:
118 raise KeyError(key)
119 return default
120
121 def setdefault(self, key, default=None):
122 ‘od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od‘
123 if key in self:
124 return self[key]
125 self[key] = default
126 return default
127
128 def popitem(self, last=True):
129 ‘‘‘od.popitem() -> (k, v), return and remove a (key, value) pair.
130 Pairs are returned in LIFO order if last is true or FIFO order if false.
131
132 ‘‘‘
133 if not self:
134 raise KeyError(‘dictionary is empty‘)
135 key = next(reversed(self) if last else iter(self))
136 value = self.pop(key)
137 return key, value
138
139 def __repr__(self, _repr_running={}):
140 ‘od.__repr__() <==> repr(od)‘
141 call_key = id(self), _get_ident()
142 if call_key in _repr_running:
143 return ‘...‘
144 _repr_running[call_key] = 1
145 try:
146 if not self:
147 return ‘%s()‘ % (self.__class__.__name__,)
148 return ‘%s(%r)‘ % (self.__class__.__name__, self.items())
149 finally:
150 del _repr_running[call_key]
151
152 def __reduce__(self):
153 ‘Return state information for pickling‘
154 items = [[k, self[k]] for k in self]
155 inst_dict = vars(self).copy()
156 for k in vars(OrderedDict()):
157 inst_dict.pop(k, None)
158 if inst_dict:
159 return (self.__class__, (items,), inst_dict)
160 return self.__class__, (items,)
161
162 def copy(self):
163 ‘od.copy() -> a shallow copy of od‘
164 return self.__class__(self)
165
166 @classmethod
167 def fromkeys(cls, iterable, value=None):
168 ‘‘‘OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
169 If not specified, the value defaults to None.
170
171 ‘‘‘
172 self = cls()
173 for key in iterable:
174 self[key] = value
175 return self
176
177 def __eq__(self, other):
178 ‘‘‘od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive
179 while comparison to a regular mapping is order-insensitive.
180
181 ‘‘‘
182 if isinstance(other, OrderedDict):
183 return dict.__eq__(self, other) and all(_imap(_eq, self, other))
184 return dict.__eq__(self, other)
185
186 def __ne__(self, other):
187 ‘od.__ne__(y) <==> od!=y‘
188 return not self == other
189
190 # -- the following methods support python 3.x style dictionary views --
191
192 def viewkeys(self):
193 "od.viewkeys() -> a set-like object providing a view on od‘s keys"
194 return KeysView(self)
195
196 def viewvalues(self):
197 "od.viewvalues() -> an object providing a view on od‘s values"
198 return ValuesView(self)
199
200 def viewitems(self):
201 "od.viewitems() -> a set-like object providing a view on od‘s items"
202 return ItemsView(self)
OrderdDict Code
我们都知道字典本来是无序的，它依靠key，value之间的索引进行匹配，那么有序字典的原理是什么呢? 原理： dic = {‘k2‘:1,‘k1‘:2}，li = [‘k1‘,‘k2‘]，这个字典在内部维护了一个key列表。
从上面的图中我们就知道，尽管我们定义的字典是从1到8按顺序写的，但是在打印的过程当中并没有按到我们希望的顺序打印。这个时候有序字典的优势就出来了：
3、默认字典(defaultdict)
defaultdict是对字典的类型的补充，他默认给字典的值设置了一个类型。
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, name): # real signature unknown; restored from __doc__ 20 """ x.__getattribute__(‘name‘) <==> x.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): # real signature unknown; restored from __doc__ 51 """ x.__repr__() <==> repr(x) """ 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__().""" 56 57 defaultdict
defaultdict Code
用代码实现了下述功能
有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {‘k1‘: 大于66 , ‘k2‘: 小于66}
看出神奇的地方了么？我们可以不需要在空字典中指定value的值，直接执行append，就可以向字典中插入值了，就是因为我们使用defauldict(list)方式定义了一个value值默认为list的字典。
否则我们就要这么写才行：
1 lst = [11,22,33,44,55,66,77,88,99,90]
2 dic = {}
3 for l in lst:
4 if l >= 66:
5 if ‘k2‘in dic.keys():
6 dic[‘k2‘].append(l)
7 else:
8 dic[‘k2‘] = [l,]
9 else:
10 if ‘k1‘in dic.keys():
11 dic[‘k1‘].append(l)
12 else:
13 dic[‘k1‘] = [l,]
14 print dic
普通字典的实现方式
4、可命名元组(namedtuple)
根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型。
1 class Mytuple(__builtin__.tuple) 2 | Mytuple(x, y) 3 | 4 | Method resolution order: 5 | Mytuple 6 | __builtin__.tuple 7 | __builtin__.object 8 | 9 | Methods defined here: 10 | 11 | __getnewargs__(self) 12 | Return self as a plain tuple. Used by copy and pickle. 13 | 14 | __getstate__(self) 15 | Exclude the OrderedDict from pickling 16 | 17 | __repr__(self) 18 | Return a nicely formatted representation string 19 | 20 | _asdict(self) 21 | Return a new OrderedDict which maps field names to their values 22 | 23 | _replace(_self, **kwds) 24 | Return a new Mytuple object replacing specified fields with new values 25 | 26 | ---------------------------------------------------------------------- 27 | Class methods defined here: 28 | 29 | _make(cls, iterable, new=<built-in method __new__ of type object>, len=<built-in function len>) from __builtin__.type 30 | Make a new Mytuple object from a sequence or iterable 31 | 32 | ---------------------------------------------------------------------- 33 | Static methods defined here: 34 | 35 | __new__(_cls, x, y) 36 | Create new instance of Mytuple(x, y) 37 | 38 | ---------------------------------------------------------------------- 39 | Data descriptors defined here: 40 | 41 | __dict__ 42 | Return a new OrderedDict which maps field names to their values 43 | 44 | x 45 | Alias for field number 0 46 | 47 | y 48 | Alias for field number 1 49 | 50 | ---------------------------------------------------------------------- 51 | Data and other attributes defined here: 52 | 53 | _fields = (‘x‘, ‘y‘) 54 | 55 | ---------------------------------------------------------------------- 56 | Methods inherited from __builtin__.tuple: 57 | 58 | __add__(...) 59 | x.__add__(y) <==> x+y 60 | 61 | __contains__(...) 62 | x.__contains__(y) <==> y in x 63 | 64 | __eq__(...) 65 | x.__eq__(y) <==> x==y 66 | 67 | __ge__(...) 68 | x.__ge__(y) <==> x>=y 69 | 70 | __getattribute__(...) 71 | x.__getattribute__(‘name‘) <==> x.name 72 | 73 | __getitem__(...) 74 | x.__getitem__(y) <==> x[y] 75 | 76 | __getslice__(...) 77 | x.__getslice__(i, j) <==> x[i:j] 78 | 79 | Use of negative indices is not supported. 80 | 81 | __gt__(...) 82 | x.__gt__(y) <==> x>y 83 | 84 | __hash__(...) 85 | x.__hash__() <==> hash(x) 86 | 87 | __iter__(...) 88 | x.__iter__() <==> iter(x) 89 | 90 | __le__(...) 91 | x.__le__(y) <==> x<=y 92 | 93 | __len__(...) 94 | x.__len__() <==> len(x) 95 | 96 | __lt__(...) 97 | x.__lt__(y) <==> x<y 98 | 99 | __mul__(...) 100 | x.__mul__(n) <==> x*n 101 | 102 | __ne__(...) 103 | x.__ne__(y) <==> x!=y 104 | 105 | __rmul__(...) 106 | x.__rmul__(n) <==> n*x 107 | 108 | __sizeof__(...) 109 | T.__sizeof__() -- size of T in memory, in bytes 110 | 111 | count(...) 112 | T.count(value) -> integer -- return number of occurrences of value 113 | 114 | index(...) 115 | T.index(value, [start, [stop]]) -> integer -- return first index of value. 116 | Raises ValueError if the value is not present. 117 118 Mytuple 119 120 Mytuple
namedtuple Code
主要用于‘坐标’的表示。用法如下：
5、双向队列(deque)
一个线程安全的双向队列：双向队列我们可以理解为两个栈底相连的栈，和队列的先进先出不同，元素可以从这个队列的两端分别加入或者删除值。尽管list其实完全可以实现这个功能，但是python的collections类还是很贴心的把这些方法都归纳了出来，歪果仁就是有意思啊~~~
1 class deque(object): 2 """ 3 deque([iterable[, maxlen]]) --> deque object 4 5 Build an ordered collection with optimized access from 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 count(self, value): # real signature unknown; restored from __doc__ 20 """ D.count(value) -> integer -- return number of occurrences of value """ 21 return 0 22 23 def extend(self, *args, **kwargs): # real signature unknown 24 """ Extend the right side of the deque with elements from the iterable """ 25 pass 26 27 def extendleft(self, *args, **kwargs): # real signature unknown 28 """ Extend the left side of the deque with elements from the iterable """ 29 pass 30 31 def pop(self, *args, **kwargs): # real signature unknown 32 """ Remove and return the rightmost element. """ 33 pass 34 35 def popleft(self, *args, **kwargs): # real signature unknown 36 """ Remove and return the leftmost element. """ 37 pass 38 39 def remove(self, value): # real signature unknown; restored from __doc__ 40 """ D.remove(value) -- remove first occurrence of value. """ 41 pass 42 43 def reverse(self): # real signature unknown; restored from __doc__ 44 """ D.reverse() -- reverse *IN PLACE* """ 45 pass 46 47 def rotate(self, *args, **kwargs): # real signature unknown 48 """ Rotate the deque n steps to the right (default n=1). If n is negative, rotates left. """ 49 pass 50 51 def __copy__(self, *args, **kwargs): # real signature unknown 52 """ Return a shallow copy of a deque. """ 53 pass 54 55 def __delitem__(self, y): # real signature unknown; restored from __doc__ 56 """ x.__delitem__(y) <==> del x[y] """ 57 pass 58 59 def __eq__(self, y): # real signature unknown; restored from __doc__ 60 """ x.__eq__(y) <==> x==y """ 61 pass 62 63 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 64 """ x.__getattribute__(‘name‘) <==> x.name """ 65 pass 66 67 def __getitem__(self, y): # real signature unknown; restored from __doc__ 68 """ x.__getitem__(y) <==> x[y] """ 69 pass 70 71 def __ge__(self, y): # real signature unknown; restored from __doc__ 72 """ x.__ge__(y) <==> x>=y """ 73 pass 74 75 def __gt__(self, y): # real signature unknown; restored from __doc__ 76 """ x.__gt__(y) <==> x>y """ 77 pass 78 79 def __iadd__(self, y): # real signature unknown; restored from __doc__ 80 """ x.__iadd__(y) <==> x+=y """ 81 pass 82 83 def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__ 84 """ 85 deque([iterable[, maxlen]]) --> deque object 86 87 Build an ordered collection with optimized access from its endpoints. 88 # (copied from class doc) 89 """ 90 pass 91 92 def __iter__(self): # real signature unknown; restored from __doc__ 93 """ x.__iter__() <==> iter(x) """ 94 pass 95 96 def __len__(self): # real signature unknown; restored from __doc__ 97 """ x.__len__() <==> len(x) """ 98 pass 99 100 def __le__(self, y): # real signature unknown; restored from __doc__ 101 """ x.__le__(y) <==> x<=y """ 102 pass 103 104 def __lt__(self, y): # real signature unknown; restored from __doc__ 105 """ x.__lt__(y) <==> x<y """ 106 pass 107 108 @staticmethod # known case of __new__ 109 def __new__(S, *more): # real signature unknown; restored from __doc__ 110 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 111 pass 112 113 def __ne__(self, y): # real signature unknown; restored from __doc__ 114 """ x.__ne__(y) <==> x!=y """ 115 pass 116 117 def __reduce__(self, *args, **kwargs): # real signature unknown 118 """ Return state information for pickling. """ 119 pass 120 121 def __repr__(self): # real signature unknown; restored from __doc__ 122 """ x.__repr__() <==> repr(x) """ 123 pass 124 125 def __reversed__(self): # real signature unknown; restored from __doc__ 126 """ D.__reversed__() -- return a reverse iterator over the deque """ 127 pass 128 129 def __setitem__(self, i, y): # real signature unknown; restored from __doc__ 130 """ x.__setitem__(i, y) <==> x[i]=y """ 131 pass 132 133 def __sizeof__(self): # real signature unknown; restored from __doc__ 134 """ D.__sizeof__() -- size of D in memory, in bytes """ 135 pass 136 137 maxlen = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 138 """maximum size of a deque or None if unbounded""" 139 140 141 __hash__ = None 142 143 deque
deque Code
时间： 2024-08-12 14:48:14