Python标准库之collections包的使用教程

概述前言Python为我们提供了4种基本的数据结构：list,tuple,dict,set，但是在处理数据量较大的情形的时候，这4种数据结构就明显过于单一了，比如list作为数组在某些情形插入的效率会比较低，有时候我们也需要维护一个有

前言

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)来解决这个问题。

>>> from collections import defaultdict>>> s = [('yellow',1),('blue',2),('yellow',3),4),('red',1)]>>> d = defaultdict(List)>>> for k,v in s:...  d[k].append(v)...>>> sorted(d.items())[('blue',[2,4]),[1]),[1,3])]

以上等价于：

>>> d = {}>>> for k,v in s:...  d.setdefault(k,[]).append(v)...>>> sorted(d.items())[('blue',3])]

如果我们不希望含有重复的元素，可以考虑使用defaultdict(set) 。set相比List的不同之处在于set中不允许存在相同的元素。

>>> from collections import defaultdict>>> s = [('red',4)]>>> d = defaultdict(set)>>> for k,v in s:...  d[k].add(v)...>>> sorted(d.items())[('blue',{2,4}),{1,3})]

OrderedDict

python3.6之前的dict是无序的，但是在某些情形我们需要保持dict的有序性，这个时候可以使用OrderedDict，它是dict的一个subclass，但是在dict的基础上保持了dict的有序型，下面我们来看一下使用方法。

>>> # regular unsorted dictionary>>> d = {'banana': 3,'apple': 4,'pear': 1,'orange': 2}>>> # dictionary sorted by key>>> OrderedDict(sorted(d.items(),key=lambda t: t[0]))OrderedDict([('apple',('banana',('orange',('pear',1)])>>> # dictionary sorted by value>>> OrderedDict(sorted(d.items(),key=lambda t: t[1]))OrderedDict([('pear',('apple',4)])>>> # dictionary sorted by length of the key string>>> OrderedDict(sorted(d.items(),key=lambda t: len(t[0])))OrderedDict([('pear',3)])

使用popitem(last=True)方法可以让我们按照liFO(先进后出)的顺序删除dict中的key-value，即删除最后一个插入的键值对，如果last=False就按照FIFO(先进先出)删除dict中key-value。

>>> d = {'banana': 3,'orange': 2}>>> # dictionary sorted by key>>> d = OrderedDict(sorted(d.items(),key=lambda t: t[0]))>>> dOrderedDict([('apple',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')>>> dOrderedDict([('a',None),('b',('c',('d',('e',None)])>>> d.move_to_end('b')>>> dOrderedDict([('a',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)。

