Python 学习笔记 基本数据类型内置方法 之集合set

一、集合

1、作用：集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算。
2、特点：集合具备以下三个特点：

  • 每个元素必须是不可变类型
  • 集合内没有重复的元素
  • 集合内元素无序

需要掌握的内容

关系运算：

去重：

其他内置方法：


3、定义：在{}内用逗号分隔开多个元素

s = {1, 2, 3, 4}  # 本质 s = set({1,2,3,4})

# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，
# 所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，
# 现在我们想定义一个空字典和空集合，该如何准确去定义两者?

d = {}  # 默认是空字典
s = set()  # 这才是定义空集合

4、类型转换
但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型

# 正确的使用：
set([1, 2, 3, 3, 3, 3, 3, 3, ])  # 列表转集合 {1，2，3}
set((1, 2, 2, 2, 2, 3, 4))  # 元组转集合 {1，2，3，4}
set({'k1': 1, 'k2': 2})  # 字典转集合 {'k2'，'k1'}
set('hellolllllllllll')  # 字符串转集合 {'e', 'l', 'h', 'o'}
# 错误的使用:
set([1, 2, 3, [3, 3, 3, 3, 3]])  # 列表内存在可变内心 程序报错！！

二、需要掌握：

1、关系运算

friends1 = {"zero", "kevin", "jason", "egon"}  # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "egon"}  # 用户2的好友们

1.1、取交集 （&） 与 .intersection()

res = friends1 & friends2
print(res)  # 结果是两者相同的好友 {'jason', 'egon'}
s = friends1.intersection(friends2)
print(s)  # 结果相同 {'jason', 'egon'}

1.2、取并集/合集 （|）与 .union()

res = friends1 | friends2
print(res)  # 结果两者好友都合在一起去了 {'Jy', 'jason', 'zero', 'egon', 'ricky', 'kevin'}
s = friends1.union(friends2)
print(s)  # 结果相同 {'ricky', 'Jy', 'egon', 'zero', 'kevin', 'jason'}

1.3、取差集（-）与 .difference()

# 1.3.1、取用户1独有的好友
res = friends1 - friends2  # 注意左右先顺序
print(res)  # 结果是用户1独有好友 {'kevin', 'zero'}
s = friends1.difference(friends2)
print(s)  # 结果相同 {'kevin', 'zero'}

# 1.3.2、取用户2独有的好友
res = friends2 - friends1
print(res)  # 结果是用户2独有好友 {'Jy', 'ricky'}
s = friends2.difference(friends1)
print(s)  # 结果相同 {'Jy', 'ricky'}

1.4、对称差集 （^）与 .symmetric_difference（）

res = (friends1 ^ friends2)  # 取出两个用户独有好友们放在一起
print(res)  # 结果！{'ricky', 'Jy', 'zero', 'kevin'}
s = friends1.symmetric_difference(friends2)
print(s)  # 结果相同 {'kevin', 'ricky', 'Jy', 'zero'}

1.5、父子集：一个集合是否包含另外一个合集

# 1.5.1、存在包含关系，返回True
s1 = {1, 2, 3}
s2 = {1, 2}
print(s1 > s2)  # True
print(s1.issuperset(s2))  # s1 > s2 True

print(s2 < s1)  # 子集 True
print(s2.issubset(s1))  # 子集 s2 < s1 True

print(s1 >= s2)  # 大于或等于都 True
print(s2 <= s1)  # 子集 True

# 1.5.2、不存在包含关系
s1 = {1, 2, 3}
s2 = {1, 2}
print(s2 > s1)  # False
print(s2.issuperset(s1))

# 1.5.3无论大小都不存在包含关系
s1 = {1, 2, 3}
s2 = {1, 2, 4}
print(s1 > s2)  # False
print(s2 > s1)  # False

2、去重

 集合去重复有局限性

2.1. 只能针对不可变类型
2.2. 集合本身是无序的，去重之后无法保留原来的顺序

l = ['a', 'b', 1, 'a', 'a']
s = set(l)
print(s)  # 将列表转成了集合 {'b', 'a', 1}

l_new = list(s)  # 再将集合转回列表
print(l_new)  # 去除了重复，但是打乱了顺序 ['b', 'a', 1]

针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如

l = [
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'jack', 'age': 73, 'sex': 'male'},
    {'name': 'tom', 'age': 20, 'sex': 'female'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
]

new_l = []

for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
# [
# {'age': 18, 'sex': 'male', 'name': 'lili'},
# {'age': 73, 'sex': 'male', 'name': 'jack'},
# {'age': 20, 'sex': 'female', 'name': 'tom'}
# ]

三、其他内置方法

1、删除合集中的元素.discard().remove().pop()

s = {1, 2, 3}
s.discard(4)  # 填写删除的元素不在合集内，什么也不回发生。do nothing
s.remove(4)  # 填写删除的元素不在合集内,程序报错KeyError: 4
res = s.pop()  # 不能指定元素，会随机删除元素

2、添加元素到合集中 .update() .add()

s = {1, 2, 3}
s.update({1, 4, 5})  # 更新集合并去除重复 {1, 2, 3, 4, 5}
s.add(6)  # {1, 2, 3, 4, 5, 6} 添加单个元素到集合中 如果元素已存在则不会发生

3、对比两个集合是否有完全相同 .isdisjoint()

s.isdisjoint({3, 4, 5, 6})  # 比较两个集合，元素没有共同部分则返回 True，反之 False

四、了解 .difference_update()

s = {1, 2, 3}
s.difference_update({3, 4, 5})  # 差集后更新到元合集中去 结果>>> {1, 2, 6}

 

posted @ 2021-09-07 19:16  Euge  阅读(96)  评论(0)    收藏  举报