1.集合的基本概念

• 无序的，不可随机访问的，不可重复的元素集合
• 与数学中集合的概念类似，可对其进行交，并，差，补等逻辑运算
• 可分为可变集合和不可变集合
• set 可变集合 增删改
• fronzenset 不可变集合 创建好之后，无法增删改

2.集合的定义

2.1 可变集合 set定义

• s = {1,2,3,4}
• s = set(iterable) 可以字符串，列表，元组，字典，集合变成一个集合

#可变集合的定义
s = {1,2,3}
print(s,type(s))#输出 {1, 2, 3} 

s1 = set("abchd")#字符串
s2 = set([1,2,3,5])#列表
s3 = set((1,2,3,4,))#元组
s4 = set({1:2,"as":3})
print(s1,type(s1))#输出{'h', 'b', 'a', 'd', 'c'} 
print(s2,type(s2))#输出{1, 2, 3, 5} 
print(s3,type(s3))#输出{1, 2, 3, 4} 
print(s4,type(s4))#输出{1, 'as'} 

2.2 不可变集合 fronzenset 定义

• fs = frozenset(iterable) 其中iterable可以是字符串，列表，元组，字典等。但是为字典时，只会提取key作为set的元素

2.3 集合定义的注意事项

• 创建一个空集合时，需要使用set()或者frozenset()，不能使用 s = {} 因为这样会被识别成字典
• 集合中的元素，必须是可哈希的值。如果一个对象在自己的生命周期中有一哈希值（hash value）是不可改变的，那么它就是可哈希的
• 如果集合中的元素出现重复，则会被合并为1个

3.单一集合的常用操作

3.1 可变集合

• 增加操作 add()
• s.add()
• 删除操作
• s.remove(element)
• 指定删除set对象中的一个元素，如果集合中没有这个元素，则返回一个错误
• s.discare(element)
• 指定删除set对象中的一个元素，如果集合中没有这个元素，则不做任何事情
• s.pop()
• 随机删除并返回一个集合中的元素，若集合为空，则返回一个错误
• s.clear()
• 清空一个集合中的所有元素
• 查询操作
• 通过for in进行遍历
• 通过迭代器进行访问

#增加操作
s = {1,2,3,4}
s.add(5)
print(s)#输出 {1, 2, 3, 4, 5}
s.add([1,2,3])#报错 因为[1,2,3]是可变哈希值

#删除操作
s = {1,2,3,4}
result = s.remove(2)
print(result,s)#输出 None {1, 3, 4}  如果集合中没有这个元素，则返回一个错误

s = {1,2,3,4}
result = s.remove(2)
print(result,s)#输出 None {1, 3, 4}  如果集合中没有这个元素，则不做任何操作

s = {1,2,3,4}
result = s.pop()
print(result,s)#输出 1 {2, 3, 4}如果集合为空，则返回一个错误

s = {1,2,3,4}
s.clear()
print(s)#{}

#查询操作
#for in 遍历
s = {1,2,3,4,5}
for x in s:
    print(x)

#通过迭代器
#1.生成一个迭代器
s = {1,2,3,4,5}
its = iter(s)
#2.使用这个迭代器去访问
for x in its:
    print(x)

3.2 不可变集合

• 不能增删改
• 查询操作
• 通过for in进行遍历
• 通过迭代器进行访问

#查询操作
#for in 遍历
s = frozenset([1,2,3,4,5])
for x in s:
    print(x)

#通过迭代器
#1.生成一个迭代器
s = frozenset([1,2,3,4,5])
its = iter(s)
#2.使用这个迭代器去访问
for x in its:
    print(x)

4. 集合之间操作

4.1 交集

• intersection(Iterable)
• 字符串 只判断字符串中的非数字
• 列表
• 元组
• 字典 值判断key
• 集合
• &
• intersection_update(....)

#intersection
s1 = {1,2,3,4,5}
s2 = {4,5,6}
result = s1.intersection(s2)
print(result,type(result))#输出 {4, 5} 

s1 = frozenset([1,2,3,4,5])
s2 = {4,5,6}
result = s1.intersection(s2)
print(result,type(result))#输出 {4, 5}   输出结果为不可变集合  
#当result = s2.intersection(s1)时，输出结果为输出 {4, 5}  集合为可变集合
#交集的输出时，是以前面为基准的

#& 作用与上一个一样
s1 = {1,2,3,4,5}
s2 = {4,5,6}
result = s1 & s2

#intersection_update()的作用和前两者一样，但是会修改原集合。

4.2 并集

• union()
• |
• update()

#union
s1 = {1,2,3,4,5}
s2 = {4,5,6}
result = s1.union(s2)
print(result,type(result))#输出 {1,2,3,4,5,6} 

s1 = frozenset([1,2,3,4,5])
s2 = {4,5,6}
result = s1.union(s2)
print(result,type(result))#输出 {1,2,3,4,5,6}   输出结果为不可变集合  
#当result = s2.intersection(s1)时，输出结果为输出 {1,2,3,4,5,6}  集合为可变集合
#并集的输出时，是以前面为基准的

#| 作用与上一个一样
s1 = {1,2,3,4,5}
s2 = {4,5,6}
result = s1 | s2

#update()的作用和前两者一样，但是会修改原集合。

4.3 差集

• defference()
• 算术运算符 -
• defference_update()

4.4 判定

• isdisjoint() 两个集合不相交
• issuperset() 一个集合包含另一个集合全部元素
• issubset() 一个集合包含于另一个集合部分元素

s1 = {1,2,3,4,5}
s2 = {4,5,6}
print(s1.isdisjoint(s2))#输出 False

s1 = {1,2,3,4,5}
s2 = {3,4,5}
print(s1.issuperset(s2))#输出 True  s2是s1的完全子集合

s1 = {1,2,3,4,5}
s2 = {4,5}
print(s1.issubset(s2))#输出 True  s2是s1的子集合