>>> from collections import deque>>> dq = deque(range(10),maxlen=10)>>> dqdeque([0,1,2,3,4,5,6,7,8,9],maxlen=10)>>> dq.rotate(3)>>> dqdeque([7,9,6],maxlen=10)>>> dq.rotate(-4)>>> dqdeque([1,0],maxlen=10)>>> dq.appendleft(-1)>>> dqdeque([-1,maxlen=10)>>> dq.extend([11,22,33])>>> dqdeque([3,11,33],maxlen=10)>>> dq.extendleft([10,20,30,40])>>> dqdeque([40,10,8],maxlen=10)

Counter

Count用来统计相关元素的出现次数。

>>> from collections import Counter>>> ct = Counter('abracadabra')>>> ctCounter({'a': 5,'r': 2,'b': 2,'d': 1,'c': 1})>>> ct.update('aaaaazzz')>>> ctCounter({'a': 10,'z': 3,'c': 1})>>> ct.most_common(2)[('a',10),('z',3)]>>> ct.elements()<itertools.chain object at 0x7fbaad4b44e0>

namedtuple

使用namedtuple(typename,fIEld_names)命名tuple中的元素来使程序更具可读性。

>>> from collections import namedtuple>>> City = namedtuple('City','name country population coordinates')>>> tokyo = City('Tokyo','JP',36.933,(35.689722,139.691667))>>> tokyoCity(name='Tokyo',country='JP',population=36.933,coordinates=(35.689722,139.691667))>>> tokyo.population36.933>>> tokyo.coordinates(35.689722,139.691667)>>> tokyo[1]'JP'

>>> City._fIElds('name','country','population','coordinates')>>> LatLong = namedtuple('LatLong','lat long')>>> delhi_data = ('Delhi NCR','IN',21.935,LatLong(28.613889,77.208889))>>> delhi = City._make(delhi_data)>>> delhi._asdict()OrderedDict([('name','Delhi NCR'),('country','IN'),('population',21.935),('coordinates',LatLong(lat=28.613889,long=77.208889))])>>> for key,value in delhi._asdict().items():  print(key + ':',value)name: Delhi NCRcountry: INpopulation: 21.935coordinates: LatLong(lat=28.613889,long=77.208889)

ChainMap

ChainMap可以用来合并多个字典。

>>> from collections import ChainMap>>> d = ChainMap({'zebra': 'black'},{'elephant': 'blue'},{'lion': 'yellow'})>>> d['lion'] = 'orange'>>> d['snake'] = 'red'>>> dChainMap({'lion': 'orange','zebra': 'black','snake': 'red'},{'lion': 'yellow'})

>>> del d['lion']>>> del d['elephant']Traceback (most recent call last): file "/usr/lib/python3.5/collections/__init__.py",line 929,in __delitem__ del self.maps[0][key]KeyError: 'elephant'During handling of the above exception,another exception occurred:Traceback (most recent call last): file "<stdin>",line 1,in <module> file "/usr/lib/python3.5/collections/__init__.py",line 931,in __delitem__ raise KeyError('Key not found in the first mapPing: {!r}'.format(key))KeyError: "Key not found in the first mapPing: 'elephant'"

从上面del['elephant']的报错信息可以看出来，对于改变键值的 *** 作ChainMap只会在第一个字典self.maps[0][key]进行查找，新增加的键值对也都会加入第一个字典，我们来改进一下ChainMap解决这个问题：

class DeepChainMap(ChainMap): 'Variant of ChainMap that allows direct updates to inner scopes' def __setitem__(self,key,value):  for mapPing in self.maps:   if key in mapPing:    mapPing[key] = value    return  self.maps[0][key] = value def __delitem__(self,key):  for mapPing in self.maps:   if key in mapPing:    del mapPing[key]    return  raise KeyError(key)>>> d = DeepChainMap({'zebra': 'black'},{'lion': 'yellow'})>>> d['lion'] = 'orange'   # update an existing key two levels down>>> d['snake'] = 'red'   # new keys get added to the topmost dict>>> del d['elephant']   # remove an existing key one level downDeepChainMap({'zebra': 'black',{},{'lion': 'orange'})

可以使用new_child来deepcopy一个ChainMap：

>>> from collections import ChainMap>>> a = {'a': 'A','c': 'C'}>>> b = {'b': 'B','c': 'D'}>>> m = ChainMap({'a': 'A','c': 'C'},{'b': 'B','c': 'D'})>>> mChainMap({'a': 'A','c': 'D'})>>> m['c']'C'>>> m.maps[{'c': 'C','a': 'A'},{'c': 'D','b': 'B'}]>>> a['c'] = 'E'>>> m['c']'E'>>> mChainMap({'c': 'E','b': 'B'})

>>> m2 = m.new_child()>>> m2['c'] = 'f'>>> m2ChainMap({'c': 'f'},{'c': 'E','b': 'B'})>>> mChainMap({'c': 'E','b': 'B'})>>> m2.parentsChainMap({'c': 'E','b': 'B'})

UserDict

下面我们来改进一下字典，查询字典的时候将key转换为str的形式：

class StrKeyDict0(dict): def __missing__(self,key):  if isinstance(key,str):   raise KeyError(key)  return self[str(key)] def get(self,default=None):  try:   return self[key]  except KeyError:   return default def __contains__(self,key):  return key in self.keys() or str(key) in self.keys()

解释一下上面这段程序：

在__missing__中isinstance(key,str)是必须要的，请思考一下为什么？ 因为假设一个key不存在的话，这会造成infinite recursion，self[str(key)]会再次调用__getitem__。 __contains__也是必须实现的，因为k in d的时候会进行调用，但是注意即使查找失败它也不会调用__missing__。关于__contains__还有一个细节就是：我们并没有使用k in my_dict，因为str(key) in self的形式，因为这会造成递归调用__contains__。

这里还强调一点，在Python2.x中dict.keys()会返回一个List，这意味着k in my_List必须遍历List。在python3.x中针对dict.keys()做了优化，性能更高，它会返回一个vIEw如同set一样，详情参考官方文档。

上面这个例子可以用UserDict改写，并且将所有的key都以str的形式存储，而且这种写法更加常用简洁：

import collectionsclass StrKeyDict(collections.UserDict): def __missing__(self,str):   raise KeyError(key)  return self[str(key)] def __contains__(self,key):  return str(key) in self.data def __setitem__(self,item):  self.data[str(key)] = item

UserDict是MutableMapPing和MapPing的子类，它继承了MutableMapPing.update和MapPing.get两个重要的方法，所以上面我们并没有重写get方法，可以在源码中看到它的实现和我们上面的实现是差不多的。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对编程小技巧的支持。

总结

以上是内存溢出为你收集整理的Python标准库之collections包的使用教程全部内容，希望文章能够帮你解决Python标准库之collections包的使用教程所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。