介绍

collections 模块是 Python 标准库的一部分，提供了多种增强的数据类型，包括 namedtuple、deque、Counter、OrderedDict、defaultdict 和 ChainMap。

这些数据类型比内置类型更灵活高效，适用于特定场景。掌握和合理使用这些数据结构，你会发现日常开发效率会非常高。

常见数据结构

namedtuple

namedtuple 是 Python collections 模块中的一个工厂函数，用于创建具有命名字段的不可变序列。它提供了类似于元组的性能和内存效率，同时可以通过名称访问其元素，从而提高代码的可读性和可维护性。

下面通过一段关于操作 地理坐标（Geolocation） 的代码来详细说明：如何创建 namedtuple、访问其元素，以及 namedtuple 的方法和属性。

# 导入
from collections import namedtuple

# 定义 namedtuple 类型 Geo
Geo = namedtuple('Geo', ['latitude', 'longitude'])

# 创建几个 Geo 实例
a_geo = Geo(39.9042, 116.4074)
b_geo = Geo(31.2304, 121.4737)
c_geo = Geo(23.1291, 113.2644)

# 打印地理坐标
print(f"a_geo: {a_geo.latitude}, {a_geo.longitude}")  # 输出: a_geo: 39.9042, 116.4074
print(f"b_geo: {b_geo.latitude}, {b_geo.longitude}")  # 输出: b_geo: 31.2304, 121.4737
print(f"c_geo: {c_geo.latitude}, {c_geo.longitude}")  # 输出: c_geo: 23.1291, 113.2644

# 使用 _make() 方法创建实例
data = [22.5431, 114.0579]
d_geo = Geo._make(data)
print(f"d_geo: {d_geo.latitude}, {d_geo.longitude}")  # 输出: d_geo: 22.5431, 114.0579

# 使用 _asdict() 方法将 namedtuple 转换为字典
a_dict = a_geo._asdict()
print(a_dict)  # 输出: OrderedDict([('latitude', 39.9042), ('longitude', 116.4074)])

# 使用 _replace() 方法更新实例
updated_a = a_geo._replace(latitude=39.913818)
print(updated_a)  # 输出: Geo(latitude=39.913818, longitude=116.4074)

# 查看字段名称
print(Geo._fields)  # 输出: ('latitude', 'longitude')

应用场景

• 数据记录：用于表示数据库查询结果或日志记录。
• 配置项：用于保存配置信息，例如服务器配置或应用程序设置。
• 数据传输：用于定义消息格式，方便序列化和传输数据。

deque

deque 是一个双端队列，它支持从两端进行高效的添加和删除操作。

基本使用

deque 支持从两端进行快速的添加和删除操作。

from collections import deque

# 创建一个空的 deque
my_deque = deque()

# 创建包含元素的 deque
my_deque_with_data = deque([1, 2, 3, 4, 5])

# 添加元素到 deque 的右端
my_deque.append(6)

# 添加元素到 deque 的左端
my_deque.appendleft(0)

# 从 deque 的右端删除元素
right_element = my_deque.pop()

# 从 deque 的左端删除元素
left_element = my_deque.popleft()

deque 的方法和属性

• append(item): 将元素添加到 deque 的右端。
• appendleft(item): 将元素添加到 deque 的左端。
• pop(): 从 deque 的右端删除并返回一个元素。
• popleft(): 从 deque 的左端删除并返回一个元素。
• extend(iterable): 将可迭代对象中的元素添加到 deque 的右端。
• extendleft(iterable): 将可迭代对象中的元素添加到 deque 的左端。
• rotate(n): 将 deque 向右循环移动 n 步（如果 n 是负数，则向左移动）。
• clear(): 清空 deque 中的所有元素。
• count(item): 返回 deque 中等于 item 的元素个数。
• reverse(): 将 deque 中的元素逆序排列。
• copy(): 返回 deque 的浅拷贝。

我们来用这些方法实现一个基于LRU策略(最近最少使用)的缓存类来慢慢感受下deque的高级玩法：

