Python高阶：counter、orderedDict、defaultdict、deque、queue简单示例

简介：python除了提供的内置数据类型（int、float、str、list、tuple、dict）外，collections模块还提供了其他数据类型，collections模块实现一些特定的数据类型，可以替代Python中常用的内置数据类型如dict, list, set, tuple，简单说就是对基本数据类型做了更上一层的处理。

主要类型：本模块只选deque、Counter、OrderedDict、defaultdict介绍。

namedtuple()：用于创建具有命名字段的元组子类的工厂函数
deque：       列表式容器，两端有快速的附件和弹出窗口
Counter：用于计算散列对象的dict子类
OrderedDict：dict子类，用于记住添加的订单条目
defaultdict：调用工厂函数以提供缺少值的dict子类
UserDict：围绕字典对象进行包装，以简化dict子类化
UserList：围绕列表对象进行包装，以简化列表子类化
UserString： 围绕字符串对象进行包装，以简化字符串子类化

使用前需要先导入：

import collections

1、计数器（Counter）：统计元素的个数，并以字典形式返回，如：{元素：元素的个数}，如果次数一致，则按ascii码从小到大排。

Counter中常用的方法：

most_common(self, n=None),
elements(self)
update(*args, **kwds)
subtract(*args, **kwds)
copy(self)

简单示例：

import collections

data = "message"
result = collections.Counter(data)

# 统计元素和元素对应个数
print(result)  # Counter({'e': 2, 's': 2, 'm': 1, 'a': 1, 'g': 1})

# most_common
# 按照元素个数的次数排序展示，默认不填则取全部
print(result.most_common())

# 按照元素个数的次数排序展示，取最多的前三个。
print(result.most_common(3))  # [('e', 2), ('s', 2), ('m', 1)]

# elements：迭代元素，重复每个元素的次数与其计数相同
print(sorted(collections.Counter("ABCABC").elements()))  # ['A', 'A', 'B', 'B', 'C', 'C']

# update：增加元素的重复次数
data1 = "abc"
c1 = collections.Counter(data1)
c1.update("ab")
print(c1)  # Counter({'a': 1, 'b': 1, 'c': 1}) + Counter({'a': 1, 'b': 1}) = Counter({'a': 2, 'b': 2, 'c': 1})

# subtract：减少元素重复次数
data2 = "abc"
c2 = collections.Counter(data2)
c2.subtract("ab")
print(c2)  # Counter({'a': 1, 'b': 1, 'c': 1}) - Counter({'a': 1, 'b': 1}) = Counter({'c': 1, 'a': 0, 'b': 0})

2、有序字典（orderedDict）：有序字典也是字典的一个子类，OrderedDict在迭代操作的时候会保持元素被插入时的顺序，OrderedDict内部维护着一个根据键插入顺序排序的双向链表。每次当一个新的元素插入进来的时候，它会被放到链表的尾部。对于一个已经存在的键的重复赋值不会改变键的顺序。需要注意的是，一个OrderedDict的大小是一个普通字典的两倍，因为它内部维护着另外一个链表。

orderedDict中常用的方法：

clear：清空字典
popitem：有序删除，类似于栈，按照后进先出的顺序依次删除
pop：删除指定键值对
move_to_end：将指定键值对移到最后位置
setdefault：设置默认值，默认为None，也可指定值
update：更新字典，有则更新，无则添加

简单示例：

import collections

dict1 = collections.OrderedDict({"name": "Tom", "age": 25, "address": "CN"})
print(dict1)  # OrderedDict([('name', 'tom'), ('age', 25), ('address', 'HK')])

# 有序遍历  name:Tom age:25 address:CN
for k, v in dict1.items():
    print("{k}:{v}".format(k=k, v=v), end=" ")

print()
# clear：清空字典
dict1.clear()
print(dict1)  # OrderedDict()

# popitem：有序删除，类似于栈，按照后进先出的顺序依次删除
dict2 = collections.OrderedDict({"name": "Jo", "age": 26, "address": "HK"})
print(dict2.popitem())  # ('address', 'HK')

# pop：删除指定键值对
dict3 = collections.OrderedDict({"name": "David", "age": 27, "address": "JP"})
print(dict3.pop("age"))  # 27

