20.集合类型内置方法

一、集合概念引入

集合可以理解成一个集合体，学习Python的学生可以是一个集合体；学习Linux的学生可以是一个集合体。

pythoners = ['jason', 'nick', 'tank', 'sean']
linuxers = ['nick', 'egon', 'kevin']

# 即报名pythoners又报名linux的学生
py_li_list = []
for stu in pythoners:
    if stu in linuxers:
        py_li_list.append(stu)
print(f"pythoners and linuxers: {py_li_list}")
pythoners and linuxers: ['nick']

上述的列表方式求两个集合体的关系运算非常复杂，因此有了我们的集合数据类型。

1.1 用途

用于关系运算的集合体，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。

1.2 定义

在{}内用逗号分隔开多个元素，每个元素必须是不可变类型。

1. 集合内元素必须为不可变量类型
2. 集合类元素无序
3. 集合类元素不可重复，可以用于去重（只能对于不可变类型进行去重，无法保证原来的顺序）

#定义空集合
s = set()   			   
print(type(s))
#执行结果：<class 'set'>

#集合本身实现去重
s = {1, 2, 1, 'a'} 		 #相当于s = set({1,2,'a'})
print(f"s: {s}")
#s: {1, 2, 'a'}

s = {1, 2, 1, 'a', 'c'}			
for i in s:
    print(i)
#执行结果：
#1
#2
#c
#a

#字符串转集合，挨个输出字符，并实现去重
s = set('hello')		
print(f"s: {s}")
#执行结果：s: {'e', 'o', 'h', 'l'}

a= 'ssssAAAA'
s = set(a)
print(s)
#执行结果：{'s', 'A'}

l = [1,'a','s',111,5,2,3,4744,2]
l = set(l)
print(l)
# {1, 2, 3, 5, 'a', 4744, 111, 's'}
#虽然实现了去重，但是顺序发生改变

二、常用操作+内置方法

常用操作和内置方法分为优先掌握（今天必须得记住）、需要掌握（一周内记住）两个部分。.

2.1 优先掌握

2.1.1 长度（len）

# set之长度len
s = {1, 2, 'a'}

print(f"len(s): {len(s)}")
#执行结果：len(s): 3

2.1.2 成员运算（in和not in）

# set之成员运算in和not in
s = {1, 2, 'a'}

print(f"1 in s: {1 in s}")
#执行结果：1 in s: True

2.1.3 并集( | )

# str之|并集  两者所有的元素
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners|linuxers: {pythoners|linuxers}")  #方式一
print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}") #方式二
#执行结果：pythoners|linuxers: {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
#执行结果：pythoners.union(linuxers): {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}

2.1.4 交集( & )

# str之&交集  共同的元素
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners&linuxers: {pythoners&linuxers}")  #方式一
print(f"pythoners.intersection(linuxers): {pythoners.intersection(linuxers)}")  #方式二
#执行结果：pythoners&linuxers: {'nick'}
#执行结果：pythoners.intersection(linuxers): {'nick'}

2.1.5 差集( - )

# str之-差集  前者中去除与后者相同的元素，即取出前者独有的元素
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners-linuxers: {pythoners-linuxers}")  #方式一
print(f"pythoners.difference(linuxers): {pythoners.difference(linuxers)}")#方式二
#执行结果：pythoners-linuxers: {'tank', 'jason', 'sean'}
#执行结果：pythoners.difference(linuxers): {'tank', 'jason', 'sean'}

2.1.6 对称差集( ^ )

# str之^对称差集  去掉共同的元素
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners^linuxers: {pythoners^linuxers}")  #方式一
print(f"pythoners.symmetric_difference(linuxers): {pythoners.symmetric_difference(linuxers)}")  #方式二
#执行结果：pythoners^linuxers: {'egon', 'tank', 'kevin', 'jason', 'sean'}
#执行结果：pythoners.symmetric_difference(linuxers): {'egon', 'tank', 'kevin', 'jason', 'sean'}

2.1.7 相等( == )

