集合
集合的建立
集合（Set） 是 Python 中一种无序、不重复的元素集合数据类型。
| 特性 | 说明 |
|---|---|
| 无序（Unordered） | 集合中的元素没有固定顺序，不能通过索引访问（如 set[0] 会报错） |
| 唯一性（Unique） | 自动去重，相同元素只保留一个 |
| 可变（Mutable） | 可以添加或删除元素（但集合中的元素本身必须是不可变类型） |
| 支持数学集合运算 | 如并集、交集、差集、对称差等 |
集合建立的方法
|-----------|-------------------------------------------------|
| 方法 | 语法格式 |
| {} | dict_name = {元素 1, 元素 2, ...} |
| set() | dict_name = set(可迭代对象) |
| 空集合 | dict_name = set() |
| 集合推导式 | dict_name = {表达式 for 变量 in 可迭代对象 [if 条件]} |
| frozenset是 Python 中的不可变集合（immutable set）数据类型，与普通 set 功能类似存储无序、不重复的元素；一旦创建后，不能添加、删除或修改元素；因为不可变，所以是 hashable 的，可以作为字典的键或其他集合的元素；frozenset ()函数创建冻结集合 ||
python
# 一、创建集合的5种方法
# 1. 花括号 {} 直接创建
# 语法：{元素 1, 元素 2, ...}
s1 = {1, 2, 3, 4, 5}
# 2. set() 构造函数创建
# 语法：set(可迭代对象)
set([1, 2, 3]) # 从列表
set("abc") # 从字符串
set((1, 2, 3)) # 从元组
set(range(5)) # 从 range 对象
# 3. 空集合创建
# 重要：{} 是空字典，不是空集合！
s_empty = set() # 正确
s_wrong = {} # 这是字典
# 4. 集合推导式
# 语法：{表达式 for 变量 in 可迭代对象 [if 条件]}
# 带条件过滤：提取偶数
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_set = {x for x in data if x % 2 == 0}
print(f"原数据：{data}")
print(f"偶数集合：{even_set}") #输出：{2, 4, 6, 8, 10}
# 5. 使用 frozenset() 创建不可变集合
fs = frozenset([1, 2, 3, 4, 5])
print(f"冻结集合：{fs}") # frozenset({1, 2, 3, 4, 5})
fs2 = frozenset([3, 4, 5, 6])
print(f"并集：{fs | fs2}") # frozenset({1, 2, 3, 4, 5, 6})
print(f"交集：{fs & fs2}") # frozenset({3, 4, 5})
print(f"差集：{fs - fs2}") # frozenset({1, 2})
# 基本应用示例
# 去除列表中的重复元素
numbers = [1, 2, 2, 3, 4, 4, 5, 5, 5]
unique = set(numbers)
print(unique) # {1, 2, 3, 4, 5}
print(list(unique)) # [1, 2, 3, 4, 5]集合的操作
基础操作汇总
|----------|------------------------------------------------------------------|-----------------------------|-------------------------------------------------------------------------------------|--------------|
| 操作 | 语法 | 作用 | 示例 | 结果 |
| 交集 | set1&set2 set1 &= set2 | 返回两个集合中共有的元素 | {1,2} & {2,3} | {2} |
| 交集 | set_name.intersection(set1, set2, ...) 参数：一个或多个集合 返回值：交集的新集合 | 获取多个集合的交集（共同元素） | s20 = {1, 2, 3, 4} s21 = {2, 3, 4, 5} s22 = {3, 4, 5, 6} s20.intersection(s21, s22) | {3, 4} |
| 并集 | set1 | set2 set1 |= set2 | 返回两个集合中所有不重复的元素 | {1,2} | {2,3} | {1,2,3} |
| 并集 | set_name.union(set1, set2, ...) 参数：一个或多个集合 返回值：并集的新集合 | 合并多个集合的所有元素，自动去重 | s27 = {1, 2} s28 = {2, 3} s29 = {3, 4} s27.union(s28, s29) | {1, 2, 3, 4} |
| 差集 | set1 - set2 set1 -= set2 | 返回属于 set1 但不属于 set2 的元素 | {1,2} - {2,3} | {1} |
| 差集 | set_name.difference(set1, set2, ...) 参数：一个或多个集合 返回值：差集的新集合 | 返回存在于当前集合但不存在于其他集合的元素 | s32 = {1, 2, 3, 4, 5} s33 = {4, 5, 6, 7} s32.difference(s33) | {1, 2, 3} |
| 对称差集 | set1 ^ set2 | 返回只存在于其中一个集合的元素（排除共有元素） | {1,2} ^ {2,3} | {1,3} |
| 对称差集 | set_name.symmetric_difference(set1) 参数：一个集合 返回值：对称差集的新集合 | 返回只存在于其中一个集合的元素（排除共有元素） | s36 = {1, 2, 3, 4} s37 = {3, 4, 5, 6} s36.symmetric_difference(s37) | {1, 2, 5, 6} |
| 等于 | set1 == set2 | 判断两个集合是否包含完全相同的元素（顺序无关） | {1,2} == {2,1} | True |
| 不等于 | set1 != set2 | 判断两个集合是否不相等 | {1,2} != {1,2,3} | True |
| 属于 | x in set | 判断元素 x 是否属于集合（比列表查找更快） | "a" in {"a","b"} | True |
| 不属于 | x not in set | 判断元素 x 是否不属于集合 | "c" not in {"a","b"} | True |
应用示例
python
# 交集--数据去重与验证
visited_urls = {'https://a.com', 'https://b.com', 'https://c.com'}
current_urls = {'https://b.com', 'https://c.com', 'https://d.com'}
duplicate_urls = visited_urls & current_urls
print("重复链接：", duplicate_urls) # {'https://b.com', 'https://c.com'}
# 应用：爬虫系统中的重复 URL 检测
# 并集--爬虫 URL 队列管理
visited_urls = {'https://a.com', 'https://b.com'}
new_urls = {'https://c.com', 'https://d.com'}
visited_urls |= new_urls # 更新已访问集合
print("更新后总数：", len(visited_urls)) # 4
# 应用：增量爬取中的 URL 累积管理
# 差集--权限升级 - 计算缺失权限
admin_perms = {'读', '写', '删除', '导出'}
editor_perms = {'读', '写'}
missing_perms = admin_perms - editor_perms
print("需补充权限：", missing_perms) # {'删除', '导出'}
# 应用：权限动态升级、角色转换
# 对称差集--双向商品推荐
user_a_purchased = {'laptop', 'mouse', 'keyboard', 'monitor'}
user_b_purchased = {'mouse', 'keyboard', 'speaker', 'headset'}
# 对称差集用于差异分析报表
diff_analysis = user_a_purchased ^ user_b_purchased
print("双向差异总览：", diff_analysis)
# 应用：用户兴趣差异分析报表
# == 相等
set1 = {1, 2, 3}
set2 = {3, 2, 1} # 顺序不同
set3 = {1, 2, 3, 4} # 多了元素
set4 = {1, 2, 2, 3} # 有重复，但自动去重
print(set1 == set2) # True：元素相同
print(set1 == set3) # False：set3 多了 4
print(set1 == set4) # True：set4 去重后也是{1, 2, 3}
# in 属于--关键词过滤
sensitive_words = {'广告', '垃圾', '诈骗'}
message = "这是一条广告信息"
for word in sensitive_words:
if word in message:
print("检测到敏感词！")
break
# not in 不属于--黑名单检查
blacklist = {'恶意用户 1', '恶意用户 2'}
visitor = '正常用户'
if visitor not in blacklist:
print("允许访问")集合的方法
常用方法汇总
|--------------------------------------------|--------------------------------------------------------------------------------------------------|--------------------------------------------------------|
| 方法 | 语法格式 | 作用 |
| set.add() | set_name.add(element) element ：要添加到集合中的任意不可变对象（如：数字、字符串、元组等） 返回值：None（原地修改集合，不返回新集合） | 向集合中添加单个元素；若元素已存在，不会报错，也不会重复添加（集合自动去重） |
| set.clear() | set_name.clear() 参数：无 返回值：None | 快速清空集合，重置状态 |
| set.copy() | set_name.copy() 参数：无 返回值：集合的浅拷贝 | 创建新集合对象，原集合不变 |
| set.discard() | set_name.discard(element) element ：要从集合中移除的元素 返回值：None | 安全地移除集合中的指定元素；若元素不存在，不会报错 |
| set.isdisjoint() | set_name.isdisjoint(set1) 参数：另一个集合 返回值：布尔值（True/False） | 判断两个集合是否没有共同元素 |
| set.issubset() | set_name.issubset(set1) 参数：另一个集合 返回值：布尔值（True/False） | 判断当前集合是否为另一个集合的子集 |
| set.issuperset() | set_name.issuperset(set1) 参数：另一个集合 返回值：布尔值（True/False） | 判断当前集合是否包含另一个集合 |
| set.pop() | set_name.pop() 参数：无 返回值：被移除的随机元素 | 随机获取并移除集合中的一个元素；若集合为空，抛出 KeyError |
| set.remove() | set_name.remove(element) element ：要从集合中移除的元素 返回值：None | 移除集合中的指定元素，若元素不存在则报错 |
| set.difference_update() | set_name.difference_update(set1, set2, ...) 参数：一个或多个集合 返回值：None（原地修改，不返回新集合） | 原地移除集合中存在于其他集合的元素（保留差集） |
| set.intersection _update() | set_name.intersection_update(set1, set2, ...) 参数：一个或多个集合 返回值：None（原地修改） | 直接修改原集合，只保留所有集合共有的元素 |
| set.symmetric_difference _update() | set_name.symmetric_difference_update(set1) 参数：一个集合 返回值：None（原地修改） | 原地更新集合为对称差集（排除共同元素，保留独有元素） |
| set.update() | set_name.update(iterable) 参数：iterable ： 任意可迭代对象（列表、元组、字符串、其他集合等） 返回值：None | 批量添加元素，自动去重 |
应用举例
python
# add()方法---网站访问记录去重
visited_urls = set()
visited_urls.add("https://www.example.com/page1")
visited_urls.add("https://www.example.com/page2")
visited_urls.add("https://www.example.com/page1") # 重复访问，自动去重
print(f"应用 1 - 访问记录去重：{len(visited_urls)} 个唯一 URL")
# clear()方法---清除会话数据
session_data = {'user_id', 'token', 'timestamp'}
session_data.clear()
print(f"应用 1 - 会话已清除：{session_data}")
# copy()方法---实验对照
control_group = {'sample_1', 'sample_2', 'sample_3'}
experimental_group = control_group.copy()
print(f"应用 3 - 实验组与对照组独立")
# discard()方法---清理过期缓存
cache = {'cache_001', 'cache_002', 'cache_003'}
cache.discard('cache_expired') # 可能已过期被删除，不报错
print(f"应用 1 - 清理缓存：{cache}")
# pop()方法--抽奖系统
prize_pool = {'一等奖', '二等奖', '三等奖', '谢谢参与'}
winner = prize_pool.pop()
print(f"应用 2 - 抽奖结果：{winner}")
# update()方法---批量导入数据
existing_ids = {1001, 1002, 1003}
new_ids = [1004, 1005, 1006, 1001] # 包含重复
existing_ids.update(new_ids)
print(f"应用 2 - 去重后 ID 总数：{len(existing_ids)}")
# remove()方法---购物车删除商品
cart_items = {'商品 1', '商品 2', '商品 3'}
cart_items.remove('商品 2')
print(f"应用 2 - 删除商品后的购物车：{cart_items}")
# issubset()方法---权限验证
required_perms = {'read', 'write'}
user_perms = {'read', 'write', 'delete', 'admin'}
has_permission = required_perms.issubset(user_perms)
print(f"应用 1 - 用户权限是否充足：{has_permission}")
# issuperset()方法---库存检查
warehouse_stock = {'item_A', 'item_B', 'item_C', 'item_D'}
order_items = {'item_A', 'item_B'}
can_fulfill = warehouse_stock.issuperset(order_items)
print(f"应用 1 - 订单能否满足：{can_fulfill}")
# isdisjoint()方法---排他性检查
group_male = {'Alice', 'Bob', 'Charlie'}
group_female = {'Diana', 'Eve', 'Frank'}
no_overlap = group_male.isdisjoint(group_female)
print(f"应用 1 - 分组是否互斥：{no_overlap}")
# difference_update()方法---批量下架商品
all_products = {'prod_001', 'prod_002', 'prod_003', 'prod_004', 'prod_005'}
discontinued = {'prod_002', 'prod_004'}
all_products.difference_update(discontinued)
print(f"应用 1 - 在售商品：{all_products}")
# intersection_update()方法---多维度数据过滤
all_records = {'rec_001', 'rec_002', 'rec_003', 'rec_004', 'rec_005'}
verified_records = {'rec_002', 'rec_003', 'rec_005'}
recent_records = {'rec_001', 'rec_003', 'rec_005'}
all_records.intersection_update(verified_records, recent_records)
print(f"应用 2 - 验证且最近的记录：{all_records}")
# symmetric_difference_update()方法---成员资格变更
old_members = {'Alice', 'Bob', 'Charlie', 'David'}
new_members = {'Charlie', 'David', 'Eve', 'Frank'}
old_members.symmetric_difference_update(new_members)
print(f"应用 3 - 成员变化：{old_members}")内置函数在集合中应用
常用函数
|-----------------|--------------------------------|------------|--------------|-------------|
| 函数 | 语法格式 | 作用 | 返回值类型 | 是否修改原集合 |
| len() | len(set) | 统计集合元素个数 | int | 否 |
| max() | max(set) | 获取最大元素 | 元素类型 | 否 |
| min() | min(set) | 获取最小元素 | 元素类型 | 否 |
| sorted() | sorted(set, reverse=False) | 对集合排序 | list | 否 |
| sum() | sum(set) | 数值元素求和 | int/float | 否 |
| enumerate() | enumerate(set, start=0) | 生成索引 - 元素对 | enumerate 对象 | 否 |
| 注意事项 | 集合是无序的，每次遍历顺序可能不同； max()、min()、sorted() 要求元素之间可以比较 sum() 只能用于数值型元素 enumerate() 返回的是迭代器，需要用 list() 转换或直接在循环中使用 ||||
应用举例
python
# 商品价格在区间内的筛选（价格分析）
prices = {299.99, 599.00, 1299.00, 899.99, 459.00, 1999.99, 399.00}
# 筛选 500-1000 元之间的商品
mid_range_prices = {p for p in prices if 500 <= p <= 1000}
if mid_range_prices:
print(f"中等价位商品：{sorted(mid_range_prices)}") # 输出：[599.0, 899.99]
print(f"最低价：{min(mid_range_prices)}") # 输出：599.0
print(f"最高价：{max(mid_range_prices)}") # 输出：899.99
print(f"平均价格：{sum(mid_range_prices)/len(mid_range_prices):.2f
# 成绩等级分布统计（教育场景）
# 优秀（>=90）、良好（80-89）、及格（60-79）
student_scores = {95, 87, 92, 78, 85, 96, 72, 88, 90, 65, 82, 94}
excellent = {s for s in student_scores if s >= 90}
good = {s for s in student_scores if 80 <= s < 90}
passing = {s for s in student_scores if 60 <= s < 80}
print(f"优秀成绩集合：{sorted(excellent)}") # 输出：[90, 92, 94, 95, 96]
print(f"优秀人数：{len(excellent)}") # 输出：5
print(f"优秀平均分：{sum(excellent)/len(excellent):.1f}") # 输出：93.4
print(f"良好成绩集合：{sorted(good)}") # 输出：[82, 85, 87, 88]
print(f"良好人数：{len(good)}") # 输出：4
print(f"良好平均分：{sum(good)/len(good):.1f}") # 输出：85.5
print(f"及格成绩集合：{sorted(passing)}") # 输出：[65, 72, 78]
print(f"及格人数：{len(passing)}") # 输出：3
print(f"及格平均分：{sum(passing)/len(passing):.1f}") # 输出：71.7
# 使用 enumerate() 输出排名
for rank, score in enumerate(sorted(student_scores, reverse=True), start=1):
print(f"第{rank}名：{score}分")