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方法返回的是一个字典，它将字符串中出现的所有字符都进行了统计。在这里再介绍一下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)
我们都知道字典本来是无序的，它依靠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
用代码实现了下述功能
有如下值集合 [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
主要用于‘坐标’的表示。用法如下：
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
