1.集合的概念

  在Python中，集合（Set）是一种无序、不重复的数据类型，它的实现基于哈希表，是由唯一元素组成的。集合中不允许有重复的元素，即相同元素只能出现一次。Python中的集合类似于数学中的集合，可以执行常见的集合操作，如并集、交集、差集等。

2.集合的创建

  使用大括号{} 或者set() 函数来创建集合。注意，空集合必须使用 set() 而不是 {}，因为{} 创建的是空字典。使用{}创建只有一个元素的集合时，元素后面必须带上逗号,

# 使用set()创建空集合
empty_set = set()

set_number = set([6,3,23,7,9])
set_fruits = {'apple','banana','orange','pear','grape'}

print(f'空集合：{empty_set}') # 输出 set()
print(f'set方法创建的集合：{set_number}') # 输出 {3, 6, 7, 9, 23}
print('花括号创建的集合：{0}'.format(set_fruits)) # 输出 {'orange', 'pear', 'apple', 'grape', 'banana'}

# 判断元素是否在集合中 用 in
print('orange' in set_fruits) # 输出 True
print('cherries' in set_fruits) # 输出 False

3.集合的方法

  集合（set）在Python中有各种方法17个，主要分为基本操作（包括添加、删除、更新等），集合操作（并集、差集、交集）、判断集合性质（比较是否有交集、是否有差集）和其他方法。

3.1 基本操作

3.1.1 add()

  用于向集合中添加一个元素。该方法是一个原地操作，会修改调用方法的集合。如果添加的元素已经存在于集合中，则不会执行任何操作。

add_set = {'apple','banana'}
add_set.add('pear')
print(f'增加pear元素后的集合：{add_set}') # 输出 {'apple', 'banana', 'pear'}

add_set.add('apple') # 已存在的元素不会执行任何操作
print(add_set) # 输出 {'apple', 'banana', 'pear'}  

3.1.2 pop()

  用于移除并返回集合中的任意一个元素,会修改调用方法的集合。由于集合是无序的，所以不能确定具体移除的是哪个元素，但这个方法总是返回一个元素。
  注意，pop()不返回新的集合，而是直接修改调用方法的集合。如果集合为空，调用 pop()会引发 KeyError

set_fruits = {'apple','banana','pear','orange','grape'}
print(f'原始集合：{set_fruits}')
print(f'移除集合的元素：{set_fruits.pop()}')
print(f'移除一个元素后的集合：{set_fruits}')

set_empty = set()
set_empty.pop() # KeyError: 'pop from an empty set'

3.1.3 remove()

  用于移除集合中的指定元素，会修改调用方法的集合。如果指定的元素不存在于集合中，remove() 方法会引发KeyError。

set_fruits = {'apple','banana','pear','orange','grape'}
set_fruits.remove('pear')
print(f'删除pear元素后的集合：{set_fruits}')

set_fruits.remove('不是水果！报错') # KeyError: '不是水果！报错'

3.1.4 clear()

  用于清空集合，即移除集合中的所有元素，使其变为空集合，会修改调用方法的集合。

set_fruits = {'apple','banana','pear','orange','grape'}
print(f'原始集合：{set_fruits}')
set_fruits.clear()
print(f'清空后集合：{set_fruits}') # 输出 清空后集合：set()

3.1.5 discard()

  用于移除集合中的指定元素，会修改调用方法的集合。
  与 remove() 不同的是，如果指定的元素不存在于集合中，discard() 方法不会引发KeyError，而是默默地执行而不产生错误。

set_fruits = {'apple','banana','pear','orange','grape'}
set_fruits.discard('pear')
print(f'删除pear元素后的集合：{set_fruits}')

set_fruits.discard('不是水果！不报错') # 不报错

3.1.6 copy()

  用于复制集合。它返回一个新的集合，其中包含与原始集合相同的元素。

set_fruits = {'apple','banana','pear','orange','grape'}
new_set_fruits = set_fruits.copy()

