第九篇 Python数据类型之集合

集合 set

写在最前，必须要会的：
1、长度len
2、成员运算in和not in
3、|合集
4、&交集
5、-差集
6、^对称差集
7、==
8、父集：>,>=
9、子集：<,<=

作用：去重，关系运算

可变类型与不可变类型的区别：
可变类型是不可hash类型
不可变类型是可hash类型： 字符串，数字，元组

定义集合:
集合：用花括号{}表示，可以包含多个元素，用逗号分割
集合的元素遵循三个原则：
1：每个元素必须是不可变类型(可hash，可作为字典的key)，不可变类型只有数字，字符串，元组，所以集合的元素也只能是这三种
2: 没有重复的元素
3：无序排列
注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

s3={1,2,3,4,5,6}
print(s3)

#结果
{1, 2, 3, 4, 5, 6}

#将字符串转换为集合
s1=set('hello')
print(s1)

#结果
{'o', 'h', 'e', 'l'}    # 这可以体现出集合是无序的

#将列表转换为集合，如果有重复元素，会自动去重
s2=set(['alex','alex','sb'])
print(s2)

#结果
{'alex', 'sb'}

# 在集合里定义元组

s={1,2,3,4,5,6,("adfa",1232)}
print(s)

#结果
{'s', 1, 2, 3, 4, 5, 6, '3', ('adfa', 1232)}

集合的内置函数

add():往集合里添加元素，每次只能添加一个，而update可以一次更新多个值

s.add('s')
s.add('')
s.add(3)
print(s)

#结果
{1, 2, 3, 4, 5, 6, 's', ''}

clear()：清空集合

s={1,2,3,4,5,6,("adfa",1232)}
s.clear()
print(s)

#结果
set()

pop()：随机删除集合的元素

s={'sb',1,2,3,4,5,6}
#随机删
s.pop()
print(s)

#结果
{2, 3, 4, 5, 6, 'sb'}

remove()：从集合里删除指定元素，如果要删除的元素不存在，程序会直接报错

s={'sb',1,2,3,4,5,6}

s.remove('sb')
s.remove('hellol') #删除元素不存在会报错
print(s)

discard()：从集合里删除指定元素，如果要删除的元素不存在，程序不会报错

s={'sb',1,2,3,4,5,6}

#指定删除
s.discard('sb')
s.discard('sbbbb')#删除元素不存在不会报错
print(s)

集合关系运算：交、差、并集

有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
　　linuxs={'wupeiqi','oldboy','gangdan'}

(1）intersection(self, *args, **kwargs)：求交集 　　
   符号表示法： A & B

pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}

# 求出即报名python又报名linux课程的学员名字集合
# for循环方法
py_and_linux = []
for item in pythons:
    if item in linuxs:
        py_and_linux.append(item)
print(py_and_linux)

# 用集合的方法---交集
s = pythons.intersection(linuxs)
print(s)
print(pythons & linuxs)

#结果
['wupeiqi', 'gangdan']
{'wupeiqi', 'gangdan'}
{'wupeiqi', 'gangdan'}

(1-1) intersection_update(self, *args, **kwargs):

( 2 ) union()：求并集

符号表示法： A | B

pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}

# 求出所有报名的学生名字集合
print(pythons.union(linuxs))
print(pythons|linuxs)

#结果
{'wupeiqi', 'biubiu', 'gangdan', 'alex', 'oldboy', 'yuanhao', 'egon'}
{'wupeiqi', 'biubiu', 'gangdan', 'alex', 'oldboy', 'yuanhao', 'egon'}

(2-2)

(3)difference(self, *args, **kwargs)：求差集  A - B ，就是要从A里去掉既再在A里又在B里的人=A里剩下的人（只在Ａ里有，不在B里的人）

符号表示法： A - B

pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}

#  求出只报名python课程的学员名字
print('差集',pythons - linuxs)
print(pythons.difference(linuxs))

# 结果
差集 {'alex', 'egon', 'yuanhao', 'biubiu'}
{'alex', 'egon', 'yuanhao', 'biubiu'}

# 求出只报名linux课程的学员名字
print('差集',linuxs-pythons)
print(linuxs.difference(pythons))

# 结果
差集 {'oldboy'}
{'oldboy'}

(3-3) difference_update(self, *args, **kwargs): A-B先求差集得到结果，然后又把这个得到的结果赋值给A，即 A = A -B

pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}

pythons.difference_update(linuxs)
print(pythons)

# 相当于

pythons = pythons - linuxs
print(pythons)
# 结果
{'egon', 'biubiu', 'alex', 'yuanhao'}

Pythons 原来是{'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}，求差集后把pythons的值更新为{'egon', 'biubiu', 'alex', 'yuanhao'}了

(4)  symmetric_difference(self, other)  ：交差补集， 先把两个集合合并到一起，然后去掉两个集合都有的公有的部分

符号表示法： A ^ B

pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
#交叉补集
print('交叉补集',pythons.symmetric_difference(linuxs))
print('交叉补集',pythons^linuxs)

#结果
交叉补集 {'biubiu', 'egon', 'yuanhao', 'alex', 'oldboy'}
交叉补集 {'biubiu', 'egon', 'yuanhao', 'alex', 'oldboy'}

isdisjoint(self, *args, **kwargs) ： 判断两个集合是否存在共有部分，如果存在返回FALSE，不存在返回TRUE

s1={1,2}
s2={2,3,5}
s3 = {4,6,7}
print(s1.isdisjoint(s2))
print(s1.isdisjoint(s3))

# 结果
False
True

issubset(self, *args, **kwargs)：判断A集合是否是B集合的子集 ，是，返回True, 不是，返回 Flase

符号表示： A <= B

s1={1,2}
s2={1,2,3}
print(s1.issubset(s2))#s1 是s2 的子集  True
print(s1 <= s2)   # True
print(s2.issubset(s1))#s2 是s1 的子集 False
print(s2 <= s1)  # False

issuperset(self, *args, **kwargs): 判断A是不是B的父集，是返回True, 不是 范湖 FALSE

符号表示： A >=B

s1={1,2}
s2={1,2,3}

print(s2.issuperset(s1))#s1 是s2 的父集  True
print(s2 >= s1 )      # True

print(s1.issuperset(s2))#s1 是s2 的父集  False
print(s1 >= s2)       # False

update(self, *args, **kwargs) ： A.update(B)  将B的值更新到A

s1={1,2}
s2={1,2,3}
s1.update(s2) #更新多个值
s1.update([3,4],(5,6))  # 可以更新列表，元组的值到集合里
print(s1)

#结果
{1, 2, 3, 4, 5, 6}

集合本来是可变类型的，但是集合还有一种定义方式，通过  frozenset() 定义不可变类型的集合

通过frozenset()方法定义的不可变集合，连add()和update()方法都没有的。

s=frozenset('hello')
print(s)

# 结果
frozenset({'o', 'h', 'l', 'e'})

通过集合对列表进行简单的去重，不考虑列表的顺序是否改变

names=['alex','alex','wupeiqi']

names=list(set(names))
print(names)

# 结果
['wupeiqi', 'alex']