『无为则无心』Python序列 — 22、Python集合及其常用操作

目录

• 1、Python集合特点
• 2、Python集合的创建
• 3、操作集合常用API
  • （1）增加数据
    • @1、add()方法
    • @2、update()方法
  • （2）删除数据
    • @1、remove()方法
    • @2、discard()方法
    • @3、pop()方法
    • @4、claer()方法
  • （3）查找数据
  • （4）copy()复制
• 4、集合的运算

1、Python集合特点

1. 集合可以对自己的元素去掉重复数据。
2. 集合元素的展示顺序和写入顺序不一致，所以集合元素是无序的，故集合也不支持下标。
3. 集合是可变类型数据。
4. 集合中只能存储不可变对象。

2、Python集合的创建

创建集合使用{}或set()， 但是如果要创建空集合只能使用set()，因为{}用来创建空字典了。

# 1.创建有数据的集合
# 可以看到集合是无序的。
# 结果:{40, 10, 50, 20, 30}
s1 = {10, 20, 30, 40, 50}
print(s1)

# 2.创建一个有重复元素的集合
# 可以看到结果，集合有去重的功能。
# 结果：{40, 10, 50, 20, 30}
s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2)

# 3.把一个序列作为数据，创建一个集合
# 结果去重，且无序
# 结果：{'f', 'g', 'e', 'd', 'a', 'c', 'b'}
s3 = set('abcdefga')
print(s3)

# 结果:{'猪八戒', '孙悟空', '沙和尚', '唐僧'}
name_list = ['孙悟空','猪八戒','沙和尚','唐僧']
s4 = set(name_list)
print(s4)

# 4.使用set()方法创建一个空集合
s5 = set()
print(s5)  # set()
print(type(s5))  # <class 'set'>

# 5.不能使用{}创建空集合，创建出来的是一个字典。
s6 = {}
print(s6)  # {}
print(type(s6))  # <class 'dict'>

# 6.集合中只能存储不可变对象。
# 结果：TypeError: unhashable type: 'list'
s = {[1,2,3],[4,6,7]}
# 存元组可以。不会报错
# 结果：{(4, 6, 7), (1, 2, 3)}
s = {(1, 2, 3), (4, 6, 7)}
print(s)

# 7.使用set()将字典转换为集合时，只会包含字典中的键
# 结果：{'c', 'a', 'b'}
s = set({'a': 1, 'b': 2, 'c': 3})
print(s)

3、操作集合常用API

（1）增加数据

@1、add()方法

只能添加不可变类型数据，序列不行。

s1 = {10, 20}

# 1.向集合中添加元素
# 结果：{10, 20, 70}
s1.add(70)

# 2.集合有去重功能，向集合中添加重复元素，不和有任何操作。
# 结果：{10, 20, 70}
s1.add(10)
print(s1) 

# 3.他通过add()方法，向集合中添加序列，会报错
# 结果：TypeError: unhashable type: 'list'
print(s1)
s1.add([666, 888, 999])

因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。

@2、update()方法

update()方法可以向集合中添加序列。

# 结果：{100, 10, 20, 200}
s1 = {10, 20}
s1.update([100, 200])
print(s1)

# 通过`update()`方法向集合添加基本类型数据，会抛异常。
# 结果：TypeError: 'int' object is not iterable
s1.update(100)
print(s1)

# update()可以传递字典作为参数，只会使用字典的键
# 结果：{100, 1000, 10, 20}
s1 = {10, 20}
s1.update({100: 'cd', 1000: 'ef'})
print(s1)

（2）删除数据

@1、remove()方法

remove()方法，删除集合中的指定数据，如果数据不存在则报错。

# 1.删除集合中指定元素
# 结果：{20, 30}
s1 = {10, 20, 30}
s1.remove(10)
print(s1)

# 2.删除的元素不存在于集合中，则会报错。
# 结果：KeyError: 40
s1.remove(40)
print(s1)

@2、discard()方法

discard()方法，删除集合中的指定数据，如果数据不存在也不会报错。

# 1.删除集合中指定元素
# 结果：{20, 30}
s1 = {10, 20, 30}
s1.discard(10)
print(s1)

# 2.删除的元素不存在于集合中，不会报错。
# 结果：{10, 20, 30}
s1.discard(40)
print(s1)

@3、pop()方法

pop()方法，随机删除集合中的某个数据，并返回这个数据。

"""
输出结果：
删除的数据为： 40
{10, 50, 20, 30}
"""
s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()
print('删除的数据为：', del_num)
print(s1)

@4、claer()方法

清空集合，用法同列表、字典。

"""
输出结果：
清空前： {888, 666, 999}
清空后： set()
"""
name_set = {666, 888, 999}
print("清空前：", name_set)
name_set.clear()
print("清空后：", name_set)

（3）查找数据

你无法通过索引来查找集合中的数据。

• in：判断数据在集合序列
• not in：判断数据不在集合序列

s1 = {10, 20, 30, 40, 50}
print(10 in s1)  # True
print(10 not in s1)  # False
print(100 in s1)  # False
print(100 not in s1)  # True

（4）copy()复制

浅复制，同字典，具体说明请点击查看字典的copy()方法。

4、集合的运算

示例如下：

# 在对集合做运算时，不会影响原来的集合，而是返回一个运算结果。

# 创建两个集合
s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# 1.& 交集运算
# 结果：{3, 4, 5}
result = s & s2 

# 2.| 并集运算
# 结果：{1,2,3,4,5,6,7}
result = s | s2 # 

# 3.- 差集：只在A集合里有的，B集合里没有
# 结果：{1, 2}
result = s - s2 

# 4.^ 异或集 获取只在一个集合中出现的元素
# 就是两个集合中不重叠的部分。
# 结果：{1, 2, 6, 7}
result = s ^ s2 

# 5.<= 检查一个集合是否是另一个集合的子集
# 如果a集合中的元素全部都在b集合中出现，
# 那么a集合就是b集合的子集，b集合是a集合超集。
a = {1,2,3}
b = {1,2,3,4,5}

result = a <= b # True
result = {1,2,3} <= {1,2,3} # True
result = {1,2,3,4,5} <= {1,2,3} # False

# 6.< 检查一个集合是否是另一个集合的真子集
# 如果超集b中含有子集a中所有元素，
# 并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集。
result = {1,2,3} < {1,2,3} # False
result = {1,2,3} <= {1,2,3} # True
result = {1,2,3} < {1,2,3,4,5} # True

# >= 检查一个集合是否是另一个的超集
# > 检查一个集合是否是另一个的真超集
print('result =',result)