Python标准库之collections包的使用教程
前言
Python为我们提供了4种基本的数据结构：list,tuple,dict,set，但是在处理数据量较大的情形的时候，这4种数据结构就明显过于单一了，比如list作为数组在某些情形插入的效率会比较低，有时候我们也需要维护一个有序的dict。所以这个时候我们就要用到Python标准库为我们提供的collections包了，它提供了多个有用的集合类，熟练掌握这些集合类，不仅可以让我们让写出的代码更加Pythonic，也可以提高我们程序的运行效率。
defaultdict
defaultdict(default_factory)在普通的dict之上添加了default_factory，使得key不存在时会自动生成相应类型的value，default_factory参数可以指定成list,set,int等各种合法类型。
我们现在有下面这样一组list，虽然我们有5组数据，但是仔细观察后发现其实我们只有3种color，但是每一种color对应多个值。现在我们想要将这个list转换成一个dict，这个dict的key对应一种color，dict的value设置为一个list存放color对应的多个值。我们可以使用defaultdict(list)来解决这个问题。
>>>fromcollectionsimportdefaultdict
>>>s=[('yellow',1),('blue',2),('yellow',3),('blue',4),('red',1)]
>>>d=defaultdict(list)
>>>fork,vins:
...d[k].append(v)
...
>>>sorted(d.items())
[('blue',[2,4]),('red',[1]),('yellow',[1,3])]
以上等价于：
>>>d={}
>>>fork,vins:
...d.setdefault(k,[]).append(v)
...
>>>sorted(d.items())
[('blue',[2,4]),('red',[1]),('yellow',[1,3])]
如果我们不希望含有重复的元素，可以考虑使用defaultdict(set)。set相比list的不同之处在于set中不允许存在相同的元素。
>>>fromcollectionsimportdefaultdict
>>>s=[('red',1),('blue',2),('red',3),('blue',4),('red',1),('blue',4)]
>>>d=defaultdict(set)
>>>fork,vins:
...d[k].add(v)
...
>>>sorted(d.items())
[('blue',{2,4}),('red',{1,3})]
OrderedDict
Python3.6之前的dict是无序的，但是在某些情形我们需要保持dict的有序性，这个时候可以使用OrderedDict，它是dict的一个subclass，但是在dict的基础上保持了dict的有序型，下面我们来看一下使用方法。
>>>#regularunsorteddictionary
>>>d={'banana':3,'apple':4,'pear':1,'orange':2}
>>>#dictionarysortedbykey
>>>OrderedDict(sorted(d.items(),key=lambdat:t[0]))
OrderedDict([('apple',4),('banana',3),('orange',2),('pear',1)])
>>>#dictionarysortedbyvalue
>>>OrderedDict(sorted(d.items(),key=lambdat:t[1]))
OrderedDict([('pear',1),('orange',2),('banana',3),('apple',4)])
>>>#dictionarysortedbylengthofthekeystring
>>>OrderedDict(sorted(d.items(),key=lambdat:len(t[0])))
OrderedDict([('pear',1),('apple',4),('orange',2),('banana',3)])
使用popitem(last=True)方法可以让我们按照LIFO(先进后出)的顺序删除dict中的key-value，即删除最后一个插入的键值对，如果last=False就按照FIFO(先进先出)删除dict中key-value。
>>>d={'banana':3,'apple':4,'pear':1,'orange':2}
>>>#dictionarysortedbykey
>>>d=OrderedDict(sorted(d.items(),key=lambdat:t[0]))
>>>d
OrderedDict([('apple',4),('banana',3),('orange',2),('pear',1)])
>>>d.popitem()
('pear',1)
>>>d.popitem(last=False)
('apple',4)
使用move_to_end(key,last=True)来改变有序的OrderedDict对象的key-value顺序，通过这个方法我们可以将排序好的OrderedDict对象中的任意一个key-value插入到字典的开头或者结尾。
>>>d=OrderedDict.fromkeys('abcde')
>>>d
OrderedDict([('a',None),('b',None),('c',None),('d',None),('e',None)])
>>>d.move_to_end('b')
>>>d
OrderedDict([('a',None),('c',None),('d',None),('e',None),('b',None)])
>>>''.join(d.keys())
'acdeb'
>>>d.move_to_end('b',last=False)
>>>''.join(d.keys())
'bacde'
deque
list存储数据的优势在于按索引查找元素会很快，但是插入和删除元素就很慢了，因为list是基于数组实现的。deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈，而且线程安全。
list只提供了append和pop方法来从list的尾部插入/删除元素，deque新增了appendleft/popleft等方法允许我们高效的在元素的开头来插入/删除元素。而且使用deque在队列两端append或pop元素的算法复杂度大约是O(1)，但是对于list对象改变列表长度和数据位置的操作例如pop(0)和insert(0,v)操作的复杂度高达O(n)。
>>>fromcollectionsimportdeque >>>dq=deque(range(10),maxlen=10) >>>dq deque([0,1,2,3,4,5,6,7,8,9],maxlen=10) >>>dq.rotate(3) >>>dq deque([7,8,9,0,1,2,3,4,5,6],maxlen=10) >>>dq.rotate(-4) >>>dq deque([1,2,3,4,5,6,7,8,9,0],maxlen=10) >>>dq.appendleft(-1) >>>dq deque([-1,1,2,3,4,5,6,7,8,9],maxlen=10) >>>dq.extend([11,22,33]) >>>dq deque([3,4,5,6,7,8,9,11,22,33],maxlen=10) >>>dq.extendleft([10,20,30,40]) >>>dq deque([40,30,20,10,3,4,5,6,7,8],maxlen=10)
Counter
Count用来统计相关元素的出现次数。
>>>fromcollectionsimportCounter
>>>ct=Counter('abracadabra')
>>>ct
Counter({'a':5,'r':2,'b':2,'d':1,'c':1})
>>>ct.update('aaaaazzz')
>>>ct
Counter({'a':10,'z':3,'r':2,'b':2,'d':1,'c':1})
>>>ct.most_common(2)
[('a',10),('z',3)]
>>>ct.elements()
namedtuple
使用namedtuple(typename,field_names)命名tuple中的元素来使程序更具可读性。
>>>fromcollectionsimportnamedtuple
>>>City=namedtuple('City','namecountrypopulationcoordinates')
>>>tokyo=City('Tokyo','JP',36.933,(35.689722,139.691667))
>>>tokyo
City(name='Tokyo',country='JP',population=36.933,coordinates=(35.689722,139.691667))
>>>tokyo.population
36.933
>>>tokyo.coordinates
(35.689722,139.691667)
>>>tokyo[1]
'JP'
>>>City._fields
('name','country','population','coordinates')
>>>LatLong=namedtuple('LatLong','latlong')
>>>delhi_data=('DelhiNCR','IN',21.935,LatLong(28.613889,77.208889))
>>>delhi=City._make(delhi_data)
>>>delhi._asdict()
OrderedDict([('name','DelhiNCR'),('country','IN'),('population',21.935),
('coordinates',LatLong(lat=28.613889,long=77.208889))])
>>>forkey,valueindelhi._asdict().items():
print(key+':',value)
name:DelhiNCR
country:IN
population:21.935
coordinates:LatLong(lat=28.613889,long=77.208889)
ChainMap
ChainMap可以用来合并多个字典。
>>>fromcollectionsimportChainMap
>>>d=ChainMap({'zebra':'black'},{'elephant':'blue'},{'lion':'yellow'})
>>>d['lion']='orange'
>>>d['snake']='red'
>>>d
ChainMap({'lion':'orange','zebra':'black','snake':'red'},
{'elephant':'blue'},{'lion':'yellow'})
>>>deld['lion'] >>>deld['elephant'] Traceback(mostrecentcalllast): File"/usr/lib/python3.5/collections/__init__.py",line929,in__delitem__ delself.maps[0][key] KeyError:'elephant' Duringhandlingoftheaboveexception,anotherexceptionoccurred: Traceback(mostrecentcalllast): File"",line1,in File"/usr/lib/python3.5/collections/__init__.py",line931,in__delitem__ raiseKeyError('Keynotfoundinthefirstmapping:{!r}'.format(key)) KeyError:"Keynotfoundinthefirstmapping:'elephant'"
从上面del['elephant']的报错信息可以看出来，对于改变键值的操作ChainMap只会在第一个字典self.maps[0][key]进行查找，新增加的键值对也都会加入第一个字典，我们来改进一下ChainMap解决这个问题：
classDeepChainMap(ChainMap):
'VariantofChainMapthatallowsdirectupdatestoinnerscopes'
def__setitem__(self,key,value):
formappinginself.maps:
ifkeyinmapping:
mapping[key]=value
return
self.maps[0][key]=value
def__delitem__(self,key):
formappinginself.maps:
ifkeyinmapping:
delmapping[key]
return
raiseKeyError(key)
>>>d=DeepChainMap({'zebra':'black'},{'elephant':'blue'},{'lion':'yellow'})
>>>d['lion']='orange'#updateanexistingkeytwolevelsdown
>>>d['snake']='red'#newkeysgetaddedtothetopmostdict
>>>deld['elephant']#removeanexistingkeyoneleveldown
DeepChainMap({'zebra':'black','snake':'red'},{},{'lion':'orange'})
可以使用new_child来deepcopy一个ChainMap：
>>>fromcollectionsimportChainMap
>>>a={'a':'A','c':'C'}
>>>b={'b':'B','c':'D'}
>>>m=ChainMap({'a':'A','c':'C'},{'b':'B','c':'D'})
>>>m
ChainMap({'a':'A','c':'C'},{'b':'B','c':'D'})
>>>m['c']
'C'
>>>m.maps
[{'c':'C','a':'A'},{'c':'D','b':'B'}]
>>>a['c']='E'
>>>m['c']
'E'
>>>m
ChainMap({'c':'E','a':'A'},{'c':'D','b':'B'})
>>>m2=m.new_child()
>>>m2['c']='f'
>>>m2
ChainMap({'c':'f'},{'c':'E','a':'A'},{'c':'D','b':'B'})
>>>m
ChainMap({'c':'E','a':'A'},{'c':'D','b':'B'})
>>>m2.parents
ChainMap({'c':'E','a':'A'},{'c':'D','b':'B'})
UserDict
下面我们来改进一下字典，查询字典的时候将key转换为str的形式：
classStrKeyDict0(dict): def__missing__(self,key): ifisinstance(key,str): raiseKeyError(key) returnself[str(key)] defget(self,key,default=None): try: returnself[key] exceptKeyError: returndefault def__contains__(self,key): returnkeyinself.keys()orstr(key)inself.keys()
解释一下上面这段程序：
- 在__missing__中isinstance(key,str)是必须要的，请思考一下为什么？因为假设一个key不存在的话，这会造成infiniterecursion，self[str(key)]会再次调用__getitem__。
- __contains__也是必须实现的，因为kind的时候会进行调用，但是注意即使查找失败它也不会调用__missing__。关于__contains__还有一个细节就是：我们并没有使用kinmy_dict，因为str(key)inself的形式，因为这会造成递归调用__contains__。
这里还强调一点，在Python2.x中dict.keys()会返回一个list，这意味着kinmy_list必须遍历list。在Python3.x中针对dict.keys()做了优化，性能更高，它会返回一个view如同set一样，详情参考官方文档。
上面这个例子可以用UserDict改写，并且将所有的key都以str的形式存储，而且这种写法更加常用简洁：
importcollections classStrKeyDict(collections.UserDict): def__missing__(self,key): ifisinstance(key,str): raiseKeyError(key) returnself[str(key)] def__contains__(self,key): returnstr(key)inself.data def__setitem__(self,key,item): self.data[str(key)]=item
UserDict是MutableMapping和Mapping的子类，它继承了MutableMapping.update和Mapping.get两个重要的方法，所以上面我们并没有重写get方法，可以在源码中看到它的实现和我们上面的实现是差不多的。
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对毛票票的支持。