02-Python字典与集合：解锁高效数据处理的关键，90%的人没吃透这几点
Python字典与集合：解锁高效数据处理的关键，90%的人没吃透这几点
在Python数据结构家族中，字典（dict）和集合（set）是隐藏的“性能王者”。相比于列表和元组，它们在查找、添加、删除操作上的效率呈指数级提升，尤其在处理大量数据时优势明显。今天，我们就从基础定义、核心特性、创建方式到性能优势，全方位拆解这两种数据结构，帮你搞懂它们的底层逻辑与适用场景。
一、先明确概念：字典和集合是什么？
字典和集合虽同属“高效数据结构”阵营，但定位截然不同，核心区别在于是否存储“键值对”：
1. 字典（dict）：键值对的有序集合
字典是键（key）和值（value）配对组成的动态集合，核心特点有三：
有序性：Python 3.7+ 中，字典正式成为“有序集合”（3.6版本中有序是临时实现细节，不保证100%稳定），元素存储顺序与插入顺序一致； 可变性：长度可动态调整，支持新增、删除、修改键值对； 键唯一性：键必须是“可哈希”类型（如整数、字符串、元组，不能是列表），且不能重复，若重复赋值会覆盖旧值。
2. 集合（set）：唯一元素的无序集合
集合是无重复、无键值对的动态集合，核心特点对应字典：
无序性：元素没有固定存储顺序，无法通过索引访问； 可变性：支持新增、删除元素（注意：还有不可变的 frozenset，需通过frozenset()创建，此处暂不展开）；元素唯一性：自动去重，插入重复元素时会被忽略，且元素必须是“可哈希”类型。
简单来说：字典是“键值对仓库”，集合是“唯一元素容器”。
二、创建方式：4种方法创建字典，2种方法创建集合
字典和集合的创建方式灵活，我们通过代码直观演示，覆盖日常开发中最常用的场景：
1. 字典的4种创建方式
# 方式1：直接用大括号{}，键值对用冒号:分隔（最常用）
d1 = {'name': 'jason', 'age': 20, 'gender': 'male'}
print("d1:", d1, type(d1)) # 输出：d1: {'name': 'jason', 'age': 20, 'gender': 'male'} <class 'dict'>
# 方式2：用dict()函数，传入字典作为参数
d2 = dict({'name': 'jason', 'age': 20, 'gender': 'male'})
print("d2:", d2, type(d2)) # 输出：d2: {'name': 'jason', 'age': 20, 'gender': 'male'} <class 'dict'>
# 方式3：用dict()函数，传入包含键值对的列表（或元组）
d3 = dict([('name', 'jason'), ('age', 20), ('gender', 'male')])
print("d3:", d3, type(d3)) # 输出：d3: {'name': 'jason', 'age': 20, 'gender': 'male'} <class 'dict'>
# 方式4：用dict()函数，直接指定键名参数（键名无需引号）
d4 = dict(name='jason', age=20, gender='male')
print("d4:", d4, type(d4)) # 输出：d4: {'name': 'jason', 'age': 20, 'gender': 'male'} <class 'dict'>
# 验证4个字典是否相等（键值对相同则相等，与创建方式无关）
print("d1==d2==d3==d4:", d1 == d2 == d3 == d4) # 输出：True
2. 集合的2种创建方式
# 方式1：直接用大括号{}，元素用逗号分隔（注意：不能用{}创建空集合，空{}是字典）
s1 = {1, 2, 3, 3, 'hello'} # 插入重复元素3，会自动去重
print("s1:", s1, type(s1)) # 输出：s1: {1, 2, 3, 'hello'} <class 'set'>（顺序可能不同，因集合无序）
# 方式2：用set()函数，传入可迭代对象（如列表、元组）
s2 = set([1, 2, 3, 3, 'hello']) # 同样自动去重
print("s2:", s2, type(s2)) # 输出：s2: {1, 2, 3, 'hello'} <class 'set'>
# 验证两个集合是否相等（元素相同则相等，与顺序无关）
print("s1==s2:", s1 == s2) # 输出：True
# 注意：创建空集合必须用set()
empty_set = set()
print("空集合:", empty_set, type(empty_set)) # 输出：空集合: set() <class 'set'>
关键提醒：混合类型支持
和列表、元组一样，字典的键/值、集合的元素也支持“混合类型”，只要满足“可哈希”要求即可：
# 字典：键是整数+字符串，值是列表+元组（值可以是任意类型，无需可哈希）
mixed_dict = {1: [1, 2, 3], 'info': ('jason', 20)}
print("混合类型字典:", mixed_dict) # 输出：{1: [1, 2, 3], 'info': ('jason', 20)}
# 集合：元素是整数+字符串+元组（均为可哈希类型）
mixed_set = {1, 'hello', (2, 3)}
print("混合类型集合:", mixed_set) # 输出：{1, 'hello', (2, 3)}（顺序可能不同）
三、核心优势：为什么字典/集合比列表更高效？
字典和集合的高效性，源于底层的哈希表（Hash Table）存储结构——这种结构让它们的查找、添加、删除操作都能在常数时间复杂度（O(1)） 内完成，而列表的同类操作时间复杂度是O(n)（需遍历整个列表）。
我们用“查找元素”的场景做对比，直观感受性能差异：
import timeit
# 1. 准备数据：创建包含10万个元素的列表、字典、集合
# 列表：存储1~100000的整数
large_list = list(range(100000))
# 字典：键是1~100000，值是键的平方
large_dict = {i: i*i for i in range(100000)}
# 集合：存储1~100000的整数
large_set = set(range(100000))
# 2. 测试查找性能：查找“99999”是否存在（执行10000次）
# 列表查找：需遍历到最后一个元素，效率低
list_time = timeit.timeit('99999 in large_list', globals=globals(), number=10000)
# 字典查找（查键）：哈希表直接定位，效率高
dict_time = timeit.timeit('99999 in large_dict', globals=globals(), number=10000)
# 集合查找：哈希表直接定位，效率高
set_time = timeit.timeit('99999 in large_set', globals=globals(), number=10000)
print(f"列表查找10000次时间：{list_time:.4f}秒") # 约0.8~1.2秒（不同环境略有差异）
print(f"字典查找10000次时间：{dict_time:.4f}秒") # 约0.001~0.002秒
print(f"集合查找10000次时间：{set_time:.4f}秒") # 约0.001~0.002秒
从结果可见：字典和集合的查找速度是列表的近1000倍！数据量越大，这种差距越明显。
同理，添加、删除操作的逻辑类似：
列表添加/删除元素（尤其是中间位置）需移动其他元素，效率低； 字典/集合通过哈希表直接定位元素位置，添加/删除无需移动其他元素，效率高。
四、适用场景：什么时候该用字典/集合？
根据两者的特性，我们可以总结出明确的使用场景，避免“用错工具”导致性能浪费：
1. 用字典的场景：需要“键值映射”时
存储关联数据：如用户信息（键是“用户名”，值是“年龄/性别”）、配置参数（键是“参数名”，值是“参数值”）； 快速查找关联值：如根据“学生ID”查“成绩”，根据“商品ID”查“价格”； 统计频次：如统计字符串中每个字符出现的次数（键是“字符”，值是“频次”）。
示例：统计字符串字符频次
# 统计"python programming"中每个字符的出现次数
text = "python programming"
freq_dict = {}
for char in text:
# 若字符已在字典中，频次+1；否则新增键值对（频次=1）
freq_dict[char] = freq_dict.get(char, 0) + 1
print("字符频次统计：", freq_dict)
# 输出：{'p': 2, 'y': 1, 't': 1, 'h': 1, 'o': 2, 'n': 2, ' ': 1, 'r': 2, 'g': 2, 'a': 1, 'm': 2, 'i': 1}
2. 用集合的场景：需要“去重”或“判断归属”时
数据去重：如过滤列表中的重复元素、统计不重复的IP地址； 判断元素是否存在：如检查用户是否在“黑名单”中、判断关键词是否在“敏感词库”中； 集合运算：如求两个列表的交集（共同元素）、并集（所有元素）、差集（独有元素）。
示例：集合运算（求两个列表的交集/并集/差集）
list_a = [1, 2, 3, 4, 5]
list_b = [4, 5, 6, 7, 8]
# 转成集合
set_a = set(list_a)
set_b = set(list_b)
# 交集：两个集合都有的元素
intersection = set_a & set_b # 或 set_a.intersection(set_b)
print("交集：", intersection) # 输出：{4, 5}
# 并集：两个集合的所有元素（去重）
union = set_a | set_b # 或 set_a.union(set_b)
print("并集：", union) # 输出：{1, 2, 3, 4, 5, 6, 7, 8}
# 差集：set_a有但set_b没有的元素
difference = set_a - set_b # 或 set_a.difference(set_b)
print("差集（A-B）：", difference) # 输出：{1, 2, 3}
总结
字典和集合是Python中“高效处理数据”的核心工具，记住这3个核心要点：
结构差异：字典是“键值对有序集合”，集合是“唯一元素无序集合”； 性能优势：底层哈希表实现，查找/添加/删除操作均为O(1)，远快于列表； 使用原则：需要“键值映射”用字典，需要“去重/归属判断”用集合。
最后留一个小思考：如果需要存储“不可变的键值对集合”（类似字典，但不能修改），Python中有没有对应的数据结构？如果有，它和字典的区别是什么？欢迎在评论区分享你的答案～
本文来自博客园，作者：热爱技术的小牛，转载请注明原文链接：https://www.cnblogs.com/my-blogs-for-everone/p/19343411
浙公网安备 33010602011771号