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