from collections import deque

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = deque(maxlen=capacity)  # 使用 deque 作为缓存
        self.cache_map = {}  # 用于存储键值对的映射关系

    def get(self, key):
        if key in self.cache_map:
            # 如果键存在于缓存中，则将其移到缓存队列的右端（最近使用）
            self.cache.remove(key)
            self.cache.append(key)
            return self.cache_map[key]
        else:
            return -1

    def put(self, key, value):
        if key in self.cache_map:
            # 如果键已存在于缓存中，则更新值并将其移到缓存队列的右端（最近使用）
            self.cache.remove(key)
            self.cache.append(key)
            self.cache_map[key] = value
        else:
            if len(self.cache) == self.capacity:
                # 如果缓存已满，则移除最左端（最久未使用）的键值对
                removed_key = self.cache.popleft()
                del self.cache_map[removed_key]
            # 将新的键值对添加到缓存队列的右端（最近使用）
            self.cache.append(key)
            self.cache_map[key] = value

    def clear(self):
        # 清空缓存队列和映射关系
        self.cache.clear()
        self.cache_map.clear()

    def extend(self, iterable):
        # 将可迭代对象中的元素添加到缓存队列的右端（最近使用）
        self.cache.extend(iterable)

    def __repr__(self):
        return str(self.cache)

    
# 测试示例
cache = LRUCache(3)
cache.put(1, 'a')
cache.put(2, 'b')
cache.put(3, 'c')
print(cache)  # 输出: deque([1, 2, 3], maxlen=3)

cache.put(4, 'd')
print(cache)  
# 输出: deque([2, 3, 4], maxlen=3)
# 因为元素超过了3个，所以淘汰了元素 1，添加保留了元素 4

cache.clear()
print(cache)  # 输出: deque([], maxlen=3)

cache.extend([4, 5, 6])
print(cache)  # 输出: deque([4, 5, 6], maxlen=3)

应用场景

• 队列和栈：用于实现队列（FIFO）和栈（LIFO）等数据结构。
• 缓存：用于实现LRU（Least Recently Used）缓存算法，保留最近访问的元素，丢弃最旧的元素。
• 任务调度：用于实现异步任务调度器，管理任务队列并支持快速的入队和出队操作。

Counter

常用于计数可哈希对象。

基本使用

from collections import Counter

# 创建一个 Counter 对象
my_counter = Counter([1, 1, 2, 3, 3, 3, 4, 4, 5])
# 获取元素的计数
count_of_3 = my_counter[3]  # 输出: 3

# 更新计数
my_counter[3] += 1

# 添加新元素
my_counter[6] = 1

方法和属性

• elements(): 返回一个迭代器，包含 Counter 对象中的所有元素，重复次数与计数相等。
• most_common(n): 返回前 n 个最常见的元素及其计数，以列表形式返回。
• subtract(iterable): 从 Counter 对象中减去可迭代对象中的元素的计数。
• update(iterable): 将可迭代对象中的元素添加到 Counter 对象中。
• clear(): 清空 Counter 对象中的所有元素。
• copy(): 返回 Counter 对象的浅拷贝。
• items(): 返回 Counter 对象的键值对。
• keys(): 返回 Counter 对象的键。
• values(): 返回 Counter 对象的值。
• most_common(n): 返回前 n 个最常见的元素及其计数。

你会发现Counter有部分类似dict字段的方法，这是因为Counter类继承了dict类

通过实现一个打工人出生地的统计计数器来感受下Counter类的使用：

from collections import Counter

