set 定义

集合（Set）是一种无序且不重复的数据结构，用于存储一组唯一的元素。时间复杂度O(1)。

集合是由一对花括号 {} 构成，其中每个元素之间用逗号分隔。
集合中的元素必须是不可变的（不可修改），可以包含数字、字符串、元组等不可变类型。
集合中的元素不重复，即集合中每个元素是唯一的。
集合是无序的，不能通过索引访问，因此不能像列表那样使用索引或切片。

set 使用场景

集合是在需要存储唯一元素、进行集合运算、快速查找和去重等场景下非常实用的数据结构。它们具有高效的成员检查和集合操作功能，能够简化代码并提高程序执行效率。

去重：当需要去除列表或其他可迭代对象中的重复元素时，使用集合可以很方便地去除重复项。
集合运算：集合提供了并集、交集、补集等集合运算方法，使得处理集合数据时更加方便。
成员检查：使用集合可以快速检查某个元素是否属于集合，因为集合的成员检查是高效的。
数据筛选：可以使用集合推导式对数据进行筛选和处理，这在处理数据中是非常常见的。
快速查找：当需要快速查找是否包含某个元素时，集合的查找速度比列表快，因为集合使用哈希表来存储元素。

set 初始化

特点：集合中的元素是唯一的，无序的，且不可变（不可哈希）。集合内部元素无索引，因此不能通过索引进行访问或切片。

创建集合：可以使用set()构造函数创建集合，也可以使用花括号{}来定义集合。

重复元素：集合会自动去除重复的元素，确保所有元素都是唯一的。

# 使用 set() 构造函数
my_set = set([1, 2, 3, 2, 3])
print(type(my_set), my_set)  # 输出: <class 'set'> {1, 2, 3}

# 使用花括号 {}
my_set2 = {4, 5, 6, 5}
print(type(my_set2),my_set2)  # 输出: <class 'set'> {4, 5, 6}

my_set3 = set()
print(type(my_set3),my_set3)  # 输出: <class 'set'> set()

my_set4 = {}
print(type(my_set4),my_set4)  # 输出: <class 'dict'> {}

my_set5 = {[1],(1,),1}
print(type(my_set5),my_set5)  # 输出: TypeError: unhashable type: 'list'

set 增加元素

add(elem)：增加一个元素到set中。如果元素存在，什么都不做。
update(*others)：合并其他元素到set集合中来。参数others必须是可迭代对象。就地修改。

# add（）
my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # 输出: {1, 2, 3, 4}

# 使用 update 方法将 set2 中的元素添加到 set1 中
set1 = {1, 2, 3}
set2 = {3, 4, 5}
set1.update(set2)
print(set1)  # 输出: {1, 2, 3, 4, 5}

# 使用 update 方法将列表中的元素添加到集合中
set3 = {1, 2, 3}
my_list = [4, 5, 3]
set3.update(my_list)
print(set3)  # 输出: {1, 2, 3, 4, 5}

# 使用 update 方法将多个集合中的元素合并到一个集合中
set5 = {1, 2, 3}
set6 = {3, 4, 5}
set7 = {5, 6, 7}
set5.update(set6, set7)
print(set5)  # 输出: {1, 2, 3, 4, 5, 6, 7}

set 删除元素

使用 remove() 方法可以删除指定的元素，如果元素不存在会引发 KeyError。
使用 discard() 方法也可以删除指定的元素，但如果元素不存在不会产生错误。
使用 pop() 方法会随机删除集合中的一个元素，并返回被删除的元素。
使用 clear() 移除所有元素。

my_set = {1, 2, 3}
my_set.remove(2)
print(my_set)  # 输出: {1, 3}

my_set.discard(3)
print(my_set)  # 输出: {1}

my_set.clear()
print(my_set)  # 输出：set()

set 查询元素

可以通过 in 运算符检查元素是否存在于集合中。

my_set = {1, 2, 3}
print(2 in my_set)  # 输出: True
print(4 in my_set)  # 输出: False

set 集合

set 集合概念

全集（Universal Set）：全集是指包含所有可能元素的集合。在Python中，可以使用任何包含所有元素的集合来表示全集。
子集（Subset）：如果集合A中的所有元素都在集合B中，那么集合A是集合B的子集。
并集（Union）：集合的并集包含了两个集合中所有的独特元素。
交集（Intersection）：集合的交集包含同时存在于两个集合中的元素。
差集（Difference）：集合的差集包含存在于第一个集合中但不存在于第二个集合中的元素。
超集（Superset）：如果集合A包含集合B中所有的元素，那么集合A是集合B的超集。

set 并集

集合的并集包含了两个集合中所有的唯一元素。
可以使用union()方法、|运算符 update()方法，以及|=运算符（原地更新）来计算集合的并集。
并集的结果是一个新的集合，包含两个原始集合中的所有唯一元素。

union() 方法：用于计算两个集合的并集。
| 运算符：也用于计算两个集合的并集。
|= 运算符：用于原地更新集合，将左侧的集合更新为其与右侧集合的并集。
update()：和多个集合合并，就地修改。

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 使用 | 运算符计算并集
union_set_operator = set1 | set2
print(union_set_operator)  # 输出: {1, 2, 3, 4, 5}

