020集合类型内置方法

集合类型内置方法

---

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

pythoners = ['jason', 'reed', 'tank', 'sean']
linuxers = ['reed', '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: ['reed']

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

1、定义

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。{}内用逗号分隔开多个元素，每个元素必须是不可变类型。

创建格式：

parame = {value01,value02,...}
或者
set(value)
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'}#随机的，但是重复出现

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

1.1 优先掌握(*****)

1. 长度len
2. 成员运算in和not in
3. |并集、union
4. &交集、intersection
5. -差集、difference
6. ^对称差集、symmetric_difference
7. ==
8. 父集：>、>= 、issuperset
9. 子集：<、<= 、issubset

1.长度len

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

print(f"len(s): {len(s)}")
####输出结果：
len(s): 3

2.成员运算in和not in

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

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

3.|并集

# str之|并集
pythoners = {'jason', 'reed', 'tank', 'sean'}
linuxers = {'reed', 'egon', 'kevin'}

print(f"pythoners|linuxers: {pythoners|linuxers}")
print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}")
###输出结果
pythoners|linuxers: {'egon', 'tank', 'kevin', 'jason', 'reed', 'sean'}
pythoners.union(linuxers): {'egon', 'tank', 'kevin', 'jason', 'reed', 'sean'}

4.&交集

# str之&交集
pythoners = {'jason', 'reed', 'tank', 'sean'}
linuxers = {'reed', 'egon', 'kevin'}

print(f"pythoners&linuxers: {pythoners&linuxers}")
print(f"pythoners.intersection(linuxers): {pythoners.intersection(linuxers)}")
####输出结果：
pythoners&linuxers: {'reed'}
pythoners.intersection(linuxers): {'reed'}

5.-差集

# str之-差集
pythoners = {'jason', 'reed', 'tank', 'sean'}
linuxers = {'reed', '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'}

6.^对称差集

返回两个集合中不重复的元素集合。

# str之^对称差集
pythoners = {'jason', 'reed', 'tank', 'sean'}
linuxers = {'reed', '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'}

7.==

# str之==
pythoners = {'jason', 'reed', 'tank', 'sean'}
linuxers = {'reed', 'egon', 'kevin'}
javers = {'reed', 'egon', 'kevin'}

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

8.父集：>、>=

# str之父集：>、>=
pythoners = {'jason', 'reed', 'tank', 'sean'}
linuxers = {'reed', 'egon', 'kevin'}
javaers = {'jason', 'reed'}

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

9.子集：<、<=

# str之子集：<、<=
pythoners = {'jason', 'reed', 'tank', 'sean'}
linuxers = {'reed', 'egon', 'kevin'}
javaers = {'jason', 'reed'}

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

1.2 需要掌握(****)

1. add

2. remove

3. difference_update

4. discard

5. isdisjoint

1.add()

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

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

2.remove()

# set之remove()
s = {1, 2, 'a'}
s.remove(1)

print(s)
###输出结果：
{2, 'a'}

3.difference_update()

移除集合中的元素，该元素在指定的集合也存在。

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

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

4.discard()

删除集合中指定的元素

# set之discard()
s = {1, 2, 'a'}
# s.remove(3)  # 报错
s.discard(3)

print(s)
####输出结果如下
{1, 2, 'a'}

5.isdisjoint()

判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

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

print(f"pythoners.isdisjoint(linuxers): {pythoners.isdisjoint(linuxers)}")
####输出结果:
pythoners.isdisjoint(linuxers): False

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

二、练习

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

stu_info_list = [
    {'name':'reed','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'},
]

4.存一个值or多个值：多个值，且值为不可变类型。

5.有序or无序：无序

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

6.可变or不可变：可变数据类型