Python全网最全基础课程笔记(九)——集合，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！

'''
集合的创建方式

'''

#第一种创建方式，使用{}
i = {1,2,3,4,5,1,4,2}

#这个集合中有重复数据
print(i,type(i)) # {1, 2, 3, 4, 5} <class 'set'> 结果都是去重后的，集合中的元素是唯一的

'''第二种创建方式，使用内置函数set()方法'''

#range(10) 生成0-9的整数
h = set(range(10))
print(h,type(h)) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} <class 'set'>

'''将列表转换成集合'''
lis = [1,2,3,4,5,4,2,1,2]
#该列表中有重复数据，将列表转换成集合
print("原列表：",lis,type(lis)) # 原列表： [1, 2, 3, 4, 5, 4, 2, 1, 2] <class 'list'>
s = set(lis)
#成功将列表中的每个元素变成集合中的每个元素，并且进行了去重处理
print("将列表转换成集合：",s,type(s)) # 将列表转换成集合： {1, 2, 3, 4, 5} <class 'set'>

'''将元组转换成集合'''
t = ('张三',12,22,92.1,'张三')
print("原元组：",t,type(t)) # 原元组： ('张三', 12, 22, 92.1, '张三') <class 'tuple'>
#将元组转换成集合，并且元组中有重复数据
s = set(t)
# 进行了去重操作，而且顺序变了
print("将元组转换成集合：",s,type(s)) # 将元组转换成集合： {12, '张三', 22, 92.1} <class 'set'>

'''将字符串转换成集合类型'''
i = "张三zhangsan"
print("原字符串：",s,type(s)) # 原字符串： {'张三', 12, 22, 92.1} <class 'set'>
s = set(i)
print("将字符串转换成集合：",s,type(s)) # 将字符串转换成集合： {'三', 'h', 'n', 's', '张', 'a', 'g', 'z'} <class 'set'>

'''创建空集合'''
s = set()
print(s,type(s)) # set() <class 'set'>
#不能使用空的{},因为系统默认空的{}是字典
s2 = {}
print(s2,type(s2)) # {} <class 'dict'>

# 定义两个集合  
set1 = {1, 2, 3, 4}  
set2 = {3, 4, 5, 6}  
  
# 使用 | 运算符或 union() 方法计算并集  
union_set = set1 | set2  # 使用 | 运算符  
# union_set = set1.union(set2)  # 使用 union() 方法  
  
# 输出结果  
print("并集:", union_set)  # 输出: 并集: {1, 2, 3, 4, 5, 6}

# 定义两个集合  
set1 = {1, 2, 3, 4}  
set2 = {3, 4, 5, 6}  
  
# 使用 & 运算符或 intersection() 方法计算交集  
intersection_set = set1 & set2  # 使用 & 运算符  
# intersection_set = set1.intersection(set2)  # 使用 intersection() 方法  
  
# 输出结果  
print("交集:", intersection_set)  # 输出: 交集: {3, 4}

# 定义两个集合  
set1 = {1, 2, 3, 4}  
set2 = {3, 4, 5, 6}  
  
# 使用 - 运算符或 difference() 方法计算差集  
difference_set = set1 - set2  # 使用 - 运算符  
# difference_set = set1.difference(set2)  # 使用 difference() 方法  
  
# 输出结果  
print("差集:", difference_set)  # 输出: 差集: {1, 2}

# 定义两个集合  
set1 = {1, 2, 3, 4}  
set2 = {3, 4, 5, 6}  
  
# 使用 ^ 运算符或 symmetric_difference() 方法计算对称差集  
symmetric_difference_set = set1 ^ set2  # 使用 ^ 运算符  
# symmetric_difference_set = set1.symmetric_difference(set2)  # 使用 symmetric_difference() 方法  
  
# 输出结果  
print("对称差集:", symmetric_difference_set)  # 输出: 对称差集: {1, 2, 5, 6}

# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 使用for循环遍历集合  
for element in my_set:  
    # 打印当前遍历到的元素  
    print(element)  
  
# 输出结果：集合中的元素将以一种看似随机的顺序被打印出来，因为集合是无序的。  
# 例如：  
# 1  
# 2  
# 3  
# 4  
# 5  
# 但每次运行的结果顺序可能不同。

# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 将集合转换为列表  
my_list = list(my_set)  
  
# 使用for循环遍历列表  
for element in my_list:  
    # 打印当前遍历到的元素  
    print(element)  
  