print(f'原始集合：{set_fruits}')
print(f'copy的集合与原始集合一样：{new_set_fruits}')

3.1.7 update()

  用于将可迭代对象（通常是另一个集合、列表或其他可迭代的对象）中的元素添加到集合中，会修改调用方法的集合。

set_fruits = {'apple',}

set_fruits.update({'pear','grape'}) # 添加集合 
print(f'添加集合后的集合：{set_fruits}')

set_fruits.update(['orange','cherries']) # 添加列表
print(f'添加列表后的集合：{set_fruits}')

set_fruits.update(('水果1','banana')) # 添加元组
print(f'添加元组后的集合：{set_fruits}')

3.1.8 len()

  函数用于获取集合中元素的个数。它返回一个表示集合中元素数量的整数值。

set_fruits = {'apple','banana','pear','orange','grape'}
set_count = len(set_fruits)
print(f'水果集合的元素个数：{set_count}个') # 输出 水果集合的元素个数：5个

3.2 判断集合性质的方法

3.2.1 isdisjoint()

  用于判断两个集合是否没有交集，如果两个集合没有共同的元素，即它们是不相交的，该方法返回 True。如果两个集合有共同的元素，即它们存在交集，该方法返回False

setA= {1,3,5}
setB = {6,8,10}
setC = {3,5,7}

result_True = setA.isdisjoint(setB)
print(f'setA 和 setB 没有共同的元素：{result_True}')

result_False = setA.isdisjoint(setC)
print(f'setA 和 setC 没有共同的元素：{result_False}')

3.2.2 issubset()

  用于判断一个集合是否是另一个集合的子集。如果集合 A的所有元素都是集合 B 的元素，那么集合 A就是集合 B的子集。这个方法返回布尔值，如果集合 A 是集合 B 的子集，则返回True，否则返回False。

setA = {1,3,5,7}
setB = {3,5,7}
setC = {2,4,6}

result_True = setB.issubset(setA)
print(f'setB 是 setA 的子集：{result_True}')

result_False = setC.issubset(setA)
print(f'setC 是 setA 的子集：{result_False}')

3.2.3 issuperset()

  用于判断一个集合是否是另一个集合的超集。如果集合 A包含了集合 B 的所有元素，那么集合 A 就是集合 B的超集。这个方法返回布尔值，如果集合 A是集合 B的超集，则返回 True，否则返回 False。

setA = {1,3,5,7}
setB = {3,5,7}
setC = {2,4,5}

result_True = setA.issuperset(setB)
print(f'setA 是 setB 的超集：{result_True}')

result_False = setA.issuperset(setC)
print(f'setA 是 setC 的超集：{result_False}')

3.3 集合的操作

3.3.1 union()

  用于返回两个集合的并集，即包含两个集合所有不重复元素的新集合。该方法不会修改原始集合，而是返回一个新的集合。

set_fruits1 = {'apple','banana'}
set_fruits2 = {'apple','pear','grape'}

set_fruits = set_fruits1.union(set_fruits2)
print(f'并集后的集合：{set_fruits}') # 输出 {'apple', 'pear', 'banana', 'grape'}

3.3.2 difference()

  用于返回两个集合的差集，即返回一个新集合，其中包含只在第一个集合中出现而在第二个集合中不存在的元素。该方法不会修改原始集合，而是返回一个新的集合。

set_fruits1 = {'apple','banana','cherries'}
set_fruits2 = {'apple','pear','grape'}

set_fruits = set_fruits1.difference(set_fruits2)
print(f'差集后的集合：{set_fruits}') # 输出 {'banana', 'cherries'}

3.3.3 difference_update()

  用于移除集合中与另一个集合相同的元素。该方法直接在原始集合上进行操作，不返回新的集合。
  与 difference() 不同，difference_update() 直接修改原始集合。

