python----集合

python----集合

---

集合的创建

空集合只能用set()创建，不能用{}创建，{}被字典占用。

# 方法一
set1 = {"集合","元素"}
print(type(set1))       # <class 'set'>

# 方法二
set2 = set()
print(type(set2))       # <class 'set'>

# 这个是空字典，而不是空集合
d = {}
print(type(d))          # <class 'dict'>

集合的运算

len()函数

函数：len(集合)
作用：返回集合中元素的个数

st = {1,2,3,4,5,6}
le = len(st)
print(le)       # 6

关键字 in

关键字 ：in
作用：判断元素是否在集合中

st = {"元素1","元素2","元素3","元素4"}
res = "元素1" in st
print(res)          # True
res1 = "元素5" in st
print(res1)         # False

并集

符号：|
作用：计算并集
返回值：返回两个集合中的所有元素

st1 = {1,2,3,4,5}
st2 = {2,4,6,8,9}
res = st1 | st2
print(res)      # {1, 2, 3, 4, 5, 6, 8, 9}

交集

符号：&
作用：计算交集
返回值：返回两个集合中共有元素

st1 = {1,2,3,4,5}
st2 = {2,4,6,8,9}
res = st1 & st2
print(res)    # {2, 4}

差集

符号：-
作用：计算差集
返回值：当A-B时，返回在集合A中但不出现在集合B中的所有元素

st1 = {1,2,3,4,5}
st2 = {2,4,6,8,9}
res = st1 - st2
print(res)      # {1, 3, 5}
res2 = st2 - st1
print(res2)     # {8, 9, 6}

对称差

符号：^
作用：计算对称差
返回值：返回两个集合交集以外的元素

st1 = {1,2,3,4,5}
st2 = {2,4,6,8,9}
res = st1 ^ st2
print(res)      # {1, 3, 5, 6, 8, 9}

子集和超集

符号	含义
A <= B	检测A是否是B的子集
A < B	检测A是否是B的真子集
A >= B	检测A是否是B的超集
A > B	检测A是否是B的真超集
A |= B	将B的元素并入A中

st1 = {1,2,3,4,5,6}
st2 = {1,2,3}

res = st2 <= st1
print(res)  # True

res1 = st2 < st1
print(res)  # True

res2 = st2 >= st1
print(res)  # True

集合的方法

（1）、intersection()

功能： 计算两个集合交集
格式：集合1.intersection(集合2)
返回值：两个集合的交集
注意：成一个新的集合，两个集合的位置对结果没有影响

st1 = {1,2,3,4,5,6}
st2 = {2,4,6,8,10,12}
set1 = st1.intersection(st2)
print(set1)      # {2, 4, 6}
set2 = st2.intersection(st1)
print(set2)     # {2, 4, 6}

（2）、union()

功能：计算两个集合的并集
格式：集合1.intersection(集合2)
返回值：两个集合的并集
注意：成一个新的集合，两个集合的位置对结果没有影响

st1 = {1,2,3,4,5,6}
st2 = {2,4,6,8,10,12}
set1 = st1.union(st2)
print(set1)     # {1, 2, 3, 4, 5, 6, 8, 10, 12}
set2 = st2.union(st1)
print(set2)     # {1, 2, 3, 4, 5, 6, 8, 10, 12}

（3）、difference()

功能：计算两个集合的差集
格式：集合1.intersection(集合2)
返回值：两个集合的差集
注意：成一个新的集合，位置对结果有影响，表现为：集合1-集合2

st1 = {1,2,3,4,5,6}
st2 = {2,4,6,8,10,12}
set1 = st1.difference(st2)
print(set1)     # {1, 3, 5}
set2 = st2.difference(st1)
print(set2)     # {8, 10, 12}

（4）、symmetric_difference()

功能：计算两个集合的对称差集 (补集情况涵盖在其中)
格式：集合1.intersection(集合2)
返回值：两个集合的对称差集
注意：成一个新的集合，两个集合的位置对结果没有影响

st1 = {1,2,3,4,5,6}
st2 = {2,4,6,8,10,12}
set1 = st1.symmetric_difference(st2)
print(set1)         # {1, 3, 5, 8, 10, 12}
set2 = st2.symmetric_difference(st1)
print(set2)         # {1, 3, 5, 8, 10, 12}

（5）、issubset()

功能：判断是否是子集
格式：集合1.intersection(集合2)
返回值：False 或 True
注意：位置对结果有影响，表现为：检测集合1是否是集合2的子集

st1 = {1,2,3,4,5,6}
st2 = {1,2,3}
set1 = st1.issubset(st2)
print(set1)     # False
set2 = st2.issubset(st1)
print(set2)     # True

（6）、issuperset() 判断是否是父集