# 输出结果：将集合转换为列表后，遍历的顺序就是列表的顺序，即元素被添加到列表中的顺序（Python 3.7+中，字典和集合的插入顺序被保留）。  
# 例如：  
# 1  
# 2  
# 3  
# 4  
# 5  
# 注意：虽然输出看似有序，但这并不意味着集合本身是有序的。

# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 使用while循环和pop()方法遍历集合（注意：这会修改集合）  
while my_set:  
    # 移除并返回集合中的一个元素  
    element = my_set.pop()  
    # 打印当前移除的元素  
    print(element)  
  
# 输出结果：集合中的元素将被逐个移除并打印，但集合本身会被清空。  
# 注意：由于pop()方法的行为（它移除并返回集合中的一个任意元素），输出顺序也是不确定的。  
# 例如：  
# 5  
# 4  
# 3  
# 2  
# 1  
# 但每次运行的结果顺序可能不同。

# 定义一个集合  
my_set = {1, 2, 3, 4}  
  
# 判断元素是否存在  
print(1 in my_set)  # 输出: True  
print(5 not in my_set)  # 输出: True

# 定义两个集合  
set_a = {1, 2, 3}  
set_b = {1, 2, 3, 4}  
  
# 判断子集和超集关系  
print(set_a.issubset(set_b))  # 输出: True，因为set_a是set_b的子集  
print(set_b.issuperset(set_a))  # 输出: True，因为set_b是set_a的超集  
  
# 使用比较运算符  
print(set_a <= set_b)  # 输出: True，等同于issubset  
print(set_b >= set_a)  # 输出: True，等同于issuperset  
print(set_a == {1, 2, 3})  # 输出: True，集合相等  
print(set_a != set_b)  # 输出: True，集合不相等

# 初始化一个空集合  
my_set = set()  
  
# 向集合中添加元素  
my_set.add(1)  # 添加整数1  
my_set.add("apple")  # 添加字符串"apple"  
  
# 输出集合内容  
print(my_set)  # 运行结果：{1, 'apple'}，注意集合是无序的  
  
# 尝试添加已存在的元素  
my_set.add(1)  # 不会有任何变化，因为1已经存在于集合中  
print(my_set)  # 运行结果仍然为：{1, 'apple'}

# 初始化一个集合  
my_set = {1, 2}  
  
# 使用update添加另一个集合  
other_set = {3, 4, 2}  # 注意2是重复的  
my_set.update(other_set)  
  
# 输出更新后的集合  
print(my_set)  # 运行结果：{1, 2, 3, 4}，重复元素2被忽略  
  
# 也可以添加其他可迭代对象，如列表  
my_set.update([5, 6, 7])  
print(my_set)  # 运行结果：{1, 2, 3, 4, 5, 6, 7}

# 初始化一个集合  
my_set = {1, 2, 3}  
  
# 使用discard移除元素  
my_set.discard(2)  
print(my_set)  # 运行结果：{1, 3}，元素2被成功移除  
  
# 尝试移除不存在的元素  
my_set.discard(4)  # 不会有任何异常，因为4不在集合中  
  
# 使用remove移除元素  
try:  
    my_set.remove(1)  
    print(my_set)  # 如果执行到这里，则输出移除1后的集合  
except KeyError:  
    print("KeyError: 尝试移除不存在的元素")  # 运行结果：KeyError: 尝试移除不存在的元素  
  
# 注意：remove操作如果元素不存在会抛出异常

# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 移除元素3  
my_set.remove(3)  
  
# 打印更新后的集合  
print(my_set)  # 运行结果：{1, 2, 4, 5}  
  
# 尝试移除不存在的元素  
# my_set.remove(6)  # 这会抛出KeyError

# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 移除元素2  
my_set.discard(2)  
  
# 打印更新后的集合  
print(my_set)  # 运行结果：{1, 3, 4, 5}  
  
# 尝试移除不存在的元素  
my_set.discard(6)  
  
# 由于discard不会抛出异常，所以这里不会打印任何信息  
# 但集合仍然是{1, 3, 4, 5}  
print(my_set)  # 运行结果：{1, 3, 4, 5}

# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 移除并返回任意一个元素  
popped_element = my_set.pop()  
  
# 打印被移除的元素和更新后的集合  
print(f"被移除的元素是：{popped_element}")  # 运行结果可能不同，例如：被移除的元素是：4  
print(my_set)  # 运行结果可能不同，例如：{1, 2, 3, 5}  
  
# 尝试从空集合中pop元素  
# my_set.clear()  # 首先清空集合  
# popped_element = my_set.pop()  # 这会抛出KeyError

# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 清空集合  
my_set.clear()  
  
# 打印清空后的集合  
print(my_set)  # 运行结果：set()