目录
5-3-14、symmetric_difference()方法
5-3-15、symmetric_difference_update()方法
一、集合
1、集合的定义
在Python中，集合(set)是一种无序且不包含重复元素的数据类型。集合是可变的，但它是无序的，所以不支持索引或切片操作，你可以使用集合来执行成员检测、消除重复元素等操作。
2、集合的语法
你可以使用花括号{}或set()函数来创建集合，但是，如果你使用花括号{}并且没有包含任何元素，Python会将其解释为一个空字典，而不是一个空集合，因此，在创建空集合时，你应该使用set()函数。
3、获取集合的属性和方法
用dir()函数获取set所有属性和方法的列表
print(dir(set))
# ['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__',
# '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__',
# '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__',
# '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__',
# '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy',
# 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset',
# 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']4、获取集合的帮助信息
用help()函数获取set的帮助信息
help(set)
# Help on class set in module builtins:
#
# class set(object)
# | set() -> new empty set object
# | set(iterable) -> new set object
# |
# | Build an unordered collection of unique elements.
# |
# | Methods defined here:
# |
# | __and__(self, value, /)
# | Return self&value.
# |
# | __contains__(...)
# | x.__contains__(y) <==> y in x.
# |
# | __eq__(self, value, /)
# | Return self==value.
# |
# | __ge__(self, value, /)
# | Return self>=value.
# |
# | __getattribute__(self, name, /)
# | Return getattr(self, name).
# |
# | __gt__(self, value, /)
# | Return self>value.
# |
# | __iand__(self, value, /)
# | Return self&=value.
# |
# | __init__(self, /, *args, **kwargs)
# | Initialize self. See help(type(self)) for accurate signature.
# |
# | __ior__(self, value, /)
# | Return self|=value.
# |
# | __isub__(self, value, /)
# | Return self-=value.
# |
# | __iter__(self, /)
# | Implement iter(self).
# |
# | __ixor__(self, value, /)
# | Return self^=value.
# |
# | __le__(self, value, /)
# | Return self<=value.
# |
# | __len__(self, /)
# | Return len(self).
# |
# | __lt__(self, value, /)
# | Return self<value.
# |
# | __ne__(self, value, /)
# | Return self!=value.
# |
# | __or__(self, value, /)
# | Return self|value.
# |
# | __rand__(self, value, /)
# | Return value&self.
# |
# | __reduce__(...)
# | Return state information for pickling.
# |
# | __repr__(self, /)
# | Return repr(self).
# |
# | __ror__(self, value, /)
# | Return value|self.
# |
# | __rsub__(self, value, /)
# | Return value-self.
# |
# | __rxor__(self, value, /)
# | Return value^self.
# |
# | __sizeof__(...)
# | S.__sizeof__() -> size of S in memory, in bytes
# |
# | __sub__(self, value, /)
# | Return self-value.
# |
# | __xor__(self, value, /)
# | Return self^value.
# |
# | add(...)
# | Add an element to a set.
# |
# | This has no effect if the element is already present.
# |
# | clear(...)
# | Remove all elements from this set.
# |
# | copy(...)
# | Return a shallow copy of a set.
# |
# | difference(...)
# | Return the difference of two or more sets as a new set.
# |
# | (i.e. all elements that are in this set but not the others.)
# |
# | difference_update(...)
# | Remove all elements of another set from this set.
# |
# | discard(...)
# | Remove an element from a set if it is a member.
# |
# | Unlike set.remove(), the discard() method does not raise
# | an exception when an element is missing from the set.
# |
# | intersection(...)
# | Return the intersection of two sets as a new set.
# |
# | (i.e. all elements that are in both sets.)
# |
# | intersection_update(...)
# | Update a set with the intersection of itself and another.
# |
# | isdisjoint(...)
# | Return True if two sets have a null intersection.
# |
# | issubset(self, other, /)
# | Test whether every element in the set is in other.
# |
# | issuperset(self, other, /)
# | Test whether every element in other is in the set.
# |
# | pop(...)
# | Remove and return an arbitrary set element.
# | Raises KeyError if the set is empty.
# |
# | remove(...)
# | Remove an element from a set; it must be a member.
# |
# | If the element is not a member, raise a KeyError.
# |
# | symmetric_difference(...)
# | Return the symmetric difference of two sets as a new set.
# |
# | (i.e. all elements that are in exactly one of the sets.)
# |
# | symmetric_difference_update(...)
# | Update a set with the symmetric difference of itself and another.
# |
# | union(...)
# | Return the union of sets as a new set.
# |
# | (i.e. all elements that are in either set.)
# |
# | update(...)
# | Update a set with the union of itself and others.
# |
# | ----------------------------------------------------------------------
# | Class methods defined here:
# |
# | __class_getitem__(...) from builtins.type
# | See PEP 585
# |
# | ----------------------------------------------------------------------
# | Static methods defined here:
# |
# | __new__(*args, **kwargs) from builtins.type
# | Create and return a new object. See help(type) for accurate signature.
# |
# | ----------------------------------------------------------------------
# | Data and other attributes defined here:
# |
# | __hash__ = None5、集合的用法
5-1、创建集合
5-1-1、创建空集合(必须使用set()函数)
# 创建空集合(须使用set()函数）
empty_set = set()
print(type(empty_set)) # 输出：<class 'set'>5-1-2、使用花括号创建集合(包含元素)
# 使用花括号创建集合(包含元素)
my_set = {1, 2, 3, 4}
print(type(my_set)) # 输出：<class 'set'>5-1-3、使用set()函数创建集合(包含元素)
# 使用set()函数创建集合(包含元素)
another_set = set([1, 2, 3, 4])
print(type(another_set)) # 输出：<class 'set'>5-1-4、尝试使用花括号创建空集合(会被解释为空字典)
# 尝试使用花括号创建空集合(会被解释为空字典)
wrong_empty_set = {} # 这将是一个空字典，而不是空集合
print(type(wrong_empty_set)) # 输出：<class 'dict'>5-2、集合的操作
5-2-1、添加元素
# 添加元素
my_set = {3, 5, 6, 8, 10, 11, 24}
my_set.add(7)
print(my_set) # 输出：{3, 5, 6, 7, 8, 24, 10, 11}5-2-2、删除元素
# 删除元素
my_set = {3, 5, 6, 8, 10, 11, 24}
# my_set.remove(9) # 如果元素不存在，会抛出KeyError，可以使用discard()代替
my_set.remove(5)
print(my_set) # 输出：{3, 6, 8, 24, 10, 11}5-2-3、检查元素是否存在
# 检查元素是否存在
my_set = {3, 5, 6, 8, 10, 11, 24}
if 6 in my_set:
print("6 is in the set") # 输出：6 is in the set5-2-4、交集
# 交集
my_set = {3, 5, 6, 8, 10, 11, 24}
another_set = {7, 8, 12}
intersection = my_set & another_set
print(intersection) # 输出：{8}5-2-5、并集
# 并集
my_set = {3, 5, 6, 8, 10, 11, 24}
another_set = {7, 8, 12}
union = my_set | another_set
print(union) # 输出：{3, 5, 6, 7, 8, 10, 11, 12, 24}5-2-6、差集
# 差集(my_set中有的但another_set中没有的)
my_set = {3, 5, 6, 8, 10, 11, 24}
another_set = {7, 8, 12}
difference = my_set - another_set
print(difference) # 输出：{3, 5, 6, 10, 11, 24}5-2-7、对称差集
# 对称差集(在my_set或another_set中，但不同时在两个中的元素)
my_set = {3, 5, 6, 8, 10, 11, 24}
another_set = {7, 8, 12}
symmetric_difference = my_set ^ another_set
print(symmetric_difference) # 输出：{3, 5, 6, 7, 10, 11, 12, 24}5-2-8、更新集合
# 更新集合，添加another_set中的所有元素，但不包括已经在my_set中的元素
my_set = {3, 5, 6, 8, 10, 11, 24}
another_set = {7, 8, 12}
my_set.update(another_set)
print(my_set) # 输出：{3, 5, 6, 7, 8, 10, 11, 12, 24}5-3、集合的用法
5-3-1、add()方法
# 1、方法：set_name.add
# 2、语法：set_name.add(element)
# 3、参数：
# 3-1、set_name：表示set对象的名称
# 3-2、element：表示你想要添加到集合中的元素
# 4、功能：用于向集合中添加一个元素
# 5、返回值：一个新的集合
# 6、说明：
# 6-1、由于set是无序的，所以打印集合时元素的顺序可能会不同，但是，集合的内容(即包含的元素)将保持不变
# 6-2、如果你尝试将一个集合(或其他可迭代对象)中的所有元素添加到另一个集合中，可以使用update()方法，而不是多次调用add()方法
# 7、示例：
# 创建一个空的set
my_set = set()
# 使用add()方法添加元素
my_set.add(1)
my_set.add(2)
my_set.add(3)
# 打印集合
print(my_set) # 输出：{1, 2, 3}或{3, 2, 1}，因为set是无序的
# 尝试添加已存在的元素，这不会有任何效果(因为set不包含重复元素)
my_set.add(2)
print(my_set) # 输出：{1, 2, 3}或{3, 2, 1}，因为set是无序的5-3-2、clear()方法
# 1、方法：set_name.clear
# 2、语法：set_name.clear()
# 3、参数：
# 3-1、set_name：表示set对象的名称
# 4、功能：用于移除集合中的所有元素，将其变为一个空集合
# 5、返回值：一个空集合
# 6、说明：
# 6-1、clear()方法会直接修改原集合，而不是返回一个新的集合；如果你需要保留原始集合并创建一个新的空集合，你应该使用set()构造函数来创建一个新的空集合
# 7、示例：
# 创建一个包含几个元素的set
my_set = {1, 2, 3, 4, 5}
# 打印原始集合
print(my_set) # 输出：可能是{1, 2, 3, 4, 5}或类似(因为set是无序的)
# 使用clear()方法清空集合
my_set.clear()
# 打印清空后的集合
print(my_set) # 输出:set()，集合已变为空集合
# 再次尝试打印集合元素(可选，以确认集合为空)
for element in my_set:
print(element) # 由于集合为空，这一行不会被执行5-3-3、copy()方法
# 1、方法：original_set.copy
# 2、语法：new_set = original_set.copy()
# 3、参数：
# 3-1、original_set：表示你想要复制的原始set对象的名称
# 3-2、new_set：一个新的set对象，它包含original_set的元素
# 4、功能：用于创建一个集合的浅拷贝(shallow copy)
# 5、返回值：浅拷贝会创建一个新的集合对象，并复制原集合中所有的元素
# 6、说明：
# 6-1、浅拷贝创建的新集合对象，与原集合属于不同的对象，它们仅仅只是包含的元素完全相同，鉴于集合的无序性，打印时的顺序不一定相同
# 7、示例：
# 创建一个包含几个元素的set
original_set = {1, 2, 3, 4, 5}
# 使用copy()方法创建一个新的集合
new_set = original_set.copy()
# 打印原始集合
print("Original set:", original_set) # 输出：Original set: {1, 2, 3, 4, 5}
# 打印新集合
print("New set:", new_set) # 输出：New set: {1, 2, 3, 4, 5}
# 修改原始集合
original_set.add(6)
# 再次打印两个集合
print("Modified original set:", original_set) # 输出：Modified original set: {1, 2, 3, 4, 5, 6}
print("New set(unchanged):", new_set) # 输出:New set(unchanged): {1, 2, 3, 4, 5}
# 创建深拷贝(如果需要)
# 如果你需要创建一个真正的“深拷贝”(即，拷贝所有的层次)，你可以使用copy模块中的deepcopy()函数
import copy
# 创建一个集合
original_set = {1, 2, 3, 4, 5}
# 使用deepcopy()方法创建深拷贝
deep_copied_set = copy.deepcopy(original_set)
# 修改深拷贝集合
deep_copied_set.add(8)
# 打印原集合和深拷贝后的集合
print("原集合:", original_set) # 输出：原集合: {1, 2, 3, 4, 5} 原集合中的元素并未新增，因为deepcopy()创建了原集合中所有层次的完全独立的副本
print("深拷贝后的集合:", deep_copied_set) # 输出：深拷贝后的集合: {1, 2, 3, 4, 5, 8}5-3-4、difference()方法
# 1、方法：set1.difference
# 2、语法：
# 2-1、set1.difference(set2)
# 2-2、set1 - set2
# 3、参数：
# 3-1、set1(必须)：表示一个做为参考基准的目标集合
# 3-2、set2(必须)：表示一个与目标集合做对比的集合
# 4、功能：用于计算两个集合之间的差集的方法
# 5、返回值：返回一个新的集合，该集合包含所有在set1中但不在set2中的元素
# 6、说明：
# 7、示例：
# 创建两个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# 使用difference()方法
difference_set = set1.difference(set2)
print(difference_set) # 输出: {1, 2, 3}
# 使用-运算符
difference_set_operator = set1 - set2
print(difference_set_operator) # 输出: {1, 2, 3}5-3-5、difference_update()方法
# 1、方法：set.difference_update
# 2、语法：set.difference_update(other_set)
# 3、参数：
# 3-1、set(必须)：表示一个做为参考基准的目标集合
# 3-2、other_set(可选)：表示与目标集合做对比的其他集合，可以是空集合
# 4、功能：用于从集合中移除那些在另一个集合中存在的元素
# 5、返回值：直接修改后的原集合
# 6、说明：
# 6-1、与difference()方法不同，difference_update()会直接修改原集合，而不是返回一个新的集合
# 7、示例：
# 创建三个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set()
# 使用difference_update()方法
set1.difference_update(set2)
print(set1) # 输出: {1, 2, 3}，set1被修改了
# 注意到set2没有改变
print(set2) # 输出: {4, 5, 6, 7, 8}
# other_set不设定集合对象
set2.difference_update()
print(set2) # 输出: {4, 5, 6, 7, 8}
# other_set设定为空集合
set2.difference_update(set3)
print(set2) # 输出: {4, 5, 6, 7, 8}5-3-6、discard()方法
# 1、方法：set.discard
# 2、语法：set.discard(element)
# 3、参数：
# 3-1、set(必须)：表示一个做为参考基准的原集合
# 3-2、element(必须)：表示待从原集合中移除的一个指定元素
# 4、功能：用于尝试从集合中移除一个指定的元素
# 5、返回值：在原集合基础上移除指定元素后形成的集合，若指定元素不存在于原集合中，则返回原集合
# 6、说明：
# 6-1、如果元素存在于集合中，它将被移除；如果元素不存在于集合中，则不会有任何错误或异常抛出
# 7、示例：
# 创建一个集合
my_set = {1, 2, 3, 4, 5}
# 使用discard()方法尝试移除元素
my_set.discard(3) # 元素3存在，将被移除
print(my_set) # 输出: {1, 2, 4, 5}
# 尝试移除一个不存在的元素
my_set.discard(6) # 元素6不存在，不会有任何影响
print(my_set) # 输出: {1, 2, 4, 5}，集合没有改变5-3-7、intersection()方法
# 1、方法：set1.intersection
# 2、语法：
# 2-1、set1.intersection(set2)
# 2-2、set1.intersection(set2, set3, ...)
# 2-3、set1.intersection(*other_sets) 其中other_sets是一个包含其他集合的序列
# 3、参数：
# 3-1、set1(必须)：表示一个做为参考基准的原集合
# 3-2、set2/set3/*other_sets(可选)：表示与原集合做对比的其他一个或多个集合
# 4、功能：用于返回两个或更多集合的交集，即返回包含在所有集合中都有的元素的新集合
# 5、返回值：
# 5-1、无交集：返回一个空集合
# 5-2、有交集：返回一个非空的新集合
# 6、说明：
# 6-1、intersection()方法不会修改原始的集合，而是返回一个新的集合
# 7、示例：
# 7-1、两个集合的交集
# 创建两个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# 计算交集
result = set1.intersection(set2)
# 打印结果
print(result) # 输出: {4, 5}
# 7-2、多个集合的交集
# 创建三个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = {5, 8, 9, 10}
# 使用 * 操作符计算交集
result = set1.intersection(set2, set3)
# 或者使用包含集合的列表
other_sets = [set2, set3]
result = set1.intersection(*other_sets)
# 打印结果
print(result) # 输出: {5}5-3-8、intersection_update()方法
# 1、方法：set1.intersection_update
# 2、语法：
# 2-1、set1.intersection_update(set2)
# 2-2、set1.intersection_update(set2, set3, ...)
# 2-3、set1.intersection_update(*other_sets) 其中other_sets是一个包含其他集合的序列
# 3、参数：
# 3-1、set1(必须)：表示一个做为参考基准的原集合
# 3-2、set2/set3/*other_sets(可选)：表示与原集合做对比的其他一个或多个集合
# 4、功能：用于更新一个集合，使其只包含该集合和指定集合(或集合序列)的交集
# 5、返回值：经过处理的原集合
# 6、说明：
# 6-1、与intersection()方法不同，intersection_update()会直接修改原集合，而不是返回一个新的集合
# 6-2、如果你需要保留原集合，你应该先使用intersection()方法来计算交集，然后将结果赋值给一个新的变量
# 7、示例：
# 7-1、两个集合的交集更新
# 创建两个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# 使用intersection_update()更新 set1
set1.intersection_update(set2)
# 打印更新后的set1
print(set1) # 输出: {4, 5}
# 7-2、多个集合的交集更新
# 创建三个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = {5, 8, 9, 10}
# 使用intersection_update()更新set1
set1.intersection_update(set2, set3)
# 或者使用包含集合的列表
other_sets = [set2, set3]
set1.intersection_update(*other_sets)
# 打印更新后的set1
print(set1) # 输出: {5}5-3-9、isdisjoint()方法
# 1、方法：set1.isdisjoint
# 2、语法：set1.isdisjoint(set2)
# 3、参数：
# 3-1、set1(必须)：表示一个做为参考基准的原集合
# 3-2、set2(必须)：表示与原集合做对比的其他集合，可以是空集合
# 4、功能：用于检查两个集合是否没有交集
# 5、返回值：一个布尔值
# 6、说明：
# 6-1、如果两个集合没有共同的元素，则isdisjoint()返回True；如果它们有至少一个共同的元素，则返回False
# 6-2、isdisjoint()方法不会修改任何集合，它只是返回一个布尔值来表示两个集合是否有交集
# 7、示例：
# 7-1、两个没有交集的集合
# 创建两个没有交集的集合
set1 = {1, 2, 3}
set2 = {4, 5, 6}
# 使用isdisjoint()检查它们是否有交集
result = set1.isdisjoint(set2)
# 打印结果
print(result) # 输出: True
# 7-2、两个有交集的集合
# 创建两个有交集的集合
set1 = {1, 2, 3, 4}
set2 = {4, 5, 6}
# 使用isdisjoint()检查它们是否有交集
result = set1.isdisjoint(set2)
# 打印结果
print(result) # 输出: False5-3-10、issubset()方法
# 1、方法：set1.issubset
# 2、语法：
# 2-1、set1.issubset(set2)
# 2-2、set1 <= set2
# 3、参数：
# 3-1、set1(必须)：表示一个做为参考基准的原集合
# 3-2、set2(必须)：表示与原集合做对比的其他集合，可以是空集合
# 4、功能：用于检查一个集合是否是另一个集合的子集
# 5、返回值：一个布尔值
# 6、说明：
# 6-1、如果第一个集合的所有元素都存在于第二个集合中，则结果为True；否则为False
# 6-2、issubset()方法不会修改任何集合，它只是返回一个布尔值来表示两个集合之间的子集关系
# 7、示例：
# 7-1、一个集合是另一个集合的子集
# 创建两个集合
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}
# 使用issubset()检查set1是否是set2的子集
result = set1.issubset(set2)
# 打印结果
print(result) # 输出: True
# 或者使用<=运算符
result = set1 <= set2
print(result) # 输出: True
# 7-2、一个集合不是另一个集合的子集
# 创建两个集合
set1 = {1, 2, 3, 6}
set2 = {1, 2, 3, 4, 5}
# 使用issubset()检查set1是否是set2的子集
result = set1.issubset(set2)
# 打印结果
print(result) # 输出: False
# 或者使用 <= 运算符
result = set1 <= set2
print(result) # 输出: False5-3-11、issuperset()方法
# 1、方法：set1.issuperset
# 2、语法：
# 2-1、set1.issuperset(set2)
# 2-2、set1 >= set2
# 3、参数：
# 3-1、set1(必须)：表示一个做为参考基准的原集合
# 3-2、set2(必须)：表示与原集合做对比的其他集合，可以是空集合
# 4、功能：用于检查一个集合是否是另一个集合的超集
# 5、返回值：一个布尔值
# 6、说明：
# 6-1、如果第一个集合包含第二个集合的所有元素，则结果为True；否则为False
# 6-2、issuperset()方法不会修改任何集合，它只是返回一个布尔值来表示两个集合之间的超集关系
# 7、示例：
# 7-1、一个集合是另一个集合的超集
# 创建两个集合
set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3}
# 使用issuperset()检查set1是否是set2的超集
result = set1.issuperset(set2)
# 打印结果
print(result) # 输出: True
# 或者使用 >= 运算符
result = set1 >= set2
print(result) # 输出: True
# 7-2、一个集合不是另一个集合的超集
# 创建两个集合
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}
# 使用issuperset()检查set1是否是set2的超集
result = set1.issuperset(set2)
# 打印结果
print(result) # 输出: False
# 或者使用 >= 运算符
result = set1 >= set2
print(result) # 输出: False5-3-12、pop()函数
# 一个模拟set.pop()行为的自定义函数
def set_pop(s):
if not s:
raise KeyError('pop from an empty set')
# 将集合转换为列表，弹出第一个元素，然后更新集合
item = list(s)[0]
s.remove(item)
return item
# 示例用法
my_set = {1, 2, 3, 4, 5}
item = set_pop(my_set)
print(item) # 输出：1
print(my_set) # 输出：{2, 3, 4, 5}5-3-13、remove()方法
# 1、方法：set.remove
# 2、语法：set.remove(element)
# 3、参数：
# 3-1、set(必须)：表示一个做为参考基准的原集合
# 3-2、element(必须)：表示待从原集合中移除的一个指定元素
# 4、功能：用于从集合中移除指定的元素
# 5、返回值：在原集合基础上移除指定元素后形成的集合，若指定元素不存在于原集合中，则返回原集合
# 6、说明：
# 6-1、如果元素存在于集合中，则将其移除；如果元素不存在，则会引发一个KeyError异常
# 6-2、如果你不确定元素是否存在于集合中，并且不希望因为尝试移除不存在的元素而引发异常，那么discard()方法是一个更好的选择
# 7、示例：
# 7-1、成功移除元素
# 创建一个集合
my_set = {1, 2, 3, 4, 5}
# 移除元素 3
my_set.remove(3)
# 打印集合
print(my_set) # 输出: {1, 2, 4, 5}
# 7-2、尝试移除不存在的元素(将引发异常)
# 创建一个集合
my_set = {1, 2, 3, 4, 5}
# 尝试移除元素6(不存在于集合中)
try:
my_set.remove(6)
except KeyError:
print("元素6不存在于集合中") # 输出：元素6不存在于集合中
# 打印集合
print(my_set) # 输出: {1, 2, 3, 4, 5}5-3-14、symmetric_difference()方法
# 1、方法：set1.symmetric_difference
# 2、语法：
# 2-1、set1.symmetric_difference(set2)
# 2-2、set1 ^ set2
# 3、参数：
# 3-1、set1(必须)：表示一个做为参考基准的原集合
# 3-2、set2(必须)：表示与原集合做对比的其他集合，可以是空集合
# 4、功能：用于计算两个集合的对称差集
# 5、返回值：返回一个新的集合，其中包含对称差集的结果
# 6、说明：
# 6-1、symmetric_difference()方法不会修改原始的集合，而是返回一个新的集合，其中包含对称差集的结果
# 6-2、你可以使用symmetric_difference_update()方法来更新一个集合，使其包含与另一个集合的对称差集，这个方法会修改原始的集合
# 7、示例：
# 7-1、计算两个集合的对称差集
# 创建两个集合
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
# 使用symmetric_difference()方法计算对称差集
symmetric_diff = set1.symmetric_difference(set2)
# 打印结果
print(symmetric_diff) # 输出: {1, 2, 5, 6}
# 使用^运算符计算对称差集
symmetric_diff_op = set1 ^ set2
print(symmetric_diff_op) # 输出: {1, 2, 5, 6}
# 7-2、使用空集合计算对称差集
# 创建一个集合和一个空集合
set1 = {1, 2, 3}
set2 = set()
# 使用symmetric_difference()方法计算对称差集
symmetric_diff = set1.symmetric_difference(set2)
# 打印结果
print(symmetric_diff) # 输出: {1, 2, 3}
# 使用^运算符计算对称差集
symmetric_diff_op = set1 ^ set2
print(symmetric_diff_op) # 输出: {1, 2, 3}5-3-15、symmetric_difference_update()方法
# 1、方法：set.symmetric_difference_update
# 2、语法：set.symmetric_difference_update(other_set)
# 3、参数：
# 3-1、set1(必须)：表示一个做为参考基准的原集合
# 3-2、other_set(可选)：表示与原集合做对比的其他集合，可以是空集合
# 4、功能：用于更新一个集合，使其包含与另一个集合的对称差集，这意味着它会移除两个集合中都存在的元素，并添加仅存在于其中一个集合中的元素。
# 5、返回值：经过处理后的原集合
# 6、说明：
# 6-1、symmetric_difference_update()方法直接修改调用它的集合，而不是返回一个新的集合
# 6-2、如果想保留原始集合不变并获取对称差集，应该使用symmetric_difference()方法
# 7、示例：
# 7-1、使用symmetric_difference_update()更新集合
# 创建两个集合
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
# 使用symmetric_difference_update()更新set1
set1.symmetric_difference_update(set2)
# 打印更新后的set1
print(set1) # 输出: {1, 2, 5, 6}
# 注意：set1已经被修改，它现在包含与set2的对称差集
# 7-2、使用空集合进行symmetric_difference_update()
# 创建一个集合和一个空集合
set1 = {1, 2, 3}
set2 = set()
# 使用symmetric_difference_update()更新set1
set1.symmetric_difference_update(set2)
# 打印更新后的set1
print(set1) # 输出: {1, 2, 3}
# 因为set2是空的，所以set1没有发生变化5-3-16、union()方法
# 1、方法：set1.union
# 2、语法：
# 2-1、set1.union(set2, ...)
# 2-2、set1 | set2 | ...
# 3、参数：
# 3-1、set1(必须)：表示一个做为参考基准的原集合
# 3-2、set2(可选)：表示与原集合做合并处理的其他集合，可以是空集合
# 4、功能：用于合并两个或多个集合中的所有元素，并返回一个新的集合，其中包含所有独特的元素(注：独特，表示保持元素的唯一性)
# 5、返回值：一个新的集合，其中包含所有独特的元素
# 6、说明：
# 6-1、如果某个元素在两个集合中都存在，它只会在结果集合中出现一次
# 6-2、union()方法不会修改原始集合，而是返回一个新的集合，其中包含所有输入集合的并集
# 7、示例：
# 7-1、使用union()方法合并两个集合
# 创建两个集合
set1 = {1, 2, 3}
set2 = {3, 4, 5}
# 使用union()方法合并集合
union_set = set1.union(set2)
# 打印结果
print(union_set) # 输出: {1, 2, 3, 4, 5}
# 7-2、使用 | 运算符合并两个集合
# 创建两个集合
set1 = {1, 2, 3}
set2 = {3, 4, 5}
# 使用 | 运算符合并集合
union_set = set1 | set2
# 打印结果
print(union_set) # 输出: {1, 2, 3, 4, 5}
# 7-3、合并多个集合
# 创建三个集合
set1 = {1, 2, 3}
set2 = {3, 4, 5}
set3 = {5, 6, 7}
# 使用union()方法合并多个集合
union_set = set1.union(set2, set3)
# 打印结果
print(union_set) # 输出: {1, 2, 3, 4, 5, 6, 7}5-3-17、update()方法
# 1、方法：set.update
# 2、语法：set.update(iterable, ...)
# 3、参数：
# 3-1、iterable：一个或多个可迭代对象，如列表、元组、集合等
# 4、功能：用于向集合中添加元素
# 5、返回值：修改原始集合或返回None
# 6、说明：
# 6-1、update()方法会修改原始集合，向其添加元素，但不会返回新的集合(它返回None)
# 6-2、如果要添加的元素已经存在于集合中，update()方法不会有任何效果
# 6-3、当你传递多个可迭代对象给update()方法时，它会依次处理每个可迭代对象，并将它们中的所有元素添加到集合中
# 7、示例：
# 7-1、使用update()方法向集合中添加元素
# 创建一个集合
my_set = {1, 2, 3}
# 使用update()方法添加元素
my_set.update([4, 5]) # 添加列表中的元素
# 打印更新后的集合
print(my_set) # 输出: {1, 2, 3, 4, 5}
# 7-2、使用update()方法添加多个元素和集合
# 创建一个集合
my_set = {1, 2, 3}
# 使用update()方法添加多个元素和另一个集合
my_set.update([4, 5], {6, 7}) # 添加列表和集合中的元素
# 打印更新后的集合
print(my_set) # 输出: {1, 2, 3, 4, 5, 6, 7}