本文共 20203 字，大约阅读时间需要 67 分钟。
Collections :collections 模块包含了内建类型之外的一些有用的工具，例如 counter,defaultdict,orderedDict,deque,以及nametuple ,其中counter,deque以及defaultdict是最常用 的类
1：计数器（counter）
如果你想统计一个单词在给家的序列中一共出现了多少次，诸如此类的操作就可以用到counter,来看看如何统计一个list中出的item次数：
from collections import Counter l = ['cat','is','this','is','cat','is'] c = Counter(l) print(c) ### 输出结果 Counter({ 'is': 3, 'cat': 2, 'this': 1})
若要统计这其中不同单词的个数，我们可以这么做
from collections import Counterl = ['cat','is','this','is','cat','is']c = Counter(l)print(c)print((len(set(l))))### 输出结果Counter({ 'is': 3, 'cat': 2, 'this': 1})3
counter是对字典类型的补充，具备字典的所有功能 然后加自己的功能
1：Counter 类方法，里面给出了详细的例子
class Counter(dict): '''Dict subclass for counting hashable items. Sometimes called a bag or multiset. Elements are stored as dictionary keys and their counts are stored as dictionary values. >>> c = Counter('abcdeabcdabcaba') # count elements from a string >>> c.most_common(3) # three most common elements [('a', 5), ('b', 4), ('c', 3)] >>> sorted(c) # list all unique elements ['a', 'b', 'c', 'd', 'e'] >>> ''.join(sorted(c.elements())) # list elements with repetitions 'aaaaabbbbcccdde' >>> sum(c.values()) # total of all counts 15 >>> c['a'] # count of letter 'a' 5 >>> for elem in 'shazam': # update counts from an iterable ... c[elem] += 1 # by adding 1 to each element's count >>> c['a'] # now there are seven 'a' 7 >>> del c['b'] # remove all 'b' >>> c['b'] # now there are zero 'b' 0 >>> d = Counter('simsalabim') # make another counter >>> c.update(d) # add in the second counter >>> c['a'] # now there are nine 'a' 9 >>> c.clear() # empty the counter >>> c Counter() Note: If a count is set to zero or reduced to zero, it will remain in the counter until the entry is deleted or the counter is cleared: >>> c = Counter('aaabbc') >>> c['b'] -= 2 # reduce the count of 'b' by two >>> c.most_common() # 'b' is still in, but its count is zero [('a', 3), ('c', 1), ('b', 0)] ''' # References: # http://en.wikipedia.org/wiki/Multiset # http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html # http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm # http://code.activestate.com/recipes/259174/ # Knuth, TAOCP Vol. II section 4.6.3
2：most_common -- ：提取最常用的前多少
def most_common(self, n=None): '''List the n most common elements and their counts from the most common to the least. If n is None, then list all element counts. >>> Counter('abcdeabcdabcaba').most_common(3) [('a', 5), ('b', 4), ('c', 3)] ''' 输出结果
l = ['cat','is','this','is','cat','is','name']print(Counter(l).most_common(4))print(Counter(l).most_common(3))print(Counter(l).most_common(2))print(Counter(l).most_common(1))### 输出结果[('is', 3), ('cat', 2), ('this', 1), ('name', 1)][('is', 3), ('cat', 2), ('this', 1)][('is', 3), ('cat', 2)][('is', 3)]
3：elements ---: 返回包含所有元素的迭代器，小于时忽略
def elements(self): '''Iterator over elements repeating each as many times as its count. >>> c = Counter('ABCABC') >>> sorted(c.elements()) ['A', 'A', 'B', 'B', 'C', 'C'] # Knuth's example for prime factors of 1836: 2**2 * 3**3 * 17**1 >>> prime_factors = Counter({2: 2, 3: 3, 17: 1}) >>> product = 1 >>> for factor in prime_factors.elements(): # loop over factors ... product *= factor # and multiply them >>> product 1836 Note, if an element's count has been set to zero or is a negative number, elements() will ignore it. ''' # Emulate Bag.do from Smalltalk and Multiset.begin from C++. return _chain.from_iterable(_starmap(_repeat, self.items()))# Override dict methods where necessary
4：未实现的方法
@classmethoddef fromkeys(cls, iterable, v=None): # There is no equivalent method for counters because setting v=1 # means that no element can have a count greater than one. raise NotImplementedError( 'Counter.fromkeys() is undefined. Use Counter(iterable) instead.')
5: update ---: 更新，添加新的内容
def update(*args, **kwds): '''Like dict.update() but add counts instead of replacing them. Source can be an iterable, a dictionary, or another Counter instance. >>> c = Counter('which') >>> c.update('witch') # add elements from another iterable >>> d = Counter('watch') >>> c.update(d) # add elements from another counter >>> c['h'] # four 'h' in which, witch, and watch 4 ''' # The regular dict.update() operation makes no sense here because the # replace behavior results in the some of original untouched counts # being mixed-in with all of the other counts for a mismash that # doesn't have a straight-forward interpretation in most counting # contexts. Instead, we implement straight-addition. Both the inputs # and outputs are allowed to contain zero and negative counts. if not args: raise TypeError("descriptor 'update' of 'Counter' object " "needs an argument") self, *args = args if len(args) > 1: raise TypeError('expected at most 1 arguments, got %d' % len(args)) iterable = args[0] if args else None if iterable is not None: if isinstance(iterable, Mapping): if self: self_get = self.get for elem, count in iterable.items(): self[elem] = count + self_get(elem, 0) else: super(Counter, self).update(iterable) # fast path when counter is empty else: _count_elements(self, iterable) if kwds: self.update(kwds)
6：subtract -----：删除匹配的值
def subtract(*args, **kwds): '''Like dict.update() but subtracts counts instead ofreplacing them. Counts can be reduced belowzero. Both the inputs and outputs are allowed to contain zero and negativecounts. Source can be an iterable, adictionary, or another Counter instance. ### 使用方法 >>> c = Counter('which') >>> c.subtract('witch') # subtract elements from anotheriterable >>>c.subtract(Counter('watch')) #subtract elements from another counter >>> c['h'] # 2 in which, minus 1in witch, minus 1 in watch 0 >>> c['w'] # 1 in which, minus 1in witch, minus 1 in watch -1 ''' if not args: raise TypeError("descriptor 'subtract' of 'Counter' object " "needs anargument") self, *args= args if len(args) > 1: raise TypeError('expected at most 1 arguments, got %d' % len(args)) iterable = args[0] if argselse None if iterable is not None: self_get = self.get if isinstance(iterable, Mapping): for elem,count in iterable.items(): self[elem] = self_get(elem, 0) - count else: for elemin iterable: self[elem] = self_get(elem, 0) - 1 if kwds: self.subtract(kwds)
7: copy ---: 复制
def copy(self): 'Return a shallow copy.' return self.__class__(self)
使用方法：
l= Counter(['cat','is',]) l1 = l.copy() print(l1) print(l) ### 输出结果 Counter({ 'cat': 1, 'is': 1}) Counter({ 'cat': 1, 'is': 1})
二：
有序字典(orderedDict)
对字典类型的补充，他实现了对字典对象中元素的排序。1：OrderedDict 类方法
class OrderedDict(dict): 'Dictionary that remembers insertion order' # An inherited dict maps keys tovalues. # The inherited dict provides__getitem__, __len__, __contains__, and get. # The remaining methods are order-aware. # Big-O running times for all methodsare the same as regular dictionaries. # The internal self.__map dict mapskeys to links in a doubly linked list. # The circular doubly linked liststarts and ends with a sentinel element. # The sentinel element never getsdeleted (this simplifies the algorithm). # The sentinel is in self.__hardrootwith a weakref proxy in self.__root. # The prev links are weakref proxies(to prevent circular references). # Individual links are kept alive bythe hard reference in self.__map. # Those hard references disappearwhen a key is deleted from an OrderedDict.
2：clear ----： 请空，返回空
def clear(self): 'od.clear() -> None. Remove all items from od.' root = self.__root root.prev = root.next= root self.__map.clear() dict.clear(self)
使用方法：
d= { 'name':'zhang','age':24} print(OrderedDict(d).clear()) ### 输出结果 None
3: popitem ----: 删除只保留一组值并返回，last值为True时，默认是最后一组，当为False时，返回第一组，默认值为True
def popitem(self, last=True): '''od.popitem() -> (k, v), return and remove a (key,value) pair. Pairs are returned in LIFO order iflast is true or FIFO order if false. ''' if not self: raise KeyError('dictionary is empty') root = self.__root if last: link = root.prev link_prev = link.prev link_prev.next = root root.prev = link_prev else: link = root.next link_next = link.next root.next = link_next link_next.prev = root key = link.key del self.__map[key] value= dict.pop(self, key) return key,value
使用方法：
d= OrderedDict((('name','zhang'),('age',24),('job','IT'),('天天学习','好好向上'))) print("default:",d.popitem()) print("------------------------") print(d) print("False:",d.popitem(last=False)) print("------------------------") print(d) print("True:",d.popitem(last=True)) print("------------------------") print(d) ### 输出结果 default: ('天天学习', '好好向上') ------------------------ OrderedDict([('name', 'zhang'), ('age', 24), ('job', 'IT')]) False: ('name', 'zhang') ------------------------ OrderedDict([('age', 24), ('job', 'IT')]) True: ('job', 'IT') ------------------------ OrderedDict([('age', 24)])
4：move_to_end ---：移动指定的key值至原值的结尾，last 默认值为True,移动到末尾，当为False时，移动key数据对至原值的开头
def move_to_end(self, key, last=True): '''Move an existing element to the end (or beginning iflast==False). Raises KeyError if the element doesnot exist. When last=True, acts like a fastversion of self[key]=self.pop(key). ''' link= self.__map[key] link_prev = link.prev link_next = link.next link_prev.next = link_next link_next.prev = link_prev root = self.__root if last: last = root.prev link.prev= last link.next = root last.next= root.prev = link else: first = root.next link.prev= root link.next= first root.next = first.prev = link
使用方法：
d= OrderedDict((('name','zhang'),('age',24),('job','IT'),('天天学习','好好向上'))) d.move_to_end('job',last=False) print("False_job:",d) d = OrderedDict((('name','zhang'),('age',24),('job','IT'),('天天学习','好好向上'))) d.move_to_end('job') print("======================================================================") print("True_job:",d) ### 输出结果 False_job: OrderedDict([('job', 'IT'), ('name', 'zhang'), ('age', 24), ('天天学习', '好好向上')]) ====================================================================== True_job: OrderedDict([('name', 'zhang'), ('age', 24), ('天天学习', '好好向上'), ('job', 'IT')])
5: pop ----: 删除，删除指定的key值并返回，如果key 不存在则报错
def pop(self, key, default=__marker): '''od.pop(k[,d]) -> v, remove specified key and returnthe corresponding value. If key is not found, d is returned if given,otherwise KeyError is raised. ''' if key in self: result = self[key] del self[key] return result if defaultis self.__marker: raise KeyError(key) return default
使用方法：
d= OrderedDict((('name','zhang'),('age',24),('job','IT'),('天天学习','好好向上'))) d1 = d.pop('name') print(d1) ### 输出结果 zhang
6：setdefault --: 添加 可选值default 默认为None
def setdefault(self, key, default=None): 'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=dif k not in od' if key in self: return self[key] self[key] = default return default
使用方法：
d = OrderedDict((('name','zhang'),('age',24),('job','IT'),('天天学习','好好向上'))) d.setdefault('phone','133') d.setdefault('addr') print(d) ### 输出结果 OrderedDict([('name', 'zhang'), ('age', 24), ('job', 'IT'), ('天天学习', '好好向上'), ('phone', '133'), ('addr', None)])
7: copy ---: 复制
def copy(self): 'od.copy() -> a shallow copy of od' return self.__class__(self)
使用方法：
d= OrderedDict((('name','zhang'),('age',24),('job','IT'),('天天学习','好好向上'))) d1 = d.copy() print(d1) ### 输出结果 OrderedDict([('name', 'zhang'), ('age', 24), ('job', 'IT'), ('天天学习', '好好向上')])
8：fromkeys ---: 生成新数据，如果未指定value，将默认为None（感觉为什么这个功能要加在OrderedDict里）
@classmethod def fromkeys(cls, iterable, value=None): '''OD.fromkeys(S[, v]) -> . If not specified, the value defaultsto None. ''' self = cls() for key in iterable: self[key] = value return self
测试的没头没脑的(和d 没有关系了都)
d= OrderedDict((('name','zhang'),('age',24),('job','IT'),('天天学习','好好向上'))) d1 = d.fromkeys(('name','SH')) ### 未指定 value值
print(d1) print("==========================") d1 = d.fromkeys(('name','li'),value='123') ### 指定 value值 print(d1) ### 输出结果 OrderedDict([('name', None), ('SH', None)]) ========================== OrderedDict([('name', '123'), ('li', '123')])
三：
默认字典(defaultdict)
对字典的类型的补充，默认给字典的值设置了一个类型，dict的setdefault（）方法在key不存在时会建立一个默认值。与此相反，defaultdict会在初始化时指定默认值。
1：类方法：接收一个类型做为参数而不是一个元素
class defaultdict(dict): """ defaultdict(default_factory[, ...])--> dict with default factory The default factory is called withoutarguments to produce a new value when a key is notpresent, in __getitem__ only. A defaultdict compares equal to adict with the same items. All remaining arguments are treatedthe same as if they were passed to the dict constructor,including keyword arguments. """
使用方法：
from collections import defaultdict def test1(): return "namezhang" l = defaultdict(test1,job="it") print(l) ### 输出结果 defaultdict(<function test1 at 0x029C31E0>, { 'job': 'it'})
2: copy ---: 复制
def copy(self): # real signatureunknown; restored from __doc__ """ D.copy() -> ashallow copy of D. """ pass
示例
有如下值集合[11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66 , 'k2':小于66}
原生字典的实现方式
values = [11, 22,33,44,55,66,77,88,99,90]my_dict = {}for value in values: if value>66: ifmy_dict.has_key('k1'): my_dict['k1'].append(value) else: my_dict['k1'] =[value] else: ifmy_dict.has_key('k2'): my_dict['k2'].append(value) else: my_dict['k2'] =[value] 默认字典的实现方式
from collections importdefaultdictvalues = [11, 22,33,44,55,66,77,88,99,90]my_dict =defaultdict(list),for value in values: if value>66: my_dict['k1'].append(value) else: my_dict['k2'].append(value)
四：可命令元组(namedtuple)
生成可以使用名字来访问元素内容的tuple子类,根据namedtuple可以创建一个包含tuple所有功能以及其他功能的类型
使用方法：
import collections persion = collections.namedtuple('persion','nameage gender') print(type(persion)) bob = persion(name= 'bob',age= 30,gender='male') print(bob) zhang = persion(name= 'zhang',age= 25,gender='male') for persion in [bob,zhang]: print("%s is %d years old %s" % persion) ### 输出 结果 <class 'type'> persion(name='bob', age=30, gender='male') bob is 30 years old male zhang is 25 years old male
可调用的方法
class persion(builtins.tuple) | persion(name, age, gender) | | Method resolution order: | persion | builtins.tuple | builtins.object | | Methods defined here: | | __getnewargs__(self) | Return self as a plain tuple. Used by copy and pickle. | | __getstate__(self) | Exclude the OrderedDict from pickling | | __repr__(self) | Return a nicely formatted representation string | | _asdict(self) | Return a new OrderedDict which maps field names to their values. | | _replace(_self, **kwds) | Return a new persion object replacing specified fields with new values | | ---------------------------------------------------------------------- | Classmethods defined here: | | _make(iterable, new=, len= ) from builtins.type | Make a new persion object from a sequence or iterable | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(_cls,name, age, gender) | Create new instance of persion(name, age, gender) | | ---------------------------------------------------------------------- | Datadescriptors defined here: | | __dict__ | Anew OrderedDict mapping field names to their values | | age | Alias for field number 1 | | gender | Alias for field number 2 | | name | Alias for field number 0 | | ---------------------------------------------------------------------- | Dataand other attributes defined here: | | _fields = ('name', 'age', 'gender') | | _source = "from builtins import property as _property,tupl..._itemget... | | ---------------------------------------------------------------------- | Methodsinherited from builtins.tuple: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return key in self. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __iter__(self, /) | Implement iter(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self integer -- return number of occurrences of value | | index(...) | T.index(value, [start, [stop]]) -> integer -- return first index ofvalue. | Raises ValueError if the value is notpresent.
五：双向队列(deque)
一个线程安全的双向队列,可以从两端添加删除元素，支持序列的常用操作。1: 类方法
class deque(object): """ deque([iterable[, maxlen]]) -->deque object Build an ordered collection withoptimized access from its endpoints. """
2: append ---: 添加：从右侧添加
def append(self, *args, **kwargs): # real signature unknown """ Add an element tothe right side of the deque. """ pass
使用方法：
from collections import deque l = deque(['name','age']) l.append('job') print(l) ### 输出结果 deque(['name', 'age', 'job'])
3: appendleft: ----: 左侧添加
def appendleft(self, *args, **kwargs): # real signature unknown """ Add an element tothe left side of the deque. """ pass
使用方法：
from collections import deque l = deque(['name','age']) l.appendleft('job') print(l) ### 输出结果 deque(['job', 'name', 'age'])
4: clear ---: 清空
def clear(self, *args, **kwargs): # real signature unknown """ Remove allelements from the deque. """ pass
使用方法：
from collections import deque l = deque(['name','age']) l.clear() print(l) ### 输出结果 deque([])
5: count ---：计算出现次数
def count(self, value): # real signature unknown; restored from __doc__ """ D.count(value)-> integer -- return number of occurrences of value """ return 0
使用方法：
from collections import deque l = deque(['1','2','1','2','3']) print(l.count('1')) ### 输出结果 2
6: extend ----:扩展，从右侧添加
def extend(self, *args, **kwargs): # real signature unknown """ Extend the rightside of the deque with elements from the iterable """ pass
使用方法：
from collections import deque l = deque(['1','2','1','2','3']) l.extend('5') print(l) ### 输出结果 deque(['1', '2', '1', '2', '3', '5'])
7: extendleft ---：左侧扩展添加,与extend相反方向
def extendleft(self, *args, **kwargs): # real signature unknown """ Extend the leftside of the deque with elements from the iterable """ pass
8: pop --- ：删除并返回最右侧的数据
def pop(self, *args, **kwargs): # real signature unknown """ Remove and returnthe rightmost element. """ pass
使用方法：
l = deque(['1','2','1','2','3']) print(l.pop()) ### 输出结果 3
9: popleft ---: 删除并返回最左侧的数据，与pop相反
def popleft(self, *args, **kwargs): # real signature unknown """ Remove and returnthe leftmost element. """ pass
10: remove ---: 删除第一次出现的值
def remove(self, value): # real signature unknown; restored from __doc__ """ D.remove(value) --remove first occurrence of value. """ pass
使用方法：
from collections import dequel = deque(['1','2','1','2','3'])l.remove('2')print(l)### 输出结果deque(['1', '1', '2', '3'])
11: reverse ---：取自己的反转值
def reverse(self): # real signatureunknown; restored from __doc__ """ D.reverse() --reverse *IN PLACE* """ pass
使用方法：
l = deque(['1','2','1','2','3'])l.reverse()print(l)### 输出结果deque(['3', '2', '1', '2', '1'])
12: rotate ---: 指定个数反转默认是1，也就是从队列的第右侧拿数据放到最左边
def rotate(self, *args, **kwargs): # real signature unknown """ Rotate the deque nsteps to the right (default n=1). If nis negative, rotates left. """ pass
使用方法：
l = deque(['1','2','3','4','5'])l.rotate(3)print(l)l = deque(['1','2','3','4','5'])l.rotate()print(l)### 输出结果deque(['3', '4', '5', '1', '2'])deque(['5', '1', '2', '3', '4'])
转载地址：http://vedhb.baihongyu.com/