# 模拟一堆大学生的出生地数据
birthplaces = ['Beijing', 'Shanghai', 'Guangzhou', 'Beijing', 'Shanghai']
# 创建 Counter 对象统计出生地
birthplace_counter = Counter(birthplaces)
# 获取出生地为上海的学生人数
shanghai_students = birthplace_counter['Shanghai']
# 更新计数，添加更多学生的出生地数据
more_birthplaces = ['Beijing', 'Shanghai', 'Chongqing', 'Shanghai', 'Shenzhen']
birthplace_counter.update(more_birthplaces)
# 获取出生地为北京的学生人数
beijing_students = birthplace_counter['Beijing']
# 统计有哪些地区
uniq_birthplaces = list(birthplace_counter.keys())
# 获取计数最多的 2 个出生地及其计数
top_birthplaces = birthplace_counter.most_common(2)
# 从统计中减去一部分出生地数据
subtract_birthplaces = ['Beijing', 'Shanghai']
birthplace_counter.subtract(subtract_birthplaces)
# 获取计数最少的 1 个出生地及其计数
bottom_birthplace = birthplace_counter.most_common()[-1]
# 清空计数器
birthplace_counter.clear()

# 输出结果
print("出生地为上海的学生人数:", shanghai_students)  # 出生地为上海的学生人数: 2
print("出生地为北京的学生人数:", beijing_students)  # 出生地为北京的学生人数: 3
print("有哪些出生地:", uniq_birthplaces)
# 有哪些出生地: ['Beijing', 'Shanghai', 'Guangzhou', 'Chongqing', 'Shenzhen']
print("计数最多的 2 个出生地:", top_birthplaces)  
# 计数最多的 2 个出生地: [('Shanghai', 4), ('Beijing', 3)]
print("计数最少的 1 个出生地:", bottom_birthplace)  # 计数最少的 1 个出生地: ('Shenzhen', 1)
print("清空后的计数器:", birthplace_counter)  # 清空后的计数器: Counter()

应用场景

• 文本处理：用于统计单词出现次数或字符出现次数。
• 数据分析：用于统计数据集中各个元素的出现频率。
• 词频统计：用于生成词云、绘制频率分布图等。

OrderedDict

OrderedDict 是一个有序字典，它可以记住元素的添加顺序。虽然 Python3.7 以后版本的dict也改成了有序字典，但基于可读性和兼容性，依然使用推荐OrderedDict。

基本使用

from collections import OrderedDict

# 创建一个空的 OrderedDict
empty_ordered_dict = OrderedDict()
# 创建包含键值对的 OrderedDict
ordered_dict = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
# 添加键值对到 OrderedDict
ordered_dict['d'] = 4
# 删除键值对
del ordered_dict['a']
# 获取键对应的值
value_of_b = ordered_dict['b']

OrderedDict 的方法和属性

• move_to_end(key, last=True): 将指定键移动到有序字典的最后或最开始，默认移到最后。
• popitem(last=True): 弹出有序字典中的最后一个键值对或第一个键值对，默认弹出最后一个。
• clear(): 清空有序字典中的所有键值对。
• copy(): 返回有序字典的浅拷贝。
• keys(): 返回有序字典中的所有键。
• values(): 返回有序字典中的所有值。
• items(): 返回有序字典中的所有键值对。

OrderedDict和Counter一样，也是继承了dict一样

应用场景

• 配置文件：用于保存配置信息，并保持配置项的顺序与文件中的顺序一致。
• 历史记录：用于记录用户操作历史，并保持操作的顺序。
• 命令行参数：用于保存命令行参数，并保持参数的顺序与输入顺序一致。

defaultdict

defaultdict 是一种字典的子类，它允许给每个键一个默认值，从而避免了在访问不存在的键时引发 KeyError 异常，这在实际开发中非常有用

基本使用

from collections import defaultdict

# 创建一个默认字典，指定默认值为 int 类型的 0
default_dict = defaultdict(int)
# 添加键值对到 defaultdict
default_dict['a'] = 1
# 获取键对应的值，如果键不存在，则返回默认值, int 默认返回0
value_of_b = default_dict['b']
print(value_of_b)  # 输出：0
# 删除键值对
# 当然删除不存在的键值对还是会触发 KeyError 的
del default_dict['a']

# 创建一个默认字典，指定默认值为 list 类型的空列表
default_dict_list = defaultdict(list)
print(default_dict_list["a"])  # 输出：[]

defaultdict 的方法和属性