# 使用 |= 运算符更新集合为并集
set1 |= set2
print(set1)  # 输出: {1, 2, 3, 4, 5}

# 使用update()方法
set1.update(set2)
print(set1)  # 输出: {1, 2, 3, 4, 5}

set 交集

集合的交集包含了同时存在于两个集合中的元素。
可以使用intersection()方法、&运算符，以及intersection_update()方法和&=运算符进行交集运算。
交集的结果是一个新的集合，包含两个原始集合共同的元素。

intersection() 方法：用于计算两个集合的交集。
& 运算符：也用于计算两个集合的交集。
intersection_update() 方法：用于就地更新集合为交集。
&= 运算符：用于原地更新集合为交集。

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 使用 & 运算符计算交集
intersection_set_operator = set1 & set2
print(intersection_set_operator)  # 输出: {3}

# 使用 intersection() 方法计算交集
intersection_set_method = set1.intersection(set2)
print(intersection_set_method)  # 输出: {3}

# 使用 &= 运算符更新集合为交集
set1 &= set2
print(set1)  # 输出: {3}

# 使用 intersection_update() 方法更新集合为交集
set1.intersection_update(set2)
print(set1)  # 输出: {3}

set 差集

集合的差集包含属于第一个集合但不属于其他指定集合的元素。
可以使用difference()方法、-运算符，以及difference_update()方法和-=运算符进行差集运算。
差集的结果是一个新的集合，包含第一个集合中存在但其他指定集合中不存在的元素。

difference() 方法：用于计算第一个集合相对于其他集合的差集。
- 运算符：也用于计算两个集合的差集。
difference_update() 方法：用于就地更新集合为差集。
-= 运算符：用于原地更新集合为差集。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5}

# 使用 - 运算符计算差集
difference_set_operator = set1 - set2
print(difference_set_operator)  # 输出: {1, 2}

# 使用 difference() 方法计算差集
difference_set_method = set1.difference(set2)
print(difference_set_method)  # 输出: {1, 2}

# 使用 -= 运算符更新集合为差集
set1 -= set2
print(set1)  # 输出: {1, 2}

# 使用 difference_update() 方法更新集合为差集
set1.difference(set2)
print(set1)  # 输出：{1, 2}

set 对称差集

集合的对称差集包含两个集合中除了交集外的所有唯一元素。
可以使用symmetric_difference()方法、^运算符，以及symmetric_difference_update()方法和^=运算符进行对称差集运算。
对称差集的结果是一个新的集合，包含两个集合中除了交集外的所有唯一元素。

symmetric_difference() 方法：用于计算两个集合的对称差集。
^ 运算符：也用于计算两个集合的对称差集。
symmetric_difference_update() 方法：用于就地更新集合为对称差集。
^= 运算符：用于原地更新集合为对称差集。

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 使用 ^ 运算符计算对称差集
symmetric_difference_set_operator = set1 ^ set2
print(symmetric_difference_set_operator)  # 输出: {1, 2, 4, 5}

# 使用 symmetric_difference() 方法计算对称差集
symmetric_difference_set_method = set1.symmetric_difference(set2)
print(symmetric_difference_set_method)  # 输出: {1, 2, 4, 5}

# 使用 ^= 运算符更新集合为对称差集
set1 ^= set2
print(set1)  # 输出: {1, 2, 4, 5}

# 使用 symmetric_difference_update() 方法更新集合为对称差集
set1.symmetric_difference(set2)
print(set1)  # 输出: {1, 2, 4, 5}

set 比较

可以使用逻辑运算符（如 == 、!=、< 、>、<=、>=）来比较两个集合是否相等、不相等，或者判断集合的子集关系

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5}

# 相等（==）：检查两个集合是否相等
print(set1 == set2)  # 输出: False

# 不相等（!=）：检查两个集合是否不相等
print(set1 != set2)  # 输出: True

# 子集（<）：检查第一个集合是否是第二个集合的子集
print(set1 < set2)   # 输出: False

# 子集（子集或相等）（<=）：检查第一个集合是否是第二个集合的子集。
print(set1 <= set2)  # 输出: False

# 真子集（>）：检查第一个集合是否是第二个集合的真子集
print(set1 > set2)   # 输出: False

# 超集（>=）：检查第一个集合是否是第二个集合的超集
print(set1 >= set2)  # 输出: False

set1 = {1, 2, 3, 4}
set2 = {2, 3}
set3 = {5, 6}

# 检查 set2 是否是 set1 的子集
print(set2.issubset(set1))  # 输出: True

# 检查 set1 是否是 set2 的超集
print(set1.issuperset(set2))  # 输出: True

# 检查 set3 是否是 set1 的子集
print(set3.issubset(set1))  # 输出: False

# 检查 set1 和 set3 是否不相交
print(set1.isdisjoint(set3))  # 输出: True

参考文档

https://docs.python.org/zh-cn/3.12/library/stdtypes.html#/set-types-set-frozenset