set_fruits1 = {'apple','banana','cherries'}
set_fruits2 = {'apple','pear','grape'}

set_fruits1.difference_update(set_fruits2)
print(f'移除相同元素后的集合：{set_fruits1}') # 输出 {'banana', 'cherries'}

3.3.4 intersection()

  用于返回两个集合的交集，即返回一个新集合，其中包含同时出现在两个集合中的所有元素。该方法不会修改原始集合，而是返回一个新的集合。

set_fruits1 = {'apple','banana','cherries'}
set_fruits2 = {'apple','pear','grape','cherries'}

results = set_fruits1.intersection(set_fruits2)
print(f'交集后的集合：{results}') # 输出 {'cherries', 'apple'}

3.3.5 intersection_update()

  用于保留两个集合中相同的元素，直接在原始集合上进行操作，不返回新的集合。
与intersection() 不同，intersection_update()直接修改原始集合。

set_fruits1 = {'apple','banana','cherries'}
set_fruits2 = {'apple','pear','grape','cherries'}

set_fruits1.intersection_update(set_fruits2)
print(f'交集后的集合：{set_fruits1}') # 输出 {'cherries', 'apple'}

3.3.6 symmetric_difference()

  用于返回两个集合的对称差集，即返回一个新集合，其中包含只在其中一个集合中出现的元素。该方法不会修改原始集合，而是返回一个新的集合。

set_fruits1 = {'apple','banana','cherries'}
set_fruits2 = {'apple','pear','grape','cherries'}

result_fruits = set_fruits1.symmetric_difference(set_fruits2)
print(f'两个集合的对称差集：{result_fruits}') # 输出 {'pear', 'banana', 'grape'}

3.3.7 symmetric_difference_update()

  用于将集合更新为其与另一个集合的对称差集，直接在原始集合上进行操作，不返回新的集合。对称差集包含只在其中一个集合中出现的元素。
与 symmetric_difference()不同，symmetric_difference_update()直接修改原始集合。

set_fruits1 = {'apple','banana','cherries'}
set_fruits2 = {'apple','pear','grape','cherries'}

set_fruits1.symmetric_difference_update(set_fruits2)
print(f'两个集合的对称差集：{set_fruits1}') # 输出 {'pear', 'banana', 'grape'}

4.集合的引用场景

4.1 去重

  集合中的元素是唯一的，因此可以用于从一个列表或其他可迭代对象中删除重复的元素。

# 去重示例
my_list = [1, 2, 2, 3, 4, 4, 5]
unique_set = set(my_list)
unique_list = list(unique_set)
print(unique_list)

4.2 成员关系测试

  集合提供了高效的成员关系测试，即判断一个元素是否属于集合，这在查找或验证元素的存在性时非常有用。

# 成员关系测试示例
my_set = {10, 20, 30, 40, 50}
print(20 in my_set)  # 输出 True
print(60 in my_set)  # 输出 False

4.3 集合运算

  集合支持丰富的数学运算，如并集、交集、差集等，这在处理多个集合之间的元素关系时非常有用。

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

# 并集
union_set = set1 | set2
print(union_set)

# 交集
intersection_set = set1 & set2
print(intersection_set)

# 差集
difference_set = set1 - set2
print(difference_set)

4.4 快速的元素查找和删除

  集合提供了快速的元素查找和删除操作，这对于处理大型数据集时非常有用。

# 快速的元素查找和删除示例
my_set = {10, 20, 30, 40, 50}

# 删除元素
my_set.remove(30)
print(my_set)

# 检查元素是否存在
print(20 in my_set)

4.5 数学和统计运算

  集合可以用于执行一些基本的数学和统计运算，如计算元素个数、最大值、最小值等。

# 数学和统计运算示例
my_set = {10, 20, 30, 40, 50}

# 计算元素个数
count = len(my_set)
print(count)

# 计算最大值和最小值
max_value = max(my_set)
min_value = min(my_set)
print(max_value, min_value)