python collections模块中的Counter、OrderedDict、namedtuple、ChainMap、deque

1. collections中的Counter模块

Counter是字典的子类，负责计数的一个字典，支持 加法 、 减法 以及求并集

1. 常见的输出：

from collections import Counter

str = Counter("aaabcccdeff")
print("Counter计数：", str)
print("Counter的item项：", str.items())
print("数量最多的前3个元素：", str.most_common(3))
print("字符c的个数：", str['c'])
print("输出字典的value列表", str.values())
print("输出总字符数", sum(str.values()))
print("将字典中的数据，按字典序排序", sorted(str.elements()))

结果为：

Counter计数： Counter({'a': 3, 'c': 3, 'f': 2, 'b': 1, 'd': 1, 'e': 1})
Counter的item项： dict_items([('a', 3), ('b', 1), ('c', 3), ('d', 1), ('e', 1), ('f', 2)])
数量最多的前3个元素： [('a', 3), ('c', 3), ('f', 2)]
字符c的个数： 3
输出字典的value列表 dict_values([3, 1, 3, 1, 1, 2])
输出总字符数 11
将字典中的数据，按字典序排序 ['a', 'a', 'a', 'b', 'c', 'c', 'c', 'd', 'e', 'f', 'f']

拓展练习： leetcode–137–只出现一次的数字 II

类型转化及访问：Python3中dict.keys()和dict_values转换成list类型及访问操作

2. 删除元素操作

str1 = Counter("ccceehhgss")
del str1['h']
print("利用del删除元素：", str)  # 一次可全部删除

str2 = Counter("ccceehhgss")
str2.subtract('h')
print("通过subtract函数删除元素：", str2)  # 一次只能删除1个

结果为：

利用del删除元素: <class 'str'>
通过subtract函数删除元素: Counter({'c': 3, 'e': 2, 's': 2, 'h': 1, 'g': 1})

3. 添加新的元素

str3 = Counter("ccceehhgss")
str3.update('a')
print("通过update添加新的元素：", str3)

通过update添加新的元素: Counter({'c': 3, 'e': 2, 'h': 2, 's': 2, 'g': 1, 'a': 1})

2. collections 中的 OrderedDict 模块

OrderedDict类型是一个有序的字典，比普通字典多了一个顺序

from collections import OrderedDict
dic = {}
dic['a'] = 'A'
dic['b'] = 'B'
dic['c'] = 'C'
odic = OrderedDict()
odic['a'] = 'A'
odic['b'] = 'B'
odic['c'] = 'C'
print('无序字典：', dic)
print('有序字典：', odic)

结果为：

无序字典： {'a': 'A', 'b': 'B', 'c': 'C'}
有序字典： OrderedDict([('a', 'A'), ('b', 'B'), ('c', 'C')])

3. collections 中的 namedtuple 模块

namedtup类型，一个类似于字典的元组，可以转化为字典

from collections import namedtuple

L = namedtuple('Li', ['x', 'y'])
i = L(x=1, y=2)
print('i的值为：', i)
print('将两个值相加：', i[0]+i[1])
print('用属性的方式相加：', i.x+i.y)
m, n = i
print('类似元组的赋值：', m, n)
d = i._asdict()
print('转化为一个字典：', d)

4. collections 中的 ChainMap 模块

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

from collections import ChainMap
L1 = {'a': 4, 'c': 2}
L2 = {'b': 3, 'c': 1}
L = ChainMap(L1, L2)
print(L)

5. collections 中的 deque模块

来源于：HappyRocking
collections 是 python 内建的一个集合模块，里面封装了许多集合类，其中队列相关的集合只有一个：deque。
deque 是双边队列（double-ended queue），具有队列和栈的性质，在 list 的基础上增加了移动、旋转和增删等。

常用方法

d = collections.deque([])
d.append('a') # 在最右边添加一个元素，此时 d=deque('a')
d.appendleft('b') # 在最左边添加一个元素，此时 d=deque(['b', 'a'])
d.extend(['c','d']) # 在最右边添加所有元素，此时 d=deque(['b', 'a', 'c', 'd'])
d.extendleft(['e','f']) # 在最左边添加所有元素，此时 d=deque(['f', 'e', 'b', 'a', 'c', 'd'])
d.pop() # 将最右边的元素取出，返回 'd'，此时 d=deque(['f', 'e', 'b', 'a', 'c'])
d.popleft() # 将最左边的元素取出，返回 'f'，此时 d=deque(['e', 'b', 'a', 'c'])
d.rotate(-2) # 向左旋转两个位置（正数则向右旋转），此时 d=deque(['a', 'c', 'e', 'b'])
d.count('a') # 队列中'a'的个数，返回 1
d.remove('c') # 从队列中将'c'删除，此时 d=deque(['a', 'e', 'b'])
d.reverse() # 将队列倒序，此时 d=deque(['b', 'e', 'a'])

应用

1.可以使用 deque 的旋转来制作跑马灯：

import collections
import sys
import time

def marquee(length=50, speed=1, direction=1):
    """
    生成一个简单的跑马灯
    length:总长
    speed：每0.1秒的移动速度
    direction:0为向左，1为向右
    """
    if direction == 1:
        array = '>'
    else:
        array = '<'
    que = collections.deque([array])
    que.extend(['-'] * (length - 1)) # 形如'>------'
    while True:
        print('%s' % ''.join(que))
        if direction == 1:
            que.rotate(1 * speed)
        else:
            que.rotate(-1 * speed)
        sys.stdout.flush()
        time.sleep(0.1)

if '__main__' == __name__:
    marquee()

2.可以使用deque的旋转来解决约瑟夫问题：

""" 约瑟夫算法
据说著名犹太历史学家 Josephus 有过以下的故事：
在罗马人占领桥塔帕特后，39个犹太人与 Josephus 及他的朋友躲到一个洞中，
39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，
由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，
直到所有人都自杀身亡为止。然而 Josephus 和他的朋友并不想自杀，
问他俩安排的哪两个位置可以逃过这场死亡游戏？
"""
import collections
def ysf(a, b):
    d = collections.deque(range(1, a+1)) # 将每个人依次编号，放入到队列中
    while d:
        d.rotate(-b) # 队列向左旋转b步
        print(d.pop()) # 将最右边的删除，即自杀的人

if __name__ == '__main__':
    ysf(41,3) # 输出的是自杀的顺序。最后两个是16和31，说明这两个位置可以保证他俩的安全。