# str之==  此时互为父子
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javers = {'nick', 'egon', 'kevin'}

print(f"pythoners==linuxers: {pythoners==linuxers}")
print(f"javers==linuxers: {javers==linuxers}")
#执行结果：pythoners==linuxers: False
#执行结果：javers==linuxers: True

2.1.8 父集：>、>=

# str之父集：>、>=
#前者至少包含后者所后的元素
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}

print(f"pythoners>linuxers: {pythoners>linuxers}")
print(f"pythoners>=linuxers: {pythoners>=linuxers}")
print(f"pythoners>=javaers: {pythoners>=javaers}")
print(f"pythoners.issuperset(javaers): {pythoners.issuperset(javaers)}")
#执行结果：pythoners>linuxers: False
#执行结果：pythoners>=linuxers: False
#执行结果：pythoners>=javaers: True
#执行结果：pythoners.issuperset(javaers): True

2.1.9 子集：<、<=

# str之子集：<、<=
#后者至少包含前者所有的元素
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}

print(f"pythoners<linuxers: {pythoners<linuxers}")
print(f"pythoners<=linuxers: {pythoners<=linuxers}")
print(f"javaers.issubset(javaers): {javaers.issubset(javaers)}")
#执行结果：pythoners<linuxers: False
#执行结果：pythoners<=linuxers: False
#执行结果：javaers.issubset(javaers): True

2.2 需要掌握

2.2. 1 增加值（add()）

# set之add()
#增加元素
s = {1, 2, 'a'}
s.add(3)

print(s)
#执行结果：{1, 2, 3, 'a'}

s = {1, 2, 'a'}
s.add(1)			#如果元素已存在，则不做处理
print(s)
#执行结果：{'a', 1, 2}

2.2. 2 移除值（remove()）

# set之remove()
#删除元素，元素不存在则报错
s = {1, 2, 'a'}
s.remove(1)

print(s)
#执行结果：{2, 'a'}

2.2. 3 求差集并赋值（difference_update()）

# str之difference_update()
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.difference_update(linuxers)

print(f"pythoners.difference_update(linuxers): {pythoners}")
#执行结果：pythoners.difference_update(linuxers): {'tank', 'jason', 'sean'}

注意：
ifference 单纯的求差集
difference_update 求完差集之后赋值给原来的集合

2.2. 4 删除（discard()）

# set之discard()
#进行删除操作，元素不存在，则不作处理
s = {1, 2, 'a'}
# s.remove(3)		  #如果用remove删除元素，元素不存在则报错
s.discard(3)	

print(s)
#执行结果：{1, 2, 'a'}

2.2. 5 判断是否有公共部分（sdisjoint()）

# set之isdisjoint()，集合没有共同的部分返回True，否则返回False
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.isdisjoint(linuxers)

print(f"pythoners.isdisjoint(linuxers): {pythoners.isdisjoint(linuxers)}")
p#执行结果：ythoners.isdisjoint(linuxers): False

三、其他

3.1 去重

有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序

stu_info_list = [
    {'name': 'nick', 'age': 19, 'sex': 'male'},
    {'name': 'egon', 'age': 18, 'sex': 'male'},
    {'name': 'tank', 'age': 20, 'sex': 'female'},
    {'name': 'tank', 'age': 20, 'sex': 'female'},
    {'name': 'egon', 'age': 18, 'sex': 'male'},
]

new_stu_info_list = []
for stu_info in stu_info_list:
    if stu_info not in new_stu_info_list:
        new_stu_info_list.append(stu_info)
print(new_stu_info_list)
#执行结果：
#[{'name': 'nick', 'age': 19, 'sex': 'male'}, {'name': 'egon', 'age': 18, 'sex': 'male'}, {'name': 'tank', 'age': 20, 'sex': 'female'}]

3.2 存一个值or多个值

存多个值

3.3 有序or无序

无序

3.4 可变or不可变

可变数据类型

s = {1, 2, 'a'}
print(f'first:{id(s)}')
s.add(3)
print(f'second:{id(s)}')
#执行结果：
#first:4480523848
#second:4480523848