Python基础：集合（Set）

Python基础：集合（Set）

---

---

一、知识点详解

1.1 集合是什么？

• 定义：集合是Python中存储唯一元素的无序可变容器
• 底层实现：基于哈希表（与字典键的存储方式相同）
• 核心特性：
  • 元素不重复（自动去重）
  • 不支持索引访问（无序结构）
  • 元素必须为不可变类型（如字符串、数字、元组）

1.2 创建集合

方法1：使用大括号{}

fruits = {"apple", "banana", "orange"}  
empty_set = set()  # 注意：{}创建的是空字典！  

方法2：set()构造函数

numbers = set([1, 2, 3, 2, 1])  # 自动去重：{1, 2, 3}  
chars = set("hello")             # 字符去重：{'h', 'e', 'l', 'o'}  

1.3 基础操作

操作类型	方法/运算符	示例代码	说明
添加单个元素	add()	fruits.add("grape")	添加单个元素，元素存在则不处理
添加多个元素	update()	fruits.update(["a", "b"])	从可迭代对象（列表/元组/字符串等）添加多个元素
删除元素	remove()	fruits.remove("apple")	删除指定元素，不存在则报错 KeyError
安全删除	discard()	fruits.discard("mango")	删除指定元素，不存在则静默处理
随机删除	pop()	removed = fruits.pop()	随机删除并返回元素，集合为空时报错KeyError
清空集合	clear()	fruits.clear()	移除所有元素，集合变为空。
成员检测	in 运算符	"banana" in fruits → True	检查元素是否存在，返回布尔值

注意：update()方法传入字符串时，会拆解为单个字符经去重后添加进集合（如 update("add") → 添加 'a', 'd'）

1.4 集合运算

运算类型	运算符	方法	描述
并集	|	union()	合并两个集合的所有元素
交集	&	intersection()	获取两个集合共有的元素
差集	-	difference()	获取只存在于第一个集合的元素
对称差集	^	symmetric_difference()	获取只存在于一个集合的元素

运算示例：

A = {1, 2, 3}  
B = {3, 4, 5}  A | B  # 并集：{1, 2, 3, 4, 5}  
A & B  # 交集：{3}  
A - B  # 差集：{1, 2}  
A ^ B  # 对称差集：{1, 2, 4, 5}  

1.5 集合推导式

语法：{表达式 for 元素 in 可迭代对象 [if 条件]} 其中 ([if 条件]可选)

squares = {x**2 for x in range(5)}  # {0, 1, 4, 9, 16}  
vowels = {char for char in "hello world" if char in "aeiou"}  # {'e', 'o'}  

---

二、说明示例

# 数码暴龙卡片收集示例 - 演示Python集合的特性与操作# 原始卡片列表（包含重复元素，演示集合去重特性）
cards_list = ["甲虫兽", "亚古兽", "战斗暴龙兽", "海狮兽", "甲虫兽", "巴达兽"]  # 1.创建集合 
# 大括号{}创建集合（自动去重，无序存储）
cards_1 = {"亚古兽", "加布兽", "神圣天使兽", "加布兽", "海狮兽"}  
# 输出结果体现无序性（集合元素顺序不固定）
print(cards_1)  # 输出：{'加布兽', '亚古兽', '神圣天使兽', '海狮兽'}  # set()构造函数创建集合（自动去重，可处理任意可迭代对象）
cards_2 = set(cards_list)  
print(cards_2)  # 输出：{'战斗暴龙兽', '海狮兽', '甲虫兽', '亚古兽', '巴达兽'}  #  2.基础操作 
# add() 添加元素（存在则忽略，保持唯一性）
cards_2.add("花仙兽")  
print("添加后cards_2:", cards_2)  # 输出包含新元素# update() 添加多个元素（从可迭代对象）
cards_2.update(["年糕兽", "滚球兽", "花仙兽"])  # 注意：花仙兽已存在，会被自动去重
print("update后cards_2:", cards_2)  # 输出：包含新增的两个数码兽# remove() 删除元素（元素不存在时报错）
cards_2.remove("甲虫兽")  
# print(cards_2.remove("机械暴龙兽"))  # 取消注释会报错：KeyError# discard() 安全删除（元素不存在时不报错）
cards_2.discard("机械暴龙兽")  # 静默处理不存在的元素# pop() 随机删除一个元素（集合无序，随机返回, 空集合报错）
removed_card = cards_2.pop()
print("随机删除的元素:", removed_card)  # 输出：随机删除的元素（可能是任意一个）# clear() 清空集合（删除所有元素，返回空集合）
cards_2.clear()  
print("清空后cards_2:", cards_2)  # 输出：set()# in 成员检测（高效判断元素是否存在）
print("花仙兽" in cards_2)  # 输出：False（集合已清空）# 3.集合推导式 
# 集合推导式（等价于上面的set(cards_list)，更灵活的创建方式）
cards_2 = {card for card in cards_list}  
print("推导式创建的cards_2:", cards_2)  # 输出与set(cards_list)一致# 4.集合运算
# 并集 | 合并所有元素（去重）
print("并集(cards_1 | cards_2):", cards_1 | cards_2)  
# 输出：{'神圣天使兽', '战斗暴龙兽', '加布兽', '海狮兽', '甲虫兽', '亚古兽', '巴达兽'}# 交集 & 获取共同元素
print("交集(cards_1 & cards_2):", cards_1 & cards_2)  
# 输出：{'亚古兽', '海狮兽'}（两组卡片都包含的数码兽）# 差集 - 获取仅存在于左侧集合的元素
print("差集(cards_1 - cards_2):", cards_1 - cards_2)  
# 输出：{'加布兽', '神圣天使兽'}（cards_1有但cards_2没有的元素）# 对称差集 ^ 获取仅存在于某一个集合的元素
print("对称差集(cards_1 ^ cards_2):", cards_1 ^ cards_2)  
# 输出：{'神圣天使兽', '战斗暴龙兽', '甲虫兽', '加布兽', '巴达兽'}（两边独有的元素）