# move_to_end：将指定键值对移到最后位置
dict4 = collections.OrderedDict({"name": "LiLei", "age": 28, "address": "UK"})
dict4.move_to_end("name")
print(dict4)  # OrderedDict([('age', 28), ('address', 'UK'), ('name', 'LiLei')])

# setdefault：设置默认值，默认为None，也可指定值
dict5 = collections.OrderedDict({"name": "HanMeiMei", "age": 29, "address": "US"})
dict5.setdefault("sex", "Man")
print(dict5["sex"])  # Man

# update：更新字典，有则更新，无则添加，与父类字典使用一致，不在赘述。

3、默认字典(defaultdict)：字典中的键映射多个值，带有默认值的字典。

简单示例：

from collections import defaultdict

d1 = defaultdict(list)
d1['a'].append([1, 2, 3])
d1['b'].append(4)
d1['c'].append(5)
print(d1)  # defaultdict(<class 'list'>, {'a': [[1, 2, 3]], 'b': [2], 'c': [3]})

d2 = defaultdict(set)
d2['a'].add(6)
d2['a'].add(7)
d2['b'].add(8)
print(d2)  # defaultdict(<class 'set'>, {'a': {6, 7}, 'b': {8}})

4、双向队列（deque）：类似于list，允许两端操作元素

deque中特有的常用的方法：其他list操作如：pop，index，count忽略

appendleft：从队列左侧添加元素
extendleft：从队列左侧扩展
popleft：从队列左侧移除值

rotate：
移动队列中的元素，若n<0，则将队列最左侧的元素依次移动至最右侧，
反之，n>0，将队列最右侧元素移动至最左侧

简单示例：

from collections import deque

# 创建队列
deq1 = deque("abc")
print(deq1)  # deque(['a', 'b', 'c'])

# appendleft：从队列左侧添加元素
deq2 = deque("abc")
deq2.appendleft("d")
print(deq2)  # deque(['d', 'a', 'b', 'c'])

# extendleft：从队列左侧扩展
deq3 = deque("abc")
deq3.extendleft(["d", "e"])
print(deq3)  # deque(['e', 'd', 'a', 'b', 'c'])

# popleft：从队列左侧移除值
deq4 = deque("abc")
deq4.popleft()
print(deq4)  # deque(['b', 'c'])


# rotate：
# 移动队列中的元素，若 n < 0，则将队列最左侧的元素依次移动至最右侧，
# 反之，n > 0，将队列最右侧元素移动至最左侧

# n < 0
deq5 = deque("abcd")
deq5.rotate(-1)
print(deq5)  # deque(['b', 'c', 'd', 'a'])

# n > 0
deq6 = deque("abcd")
deq6.rotate(1)
print(deq6)  # deque(['d', 'a', 'b', 'c'])

单项队列queue：双向队列存在于collections模块中，允许对元素两端进行操作，而单项队列存在于queue模块中，遵循先进先出原则，只能一端进，一端出。

主要常用方法：

empty：判断队列是否为空，是返回True
full：判断队列是否已满，是返回True
put：往队列中放一个元素
get：依据先进先出原则，依次从队列取元素
put_nowait：无阻塞的向队列中添加元素，若队列已满，不等待直接报错（full）
get_nowait：无阻塞从队列中获取元素，若队列为空，不等待直接报错（empty）
qsize：表示队列长度，即元素个数
join：阻塞调用线程，直到队列中的所有任务都被处理完成，与task_done配合使用

简单示例：

import queue

que = queue.Queue(2)  # 创建队列，表示队列的长度
print(que)

print("init_full:", que.full())  # init_full: False

# 清空队列，并且判断队列是否为空，是返回True
print("init_empty:", que.empty())  # init_empty: True

que.put('A')  # 向队列中添加元素
que.put('B')
# que.put('C')  # 此时如果继续添加元素会造成堵塞等待

# 判断队列是否已满，是返回True
print("2ed_full:", que.full())  # 2ed_full: True

print(que.get())  # A
print(que.qsize())  # 表示队列长度，即元素个数: 取出一个后，只剩B，即：长度1

微信公众号：玩转测试开发
欢迎关注，共同进步，谢谢！