6. python 查漏补缺，namedtuple 命名元组，双向队列 deque，Counter 计数器，可排序字典-蒲公英云

namedtuple 命名元组

在之前的学习过程中，咱们已经接触过命名元组相关知识，毕竟这个知识点可以极大的提高元组使用。

命名元组的函数原型如下：

namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)

下面依旧是对各个参数的说明：

typename：元组名称；
field_names：元组中元素名称，即元组字段的名称，可以是有空格分隔的字段名组成的字符串，也可以是有多个字符串组成的可迭代对象；
*：捕获参数占位符；
rename：设置为 True，会自动替换一些与 Python 关键字重名的字段；
module：设置 __module__ 属性值。

演示案例如下，创建一个命名元组，其中字段包括：姓名，性别，学号。

from collections import namedtuple
# Student = namedtuple("Student",["name sex sid"])
Student = namedtuple("Student", ["name", "sex", "sid"])
# 接下来就可以创建命名元组相关实例了
s1 = Student("橡皮擦", "女", 10086)
s2 = Student("菜鸡", "男", 10010)
# 直接索引形式访问数据
print(s1[0])
# 通过名称访问数据
print(s2.name)
# 直接输出对象，会输出 Student(name='橡皮擦', sex='女', sid=10086)
print(s1)

命名元组特殊的方法与属性

_make 从现有序列创建一个新的实例。

s_1_s = Student._make(s1)
print(id(s1)) # 查看内存地址
print(s_1_s)
print(id(s_1_s))

_asdict 返回 OrderedDict 对象。

s_1_as = Student._asdict(s1)
print(s_1_as) # OrderedDict([('name', '橡皮擦'), ('sex', '女'), ('sid', 10086)])
print(s1._asdict())

_replace 替换元组值。

s_1_r = Student._replace(s1, name="擦姐")
print(s_1_r) # Student(name='擦姐', sex='女', sid=10086)

_fields 获取字段名称。

s_1_f = Student._fields
print(s_1_f)

双向队列

在 collections 模块中，还存在一个 deque 容器，该容器可以从两端快速追加或者删除值，所以叫做双向队列（线程安全）。

deque 函数原型如下：

deque([iterable[, maxlen]]) --> deque object

其中两个参数都是可选参数：

iterable：可迭代对象，如果没有该值，默认创建一个空的 deque 对象；
maxlen：deque 对象的长度，默认值为 None。

deque 对象使用方式类似列表，常用的方法清单如下（部分与列表一致的方法，使用说明略）

append()：右侧追加元素；
appendleft()：左侧追加元素；
clear()：清空；
copy()：浅复制；
extend()：右侧扩展一个序列；
extendleft()：左侧扩展一个序列；
count()：计算某个元素出现的次数；
index()：检索位置，找不到就报错；
pop()：右侧末尾移除一个元素，并返回该值；
popleft()：左侧末尾移除一个元素，并返回该值；
reverse()：反转；
remove()：移除元素。

其余的一些可作用于可迭代对象的函数，也可用于 deque 队列，例如 len，reversed。

Counter 计数器

计数器与 Python 中的字典基本一致，对象中包括元素及该元素对应的数量，该值为整数值，可以为 0 和负值。

Counter 是一个类，官方注释中提供了使用规则：

1. c = Counter()                           # a new, empty counter
2. c = Counter('gallahad')                 # a new counter from an iterable
3. c = Counter({ 'a': 4, 'b': 2})           # a new counter from a mapping
4. c = Counter(a=4, b=2)                   # a new counter from keyword args

空计数器；
文本字符串映射，会统计每个字母出现的次数；
通过字典创建对象；
通过关键字参数创建对象。

在使用计数器的过程中，如果发现不存在的项，直接返回 0，代码如下：

from collections import Counter
c = Counter({ 'a': 4, 'b': 2})
print(c["c"]) # 0

使用对象的 elements() 方法，可以返回一个可迭代对象。

from collections import Counter
c = Counter({ 'a': 4, 'b': 2})
for item in c.elements():
    print(item)

该迭代循环将按照元素顺序依次打印数据。

most_common 方法，将返回元素列表，顺序按照元素出现的次数，从最多到最少排列。

from collections import Counter
c = Counter({ 'a': 4, 'b': 2, 'c': 5, "e": 2})
print(c.most_common()) # [('c', 5), ('a', 4), ('b', 2), ('e', 2)]

subtract 方法用于从现有计数器中，参照一个序列减去对应的值，代码如下：

c = Counter({ 'a': 4, 'b': 2, 'c': 5, "e": 2})
d = Counter({ 'a': 1, 'b': 2, 'c': 3, "e": 4})
c.subtract(d)  # c-d
print(c)

由于计数器是特殊的字典，即值是整数，故可以对计数器使用一些数学计算

from collections import Counter
c = Counter({ 'a': 4, 'b': 2, 'c': 5, "e": 2})
d = Counter({ 'a': 1, 'b': 2, 'c': 3, "e": 4})
t1 = c - d
print(t1)  # Counter({'a': 3, 'c': 2})
t2 = c + d
print(t2)  # Counter({'c': 8, 'e': 6, 'a': 5, 'b': 4})
t3 = c & d
print(t3) # Counter({'c': 3, 'b': 2, 'e': 2, 'a': 1}) 取两个值中的较小值
t4 = c | d
print(t4) # Counter({'c': 5, 'a': 4, 'e': 4, 'b': 2}) 取两个值中的较大值