---

三、知识点总结

集合的定义：存储唯一元素的无序可变容器， 基于哈希表实现

集合的特性：
无序性：集合中的元素没有顺序，无法通过索引访问
唯一性：自动去重，相同元素只会保留一个
元素不可变性：元素必须是不可变类型（字符串、数字、元组）
高效性：基于哈希表实现，插入、删除、查找操作，十分高效

适用场景：
数据去重（如日志分析、用户统计）
集合运算（交集、并集、差集等数学操作）
成员快速判断（比列表效率高得多）

注意事项：
空集合必须用set()创建，{}创建的是字典
remove()方法删除不存在的元素会报错，建议使用discard()
集合本身是可变的，因此不能作为其他集合的元素或字典的键

---

四、扩展知识

4.1 哈希函数 – hash()

在Python里，哈希函数是实现字典（dict）和集合（set）的核心机制，能够帮助我们快速查找和存储数据。下面我们来就来认识并了解一下哈希函数 ：

1. 什么是哈希函数？

哈希函数就像是一个“数据指纹机”，它能把任意内容（比如数字、字符串）转换成固定长度的“指纹码”（哈希值）。
相同的内容一定会得到相同的哈希值，不同的内容得到相同哈希值的概率极低。

# 使用内置的 hash() 函数计算哈希值
print(hash(123))          # 整数的哈希值：123
print(hash("apple"))      # 字符串的哈希值：一个很大的整数
print(hash((1, 2, 3)))    # 元组的哈希值（列表等可变对象无法哈希）

2. 哈希函数在字典和集合中的作用

字典（dict） 和 集合（set） 的底层使用哈希表来存储数据，它们的工作流程如下：

1. 存储数据时：
   对键（字典）或元素（集合）计算哈希值。
   通过哈希值找到对应的“抽屉”（存储位置）。
   将值存入这个“抽屉”。

2. 查找数据时：
   对要查找的键/元素计算哈希值。
   通过哈希值直接定位到“抽屉”，快速获取数据。

例子：

my_dict = {"apple": 1, "banana": 2}# 当你执行：my_dict["apple"]
# 1. 计算 "apple" 的哈希值
# 2. 通过哈希值找到对应的存储位置
# 3. 直接取出值 1（无需遍历整个字典）

3. 为什么字典的键和集合的元素必须是不可变的？

因为哈希值是基于对象内容计算的，如果对象内容可变（如列表），修改后哈希值会改变，导致找不到原来的数据。

# 正确示例
dict1 = {(1, 2): "元组可以作为键",  # 元组是不可变的，可以作为键"name": "小帅"
}# 错误示例
dict2 = {[1, 2]: "列表不可作为键"  # 列表是可变的，会报错TypeError
}

4. 集合（set）的去重原理

集合不允许重复元素，正是因为哈希函数的特性：相同内容的哈希值相同，会被存入同一个“抽屉”，后存入的会覆盖前一个。

my_set = {1, 2, 2, 3}  # 重复的 2 会被自动去重
print(my_set)  # 输出：{1, 2, 3}

总结来说：哈希函数就像是字典和集合的“导航系统”，让它们能够快速找到数据，同时保证键/元素的唯一性。这也是字典和集合高效的核心原因！

---

五、知识点考察题

s = {True, 1.0, "1", (1,)}  
s.update('APP')  
print(len(s))  

以上代码输出结果是什么（ ）

• A. 4
• B. 5
• C. 6
• D. 7

答案：B

解析：

1. 初始集合 {True, 1.0, "1", (1,)} 因 True 和 1.0 等价，实际为 {True, "1", (1,)}（3个元素）。
2. update('APP') 将字符串拆分为 {'A', 'P'} 并添加（去重后）。
3. 最终集合：{True, "1", (1,), 'A', 'P'}，共 5 个元素。

---

关注「安于欣」获取更多Python技巧