功能：判断是否是父集
格式：集合1.intersection(集合2)
返回值：False 或 True
注意：位置对结果有影响，表现为：检测集合1是否是集合2的父集

st1 = {1,2,3,4,5,6}
st2 = {1,2,3}
set1 = st1.issuperset(st2)
print(set1)     # True
set2 = st2.issuperset(st1)
print(set2)     # False

（7）、isdisjoint()

功能：检测两集合是否不相交
格式：集合1.intersection(集合2)
返回值：不相交 True 相交False
注意：两个集合的位置对结果没有影响

st1 = {1,2,3,4,5,6}
st2 = {2,4,6,}
# 相交
set1 = st1.isdisjoint(st2)
print(set1)
set2 = st2.isdisjoint(st1)
print(set2)

st3 = {"hh",'hehe','haha'}
st4 = {"h",5,3}
# 不相交
set3 = st3.isdisjoint(st4)
print(set3)     # True

（8）、add()

功能：向集合中添加数据
格式：集合.add(数据)
返回值：None
注意：直接将数据添加到原来集合中且位置随机

st = {"黄毛","灰猫"}
t = st.add("黑猫")
print(t)        # None
print(st)       # {'黄毛', '黑猫', '灰猫'}

（9）、update() 迭代着增加

功能：迭代着增加
格式：集合.update(序列)
返回值：None
注意：直接将序列中的元素迭代添加到原来集合中且位置随机

st = {"工人","学生","老师"}
t = st.update(["医生","护士"])
print(t)        # None
print(st)       # {'学生', '护士', '医生', '老师', '工人'}
st.update(("白领","程序员"))
print(st)       # {'学生', '护士', '医生', '白领', '程序员', '老师', '工人'}

（10）、clear()

功能：清空集合
格式：集合.clear()
返回值：None
注意：集合中元素全部清空，原集合变为空集合

st = {"家长","学生","老师"}
t = st.clear()
print(t)        # None
print(st)       # set()

（11）、pop()

功能：随机删除集合中的一个数据
格式：集合.pop()
返回值：返回被删除的元素
注意：结果改变原集合，直接在原集合中删除数据

st = {"家长","学生","老师"}
t = st.pop()
print(t)        # 学生
print(st)       # {'老师', '家长'}

（12）、remove()

功能： 删除集合中指定的值(不存在则报错)
格式：集合.remove(指定元素)
返回值：None
注意：结果改变原集合，直接在原集合中删除数据，不存在报错

st = {"指定删除","没有报错"}
t = st.remove("指定删除")
print(t)        # None
print(st)       # {'没有报错'}

st.remove("1")  # 报错：KeyError: '1'

（13）、discard()

功能：删除集合中指定的值(不存在的不删除 推荐使用)
格式：集合.discard(指定元素)
返回值：None
注意：结果改变原集合，直接在原集合中删除数据，

st = {'学生', '护士', '医生', '白领', '程序员', '老师', '工人'}
t = st.discard("工人")
print(t)        # None
print(st)       # {'老师', '程序员', '白领', '护士', '学生', '医生'}

t2 = st.discard("haha")
print(st)       # {'老师', '程序员', '护士', '医生', '学生', '白领'}

冰冻集合

函数：frozenset（）
作用：frozenset 可强转序列数据变为冰冻集合
注意：冰冻集合一旦创建,不能在进行任何修改,只能做交叉并补操作

# 定义有个空的冰冻集合
t1 = frozenset()
print(type(t1))     # <class 'frozenset'>

# 列表强转冰冻集合
ls = [1,2,3,4,5]
t2 = frozenset(ls)
print(t2)       # frozenset({1, 2, 3, 4, 5})

# 元组强转冰冻集合
tp = (1,2,3,4)
t3 = frozenset(tp)
print(t3)       # frozenset({1, 2, 3, 4})

# 字符串强转冰冻集合
s = "123456"
t4 = frozenset(s)
print(t4)   # frozenset({'4', '2', '3', '6', '1', '5'})


# 字典强转冰冻集合
dic = {"a":1,"b":2,"c":3}
t5 = frozenset(dic)
# 默认将键转为集合
print(t5)       # frozenset({'a', 'b', 'c'})

# 不能在进行任何修改
# t5.add("haha")    # 报错：AttributeError: 'frozenset' object has no attribute 'add'
# t5.clear()          # 报错：AttributeError: 'frozenset' object has no attribute 'clear'

集合的去重性

很多场景中需要去掉重复值，集合就一个比较简单的去重工具

ls = [1904040201,1904040202,1904040203,1904040201,1904040202]
# 要求去掉重复的学号
st = set(ls)
new_ls = list(st)
print(new_ls)       # [1904040201, 1904040202, 1904040203]