• default_factory: 默认工厂函数，用于生成默认值。
• copy(): 返回 defaultdict 对象的浅拷贝。
• keys(): 返回 defaultdict 对象中的所有键。
• values(): 返回 defaultdict 对象中的所有值。
• items(): 返回 defaultdict 对象中的所有键值对。

defaultdict也是继承了dict，所以很多方法都很类似，区别在于defaultdict允许给每个键一个默认值

重点说说defualtdict中的default_factory:

default_factory除了设置为某种类型（如 int、list 等）外，还可以将其设置为函数，以便在需要时动态生成默认值（任何对象：数值、字符串、类实例等），从而实现更灵活的功能。

下面则是使用这种方法构造默认采集配置：

from collections import defaultdict


# 定义默认的爬虫配置参数
def default_config():
    return {
        'user_agent': 'Mozilla/5.0 ***',
        'timeout': 10,
        'retry': 3,
        'headers': {'Accept': 'text/html,application/json'},
        'proxies': None
    }

# 创建一个 defaultdict，并指定默认值的生成函数为 default_config
crawler_config = defaultdict(default_config)

print(crawler_config["baidu"]["timeout"])  # 输出：10
print(crawler_config["weixin"]["timeout"])  # 输出：10

应用场景

• 计数器初始化：用于创建计数器字典，并设置默认计数值为0。
• 数据分组：用于分组数据集，并将缺失的组初始化为空列表或其他默认值。
• 统计分析：用于统计数据集中各类别的频率，并将缺失的类别初始化为0。

ChainMap

用于将多个字典或映射组合在一起形成单个视图，适用于需要处理多个映射的情况。

方法与属性

• new_child(m=None): 创建一个新的 ChainMap 对象，将参数 m（字典或映射）添加到链的开头。
• parents: 返回一个包含所有父映射的新 ChainMap 对象。
• maps: 返回一个包含所有映射的列表。
• copy(): 返回 ChainMap 对象的浅拷贝。

用法

下面举个配置合并的例子来说明下用法：

from collections import ChainMap

# 定义三个模块的配置信息
module1_config = {'timeout': 10, 'retry': 3}
module2_config = {'user_agent': 'Mozilla/5.0', 'proxies': 1}
module3_config = {'headers': {'Accept': 'text/html'}}

# 使用 ChainMap 合并多个模块的配置
combined_config = ChainMap(module1_config, module2_config, module3_config)

# 获取所有映射
print("所有映射:")
print(combined_config.maps)

# 获取父映射（去除最后一个映射）
parent_maps = combined_config.parents
print("\n父映射:")
for parent_map in parent_maps:
    print(parent_map)

# 获取指定键的值
print("\n获取指定键的值:")
print("timeout:", combined_config['timeout'])
print("user_agent:", combined_config['user_agent'])

# 添加新的映射
new_module_config = {'timeout': 20, 'retry': 5}
combined_config = combined_config.new_child(new_module_config)
print("\n添加新的映射后的配置信息:")
print(combined_config)

print(combined_config['proxies'])

应用场景

• 配置管理：用于合并多个配置源（如全局配置、用户配置、默认配置）并提供统一的配置视图。
• 命名空间：用于将多个命名空间（如全局命名空间、模块命名空间、局部命名空间）组合在一起，形成单个命名空间。
• 上下文管理器：用于管理多个上下文，并提供统一的上下文视图，使得上下文的嵌套和覆盖更加灵活。

使用优势

• 更具表达性：collections中的数据结构通常比内置的数据结构更具表达性，能够更清晰地表达程序的意图，代码也会简单很多。
• 更高级的功能：collections中的数据结构提供了一些额外的功能，这些功能在特定的使用场景下非常有用。
• 性能优势：在某些特定的操作中，collections中的数据结构可能比内置数据结构性能更好。
• 可扩展性：如果你的程序需要更多的功能，collections模块提供了一些非常有用的数据结构，可以满足更广泛的需求。
• 标准化：使用collections中的数据结构能够让你的代码更加标准化和易于理解。

如果你觉得本文有帮助到你，非常期待得到你的支持和鼓励；
如果有其他问题或补充，欢迎评论区留言交流。