Python中的基本数据结构有list，dict，tuple，set。

Collections 库在其基础上提供了几种高级数据类型，作为Python标准内建容器 dict , list , set , 和 tuple 的替代选择。如：

1. deque 双端队列

deque本质上实现了数据结构中队列的升级版，双端队列可以高效的实现插入和删除的双向列表，适用于队列和栈。

deque 是为了向list中删除和插入的效率更高，用法与list相似，而list自带的append和pop方法(尾部插入和删除)速度慢。

双端队列支持线程安全，在双端队列的任何一端执行添加和删除操作，它们的内存效率几乎相同（时间复杂度为O(1)）。

from collections import deque

q = deque([])

#在最右边添加一个元素，此时 q=deque('a')
q.append('a') 

#在最左边添加一个元素，此时 q=deque(['b', 'a'])
q.appendleft('b') 

#在最右边添加所有元素，此时 q=deque(['b', 'a', 'c', 'd'])
q.extend(['c','d']) 

#在最左边添加所有元素，此时 q=deque(['f', 'e', 'b', 'a', 'c', 'd'])
q.extendleft(['e','f'])

#将最右边的元素取出，返回 'd'，此时 q=deque(['f', 'e', 'b', 'a', 'c'])
q.pop() 

#将最左边的元素取出，返回 'f'，此时 q=deque(['e', 'b', 'a', 'c'])
q.popleft() 

#向左旋转两个位置(正数则向右旋转)，此时 q=deque(['a', 'c', 'e', 'b'])
q.rotate(-2)

#统计队列中'a'的个数，此时返回 1
q.count('a') 

#从队列中将'c'删除，此时 q=deque(['a', 'e', 'b'])
q.remove('c') 

#将队列倒序，此时 q=deque(['b', 'e', 'a'])
q.reverse() 

2. ChainMap

ChainMap 可以合并多个dict，而且效率很高。

from collections import ChainMap

a = {'a': 4, 'c': 2}
b = {'b': 3, 'c': 1}
c=ChainMap(a,b)
print(c)
#ChainMap({'a': 4, 'c': 2}, {'b': 3, 'c': 1})

#将c变成一个list
c_list = c.maps
print(c_list)
#[{'a': 4, 'c': 2}, {'b': 3, 'c': 1}]

ChainMap 是为了将多个映射快速的链接到一起，这样它们就可以作为一个单元处理。它通常比创建一个新字典和多次调用 update() 要快很多，因为这么做的话要新建一个数据结构，这样的话对空间和时间上的浪费都是不小得。

[1] - 可以用来合并两个或者更多个字典，当查询的时候，从前往后依次查询，若该多个字典当中有相同的key时，只会显示第一个字典相对应的value

[2] - 当对ChainMap进行修改的时候总是只会对第一个字典进行修改

[3] - new_child()方法实质上是在列表的第一个元素前放入一个字典，默认是{}，而parents是去掉了列表开头的元素

3. Counter计数器

Counter是对字典类型的补充，用于追踪value出现的次数，其继承于字典，用于计数可哈希的对象，计数的数值可以是正整数、负整数和零。

from collections import Counter

#统计元素出现个数
cnt=Counter()
for w in ['a','b','a','a','a','r','b']:
  cnt[w]+=1
print(cnt)
#Counter({'a': 4, 'b': 2, 'r': 1})

#统计字符串出现的次数
cnt = Counter()
for ch in 'helloworld':
  cnt[ch] = cnt[ch] + 1
print(cnt)
#Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, 'w': 1, 'r': 1, 'd': 1})

#返回Counter对象中出现最多前n个元素，list
c = Counter('abracadabra')
print(c)
#Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})
print(c.most_common(3))
#[('a', 5), ('b', 2), ('r', 2)]

#elements()方法按照元素的出现次数返回一个iterator(迭代器)
print(sorted(c.elements()))
#['a', 'a', 'a', 'a', 'a', 'b', 'b', 'c', 'd', 'r', 'r']

4. OrdereDict有序字典

字典dict是无序的，OrdereDict是有序的dict。

from collections import OrderedDict

d ={'b':3,'a':4,'c':2,'d':1}
#将d按照key来排序
sort_dk = OrderedDict(sorted(d.items(),key=lambda t:t[0]))
print(sort_d)
#OrderedDict([('a', 4), ('b', 3), ('c', 2), ('d', 1)])
'''
sorted(iterable,key,reverse)
其中,
iterable表示可以迭代的对象，如dict.items()、dict.keys()等
key是一个函数，用来选取参与比较的元素，
reverse是用来指定排序是倒序还是顺序，默认时reverse=false(顺序)，若reverse=true则是倒序.
'''

#将d按照value来排序
sort_dv = OrderedDict(sorted(d.items(),key=lambda t:t[1]))
print(sort_dv)
#OrderedDict([('d', 1), ('c', 2), ('b', 3), ('a', 4)])

#将d按照key的长度来排序
sort_dl = OrderedDict(sorted(d.items(),key=lambda t:len(t[0])))
print(sort_dl)
#OrderedDict([('b', 3), ('a', 4), ('c', 2), ('d', 1)])

#
d.popitem()
#('d',1)

#改变有序的OrderedDict对象的key-value顺序
d = OrderedDict.fromkeys('abcde')
print(d)
#OrderedDict([('a', None), ('b', None), ('c', None), ('d', None), ('e', None)])

#将key为c的key-value移动到最后
d.move_to_end('c')
print(d)
#OrderedDict([('a', None), ('b', None), ('d', None), ('e', None), ('c', None)])

#将key为c的key-value移动到最前面
d.move_to_end('c',last=False)
print(d)
#OrderedDict([('c', None), ('a', None), ('b', None), ('d', None), ('e', None)])
print(''.join(d.keys()))
#cabde

5. defaultdict 默认字典

defaultdict在字典dict的基础之上添加一个参数default_factory(default_factory可以指定为list，set，int).

from collections import defaultdict

l=[('a',2),('b',3),('a',1),('b',4),('a',3),('a',1),('b',3)]
#list转dict，其中key对应的value是一个list，defaultdict(list)
d=defaultdict(list)
for key,value in l:
  d[key].append(value)
print(d)
#defaultdict(<class 'list'>, {'a': [2, 1, 3, 1], 'b': [3, 4, 3]})

#list转dict，value去重，defaultdict(set)
d = defaultdict(set) #set与list不同之处就是set中不允许存在相同的元素
for key,value in l:
  d[key].add(value)
print(d)
#defaultdict(<class 'set'>, {'a': {1, 2, 3}, 'b': {3, 4}})

#统计一个字符串中每个字符出现的次数，defaultdict(int)
s='hello world'
d=defaultdict(int)
for key in s:
  d[key]+=1
print(d)
#defaultdict(<class 'int'>, {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

6. namedtuple

命名 tuple 中的元素，使用namedtuple(typename,field_names).

from collections import namedtuple

nm=namedtuple('helloworld',['x','y'])
#namedtuple('名称', [属性list]):

n=nm(1,2)
print(n.__class__.__name__)
#'helloworld'

print(n.x)
print(n.y)