frozenset() - 不可变集合构造函数
创建不可变的集合对象
frozenset() - 不可变集合构造函数
📝 概述
frozenset() 是 Python 中的内置函数，用于创建不可变的集合对象。与普通的 set 不同，frozenset 一旦创建就不能修改，这使得它可以作为字典的键或其他集合的元素使用。frozenset 保持了集合的所有特性：元素唯一、无序、支持集合运算。
🎯 学习目标
- 掌握 frozenset()函数的基本用法和语法
- 理解 frozenset 与 set 的区别和联系
- 学会在需要不可变集合的场景中使用 frozenset
- 了解 frozenset 的哈希特性和应用场景
- 掌握 frozenset 的集合运算操作
📋 前置知识
- Python 基本语法
- 集合（set）的基本概念和操作
- 可变与不可变对象的概念
- 哈希和字典键的要求
- 可迭代对象的概念
🔍 详细内容
基本概念
frozenset() 创建一个不可变的集合对象。不可变意味着一旦创建，就不能添加、删除或修改其中的元素。这种不可变性使得 frozenset 对象是可哈希的，因此可以用作字典的键或其他集合的元素。
语法格式
frozenset([iterable])
参数说明
| 参数名 | 类型 | 必需 | 默认值 | 说明 |
|---|---|---|---|---|
| iterable | 可迭代对象 | 否 | 无 | 用于初始化 frozenset 的可迭代对象 |
返回值
- 类型: frozenset 对象
- 内容: 包含来自可迭代对象的唯一元素的不可变集合
💡 代码示例
基本用法
## 创建空的 frozenset
empty_fs = frozenset()
print(empty_fs) # 输出: frozenset()
print(type(empty_fs)) # 输出: <class 'frozenset'>
## 从列表创建 frozenset
list_data = [1, 2, 3, 2, 1]
fs_from_list = frozenset(list_data)
print(fs_from_list) # 输出: frozenset({1, 2, 3})
## 从字符串创建 frozenset
fs_from_string = frozenset("hello")
print(fs_from_string) # 输出: frozenset({'h', 'e', 'l', 'o'})
## 从元组创建 frozenset
fs_from_tuple = frozenset((1, 2, 3, 4))
print(fs_from_tuple) # 输出: frozenset({1, 2, 3, 4})
与 set 的比较
## 创建普通集合和不可变集合
regular_set = {1, 2, 3}
frozen_set = frozenset([1, 2, 3])
print(f"普通集合: {regular_set}")
print(f"不可变集合: {frozen_set}")
## 尝试修改普通集合(成功)
regular_set.add(4)
print(f"添加元素后的普通集合: {regular_set}")
## 尝试修改不可变集合(失败)
try:
frozen_set.add(4) # 这会引发 AttributeError
except AttributeError as e:
print(f"错误: {e}")
## 检查可哈希性
print(f"普通集合是否可哈希: {hash(regular_set) if hasattr(regular_set, '__hash__') else '不可哈希'}")
print(f"不可变集合的哈希值: {hash(frozen_set)}")
作为字典键使用
## frozenset 可以作为字典的键
data_dict = {}
## 使用 frozenset 作为键
key1 = frozenset([1, 2, 3])
key2 = frozenset(['a', 'b', 'c'])
key3 = frozenset([1, 2, 3]) # 与 key1 相同
data_dict[key1] = "数字集合"
data_dict[key2] = "字母集合"
data_dict[key3] = "另一个数字集合" # 会覆盖 key1 的值
print(data_dict)
## 输出: {frozenset({1, 2, 3}): '另一个数字集合', frozenset({'a', 'b', 'c'}): '字母集合'}
## 普通 set 不能作为字典键
try:
regular_set_key = {1, 2, 3}
data_dict[regular_set_key] = "这会失败"
except TypeError as e:
print(f"使用 set 作为键的错误: {e}")
集合运算
## frozenset 支持所有集合运算
fs1 = frozenset([1, 2, 3, 4])
fs2 = frozenset([3, 4, 5, 6])
fs3 = frozenset([1, 2])
## 并集
union_result = fs1 | fs2
print(f"并集: {union_result}") # 输出: frozenset({1, 2, 3, 4, 5, 6})
## 交集
intersection_result = fs1 & fs2
print(f"交集: {intersection_result}") # 输出: frozenset({3, 4})
## 差集
difference_result = fs1 - fs2
print(f"差集: {difference_result}") # 输出: frozenset({1, 2})
## 对称差集
symmetric_diff = fs1 ^ fs2
print(f"对称差集: {symmetric_diff}") # 输出: frozenset({1, 2, 5, 6})
## 子集检查
print(f"fs3 是 fs1 的子集: {fs3 <= fs1}") # 输出: True
print(f"fs1 是 fs2 的超集: {fs1 >= fs2}") # 输出: False
集合方法
fs = frozenset([1, 2, 3, 4, 5])
## 检查元素是否存在
print(f"3 在集合中: {3 in fs}") # 输出: True
print(f"6 在集合中: {6 in fs}") # 输出: False
## 获取集合长度
print(f"集合长度: {len(fs)}") # 输出: 5
## 遍历集合
print("集合元素:")
for item in fs:
print(f" {item}")
## 集合方法(返回新的 frozenset)
other_fs = frozenset([4, 5, 6, 7])
## union 方法
union_fs = fs.union(other_fs)
print(f"union 方法结果: {union_fs}")
## intersection 方法
intersection_fs = fs.intersection(other_fs)
print(f"intersection 方法结果: {intersection_fs}")
## difference 方法
difference_fs = fs.difference(other_fs)
print(f"difference 方法结果: {difference_fs}")
## issubset 和 issuperset 方法
small_fs = frozenset([1, 2])
print(f"small_fs 是 fs 的子集: {small_fs.issubset(fs)}")
print(f"fs 是 small_fs 的超集: {fs.issuperset(small_fs)}")
🚀 高级应用
嵌套集合结构
## 创建包含 frozenset 的集合
nested_sets = {
frozenset([1, 2, 3]),
frozenset(['a', 'b', 'c']),
frozenset([1, 2, 3]), # 重复,会被去除
frozenset(['x', 'y', 'z'])
}
print(f"嵌套集合: {nested_sets}")
print(f"嵌套集合长度: {len(nested_sets)}")
## 在嵌套集合中查找
target = frozenset([1, 2, 3])
print(f"目标集合在嵌套集合中: {target in nested_sets}")
## 创建集合的集合
set_of_sets = set()
set_of_sets.add(frozenset([1, 2]))
set_of_sets.add(frozenset([3, 4]))
set_of_sets.add(frozenset([1, 2])) # 重复,不会添加
print(f"集合的集合: {set_of_sets}")
缓存和记忆化
from functools import lru_cache
## 使用 frozenset 作为缓存键
@lru_cache(maxsize=128)
def calculate_set_properties(elements):
"""计算集合的属性(使用 frozenset 作为参数)"""
if not isinstance(elements, frozenset):
elements = frozenset(elements)
return {
'size': len(elements),
'sum': sum(elements) if all(isinstance(x, (int, float)) for x in elements) else None,
'min': min(elements) if elements else None,
'max': max(elements) if elements else None
}
## 使用示例
data1 = frozenset([1, 2, 3, 4, 5])
data2 = frozenset([1, 2, 3, 4, 5]) # 相同的数据
data3 = frozenset([2, 3, 4, 5, 6])
result1 = calculate_set_properties(data1)
result2 = calculate_set_properties(data2) # 会使用缓存
result3 = calculate_set_properties(data3)
print(f"结果 1: {result1}")
print(f"结果 2: {result2}")
print(f"结果 3: {result3}")
print(f"缓存信息: {calculate_set_properties.cache_info()}")
图算法中的应用
## 在图算法中使用 frozenset 表示边
class Graph:
def __init__(self):
self.edges = set() # 存储 frozenset 表示的边
self.vertices = set()
def add_edge(self, vertex1, vertex2):
"""添加无向边"""
edge = frozenset([vertex1, vertex2])
self.edges.add(edge)
self.vertices.add(vertex1)
self.vertices.add(vertex2)
def has_edge(self, vertex1, vertex2):
"""检查是否存在边"""
edge = frozenset([vertex1, vertex2])
return edge in self.edges
def get_neighbors(self, vertex):
"""获取顶点的邻居"""
neighbors = set()
for edge in self.edges:
if vertex in edge:
neighbors.update(edge - {vertex})
return neighbors
def __str__(self):
return f"Graph(vertices={self.vertices}, edges={self.edges})"
## 使用示例
graph = Graph()
graph.add_edge('A', 'B')
graph.add_edge('B', 'C')
graph.add_edge('C', 'A')
graph.add_edge('A', 'B') # 重复边,不会添加
print(graph)
print(f"A 和 B 之间有边: {graph.has_edge('A', 'B')}")
print(f"A 的邻居: {graph.get_neighbors('A')}")
配置管理
## 使用 frozenset 管理不可变配置
class ConfigManager:
def __init__(self):
self.configs = {} # 配置名 -> frozenset 的映射
def add_config(self, name, settings):
"""添加配置"""
if isinstance(settings, dict):
# # 将字典转换为 frozenset of tuples
config_items = frozenset(settings.items())
elif hasattr(settings, '__iter__'):
config_items = frozenset(settings)
else:
raise ValueError("设置必须是字典或可迭代对象")
self.configs[name] = config_items
def get_config(self, name):
"""获取配置"""
return self.configs.get(name)
def compare_configs(self, name1, name2):
"""比较两个配置"""
config1 = self.configs.get(name1)
config2 = self.configs.get(name2)
if config1 is None or config2 is None:
return None
return {
'common': config1 & config2,
'only_in_first': config1 - config2,
'only_in_second': config2 - config1
}
## 使用示例
config_manager = ConfigManager()
## 添加配置
config_manager.add_config('dev', {
'debug': True,
'database_url': 'localhost:5432',
'cache_enabled': False
})
config_manager.add_config('prod', {
'debug': False,
'database_url': 'prod-server:5432',
'cache_enabled': True,
'ssl_enabled': True
})
## 比较配置
comparison = config_manager.compare_configs('dev', 'prod')
print("配置比较结果:")
print(f" 共同设置: {comparison['common']}")
print(f" 仅在 dev 中: {comparison['only_in_first']}")
print(f" 仅在 prod 中: {comparison['only_in_second']}")
⚠️ 常见陷阱与最佳实践
不可变性理解
## 正确理解不可变性
fs = frozenset([1, 2, 3])
## 错误:尝试修改 frozenset
try:
fs.add(4) # AttributeError
except AttributeError:
print("frozenset 不支持 add 方法")
try:
fs.remove(1) # AttributeError
except AttributeError:
print("frozenset 不支持 remove 方法")
## 正确:创建新的 frozenset
new_fs = fs | {4} # 使用并集操作
print(f"原 frozenset: {fs}")
print(f"新 frozenset: {new_fs}")
## 正确:使用方法创建新 frozenset
another_fs = fs.union([4, 5])
print(f"使用 union 方法: {another_fs}")
哈希和相等性
## frozenset 的哈希和相等性
fs1 = frozenset([1, 2, 3])
fs2 = frozenset([3, 2, 1]) # 顺序不同
fs3 = frozenset([1, 2, 3, 3]) # 有重复元素
print(f"fs1 == fs2: {fs1 == fs2}") # True,集合不考虑顺序
print(f"fs1 == fs3: {fs1 == fs3}") # True,集合自动去重
print(f"hash(fs1) == hash(fs2): {hash(fs1) == hash(fs2)}") # True
## 在字典中使用
dict_with_fs_keys = {}
dict_with_fs_keys[fs1] = "第一个"
dict_with_fs_keys[fs2] = "第二个" # 会覆盖第一个
dict_with_fs_keys[fs3] = "第三个" # 会覆盖前面的
print(f"字典内容: {dict_with_fs_keys}") # 只有一个键值对
性能考虑
import time
## 性能比较:frozenset vs set vs list
def performance_comparison():
"""比较不同数据结构的性能"""
data = list(range(10000))
# # 创建时间比较
start = time.time()
regular_set = set(data)
set_time = time.time() - start
start = time.time()
frozen_set = frozenset(data)
frozenset_time = time.time() - start
start = time.time()
list_data = list(data)
list_time = time.time() - start
print(f"创建时间比较:")
print(f" set: {set_time:.6f}秒")
print(f" frozenset: {frozenset_time:.6f}秒")
print(f" list: {list_time:.6f}秒")
# # 查找时间比较
target = 5000
start = time.time()
for _ in range(1000):
target in regular_set
set_lookup_time = time.time() - start
start = time.time()
for _ in range(1000):
target in frozen_set
frozenset_lookup_time = time.time() - start
start = time.time()
for _ in range(1000):
target in list_data
list_lookup_time = time.time() - start
print(f"\n 查找时间比较(1000 次):")
print(f" set: {set_lookup_time:.6f}秒")
print(f" frozenset: {frozenset_lookup_time:.6f}秒")
print(f" list: {list_lookup_time:.6f}秒")
performance_comparison()
内存使用优化
import sys
## 内存使用比较
def memory_comparison():
"""比较不同数据结构的内存使用"""
data = list(range(1000))
regular_set = set(data)
frozen_set = frozenset(data)
list_data = list(data)
tuple_data = tuple(data)
print("内存使用比较:")
print(f" set: {sys.getsizeof(regular_set)} 字节")
print(f" frozenset: {sys.getsizeof(frozen_set)} 字节")
print(f" list: {sys.getsizeof(list_data)} 字节")
print(f" tuple: {sys.getsizeof(tuple_data)} 字节")
# # frozenset 的共享优化
fs1 = frozenset([1, 2, 3])
fs2 = frozenset([1, 2, 3])
print(f"\nfrozenset 对象共享:")
print(f" fs1 is fs2: {fs1 is fs2}") # 可能为 True(实现相关)
print(f" id(fs1): {id(fs1)}")
print(f" id(fs2): {id(fs2)}")
memory_comparison()
🔧 性能优化
批量操作优化
## 批量操作的性能优化
def optimize_batch_operations():
"""优化批量 frozenset 操作"""
# # 避免频繁创建小的 frozenset
data_sets = []
# # 不推荐:频繁创建
start = time.time()
for i in range(1000):
fs = frozenset([i, i+1, i+2])
data_sets.append(fs)
slow_time = time.time() - start
# # 推荐:批量创建
data_sets.clear()
start = time.time()
batch_data = [(i, i+1, i+2) for i in range(1000)]
data_sets = [frozenset(item) for item in batch_data]
fast_time = time.time() - start
print(f"频繁创建时间: {slow_time:.6f}秒")
print(f"批量创建时间: {fast_time:.6f}秒")
print(f"性能提升: {slow_time / fast_time:.2f}倍")
optimize_batch_operations()
集合运算优化
## 集合运算的性能优化
def optimize_set_operations():
"""优化集合运算性能"""
# # 创建测试数据
large_fs1 = frozenset(range(10000))
large_fs2 = frozenset(range(5000, 15000))
small_fs = frozenset(range(100))
# # 优化 1:使用合适的运算顺序
start = time.time()
# # 不推荐:大集合先运算
result1 = (large_fs1 | large_fs2) & small_fs
slow_time = time.time() - start
start = time.time()
# # 推荐:小集合先运算
result2 = small_fs & (large_fs1 | large_fs2)
fast_time = time.time() - start
print(f"大集合先运算: {slow_time:.6f}秒")
print(f"小集合先运算: {fast_time:.6f}秒")
print(f"结果相同: {result1 == result2}")
# # 优化 2:避免不必要的中间结果
start = time.time()
# # 不推荐:创建中间 frozenset
temp_fs = frozenset(range(100, 200))
result3 = large_fs1 & temp_fs
slow_time2 = time.time() - start
start = time.time()
# # 推荐:直接使用其他可迭代对象
result4 = large_fs1 & set(range(100, 200))
fast_time2 = time.time() - start
print(f"\n 创建中间 frozenset: {slow_time2:.6f}秒")
print(f"直接使用 set: {fast_time2:.6f}秒")
print(f"结果相同: {result3 == result4}")
optimize_set_operations()
🔗 相关函数
内置函数
- set() - 创建可变集合
- list() - 创建列表
- tuple() - 创建元组
- dict() - 创建字典
- len() - 获取集合长度
- iter() - 创建迭代器
- hash() - 计算哈希值
- bool() - 布尔值转换
标准库模块
- collections - 特殊容器数据类型
Counter- 计数器defaultdict- 默认字典
- itertools - 迭代工具
chain()- 连接迭代器combinations()- 组合permutations()- 排列
- operator - 函数式操作符
or_()- 并集操作and_()- 交集操作sub()- 差集操作xor()- 对称差集操作
第三方库
- numpy - 数值计算
np.unique()- 唯一值np.intersect1d()- 一维交集np.union1d()- 一维并集
- pandas - 数据分析
pd.Series.unique()- 唯一值pd.Index- 索引对象
📚 扩展阅读
🏷️ 标签
集合 不可变 数据结构 哈希 集合运算 函数式编程
最后更新: 2024-01-15
作者: Python 文档工程师
版本: 1.0
讨论与反馈
欢迎在下方留言讨论，分享你的学习心得或提出问题。评论基于GitHub Issues，需要GitHub账号。