python学习笔记10-集合

Python集合

Python中的集合（Set）是一个无序的、不包含重复元素的数据结构。它主要用于数学上的集合操作，如并集、交集、差集和对称差集等。集合是基本的内置数据类型之一，提供了丰富的操作来支持这些数学上的集合操作。下面详细介绍Python中集合的一些基本概念和用法。集合其实就是没有value值的字典集合跟列表、字典一样都是可变序列，集合是一个没有Value的字典字典是使用{}，里面是key:value，集合也是使用{}但是里面没有value 底层数据结构也是采用了哈希表所以集合里面只有key,这个key不可重复，并且是无序的，因为跟字典一样，key都是通过哈希编译过得

集合的特性

1. 无序性

无序性：集合中的元素没有特定的顺序。与列表（List）或元组（Tuple）不同，你不能通过索引来访问集合中的元素。

2. 唯一性

唯一性：集合中的元素是唯一的，自动去除了重复的元素。这意味着如果你尝试向集合中添加一个已存在的元素，该操作将不会有任何效果，集合不会改变。

3. 不可变性（针对集合的元素）

元素不可变性：虽然集合本身是可变的（可以添加或删除元素），但其元素必须是不可变的（如整数、浮点数、字符串、元组等）。列表、字典或另一个集合等可变类型不能直接作为集合的元素，但可以通过将它们转换为不可变类型（如将列表转换为元组）后添加到集合中。

4. 支持数学上的集合操作

并集（Union）：使用 | 运算符或 union() 方法，可以获取两个集合的并集，即包含两个集合中所有不重复元素的集合。
交集（Intersection）：使用 & 运算符或 intersection() 方法，可以获取两个集合的交集，即同时属于两个集合的元素组成的集合。
差集（Difference）：使用 - 运算符或 difference() 方法，可以获取两个集合的差集，即存在于第一个集合但不在第二个集合中的元素组成的集合。
对称差集（Symmetric Difference）：使用 ^ 运算符或 symmetric_difference() 方法，可以获取两个集合的对称差集，即存在于一个集合中但不同时存在于两个集合中的元素组成的集合。

5. 集合的方法

添加元素：使用 add() 方法可以向集合中添加一个元素。
删除元素：可以使用 remove() 方法删除集合中的一个元素（如果元素不存在则抛出异常），或者使用 discard() 方法删除一个元素（如果元素不存在则不抛出异常）。
清空集合：使用 clear() 方法可以移除集合中的所有元素。
集合的更新：update() 方法用于向集合中添加多个元素，如果元素已存在则不会添加。
集合的拷贝：可以使用 copy() 方法或集合的切片操作（set_copy = original_set.copy() 或 set_copy = set(original_set)）来创建集合的浅拷贝。

6. 集合的迭代

集合支持迭代操作，可以使用 for 循环遍历集合中的元素。由于集合是无序的，所以每次迭代时元素的顺序可能会不同。

7. 集合推导式

类似于列表推导式，Python 也支持集合推导式，用于通过表达式生成集合。例如：{x**2 for x in range(6) if x % 2 == 0} 将生成一个包含0, 4, 16, 36的集合。

8. 集合的性能

由于集合的内部实现（通常使用哈希表），使得其在进行元素查找、添加和删除操作时具有非常高效的性能，时间复杂度接近 O(1)。

综上所述，Python的集合是一种功能强大且灵活的数据结构，特别适用于需要去除重复元素或进行集合运算的场景。

创建集合

集合可以通过花括号 {} 来创建，但需要注意的是，如果集合中只包含一个元素，则需要在元素后面加上逗号（,），以避免与字典字面量混淆。另外，也可以使用 set() 函数来创建空集合或从一个可迭代对象（如列表、元组等）中创建集合。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
'''
集合的创建方式

'''

#第一种创建方式，使用{}
i = {1,2,3,4,5,1,4,2}

#这个集合中有重复数据
print(i,type(i)) # {1, 2, 3, 4, 5} <class 'set'> 结果都是去重后的，集合中的元素是唯一的

'''第二种创建方式，使用内置函数set()方法'''

#range(10) 生成0-9的整数
h = set(range(10))
print(h,type(h)) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} <class 'set'>

'''将列表转换成集合'''
lis = [1,2,3,4,5,4,2,1,2]
#该列表中有重复数据，将列表转换成集合
print("原列表：",lis,type(lis)) # 原列表： [1, 2, 3, 4, 5, 4, 2, 1, 2] <class 'list'>
s = set(lis)
#成功将列表中的每个元素变成集合中的每个元素，并且进行了去重处理
print("将列表转换成集合：",s,type(s)) # 将列表转换成集合： {1, 2, 3, 4, 5} <class 'set'>

'''将元组转换成集合'''
t = ('张三',12,22,92.1,'张三')
print("原元组：",t,type(t)) # 原元组： ('张三', 12, 22, 92.1, '张三') <class 'tuple'>
#将元组转换成集合，并且元组中有重复数据
s = set(t)
# 进行了去重操作，而且顺序变了
print("将元组转换成集合：",s,type(s)) # 将元组转换成集合： {12, '张三', 22, 92.1} <class 'set'>

'''将字符串转换成集合类型'''
i = "张三zhangsan"
print("原字符串：",s,type(s)) # 原字符串： {'张三', 12, 22, 92.1} <class 'set'>
s = set(i)
print("将字符串转换成集合：",s,type(s)) # 将字符串转换成集合： {'三', 'h', 'n', 's', '张', 'a', 'g', 'z'} <class 'set'>

'''创建空集合'''
s = set()
print(s,type(s)) # set() <class 'set'>
#不能使用空的{},因为系统默认空的{}是字典
s2 = {}
print(s2,type(s2)) # {} <class 'dict'>

集合的基本运算

& 运算符或 intersection(other): 返回两个集合的交集。
| 运算符或 union(other): 返回两个集合的并集。
– 运算符或 difference(other): 返回集合的差集，即存在于第一个集合中但不在第二个集合中的元素。
^ 运算符或 symmetric_difference(other): 返回两个集合的对称差集，即存在于一个集合中但不同时存在于两个集合中的元素。

并集（Union）

并集是指两个集合中所有不重复的元素组成的集合。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# 定义两个集合  
set1 = {1, 2, 3, 4}  
set2 = {3, 4, 5, 6}  
  
# 使用 | 运算符或 union() 方法计算并集  
union_set = set1 | set2  # 使用 | 运算符  
# union_set = set1.union(set2)  # 使用 union() 方法  
  
# 输出结果  
print("并集:", union_set)  # 输出: 并集: {1, 2, 3, 4, 5, 6}

交集（Intersection）

交集是指两个集合中共有的元素组成的集合。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# 定义两个集合  
set1 = {1, 2, 3, 4}  
set2 = {3, 4, 5, 6}  
  
# 使用 & 运算符或 intersection() 方法计算交集  
intersection_set = set1 & set2  # 使用 & 运算符  
# intersection_set = set1.intersection(set2)  # 使用 intersection() 方法  
  
# 输出结果  
print("交集:", intersection_set)  # 输出: 交集: {3, 4}

差集（Difference）

差集是指存在于第一个集合中但不在第二个集合中的所有元素组成的集合。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# 定义两个集合  
set1 = {1, 2, 3, 4}  
set2 = {3, 4, 5, 6}  
  
# 使用 - 运算符或 difference() 方法计算差集  
difference_set = set1 - set2  # 使用 - 运算符  
# difference_set = set1.difference(set2)  # 使用 difference() 方法  
  
# 输出结果  
print("差集:", difference_set)  # 输出: 差集: {1, 2}

对称差集（Symmetric Difference）

对称差集是指存在于一个集合中但不同时存在于两个集合中的所有元素组成的集合。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# 定义两个集合  
set1 = {1, 2, 3, 4}  
set2 = {3, 4, 5, 6}  
  
# 使用 ^ 运算符或 symmetric_difference() 方法计算对称差集  
symmetric_difference_set = set1 ^ set2  # 使用 ^ 运算符  
# symmetric_difference_set = set1.symmetric_difference(set2)  # 使用 symmetric_difference() 方法  
  
# 输出结果  
print("对称差集:", symmetric_difference_set)  # 输出: 对称差集: {1, 2, 5, 6}

集合的遍历

使用for循环直接遍历

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 使用for循环遍历集合  
for element in my_set:  
    # 打印当前遍历到的元素  
    print(element)  
  
# 输出结果：集合中的元素将以一种看似随机的顺序被打印出来，因为集合是无序的。  
# 例如：  
# 1  
# 2  
# 3  
# 4  
# 5  
# 但每次运行的结果顺序可能不同。

转换为列表后遍历

如果你需要保持元素的遍历顺序（尽管集合本身是无序的），可以先将集合转换为列表，然后遍历列表。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 将集合转换为列表  
my_list = list(my_set)  
  
# 使用for循环遍历列表  
for element in my_list:  
    # 打印当前遍历到的元素  
    print(element)  
  
# 输出结果：将集合转换为列表后，遍历的顺序就是列表的顺序，即元素被添加到列表中的顺序（Python 3.7+中，字典和集合的插入顺序被保留）。  
# 例如：  
# 1  
# 2  
# 3  
# 4  
# 5  
# 注意：虽然输出看似有序，但这并不意味着集合本身是有序的。

使用while循环和pop()方法（不推荐，因为会修改集合）

虽然这不是遍历集合的常规方法，但理论上可以通过不断从集合中移除元素并打印它们来“遍历”集合。然而，这会修改集合本身，因此通常不推荐这样做。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 使用while循环和pop()方法遍历集合（注意：这会修改集合）  
while my_set:  
    # 移除并返回集合中的一个元素  
    element = my_set.pop()  
    # 打印当前移除的元素  
    print(element)  
  
# 输出结果：集合中的元素将被逐个移除并打印，但集合本身会被清空。  
# 注意：由于pop()方法的行为（它移除并返回集合中的一个任意元素），输出顺序也是不确定的。  
# 例如：  
# 5  
# 4  
# 3  
# 2  
# 1  
# 但每次运行的结果顺序可能不同。

集合的判断

判断元素是否存在

in 关键字: 检查元素是否存在于集合中。
not in 关键字: 检查元素是否不存在于集合中。

1
2
3
4
5
6
# 定义一个集合  
my_set = {1, 2, 3, 4}  
  
# 判断元素是否存在  
print(1 in my_set)  # 输出: True  
print(5 not in my_set)  # 输出: True

集合间的关系判断

issubset(other): 判断集合是否是另一个集合的子集。
issuperset(other): 判断集合是否是另一个集合的超集。
==, !=, <, <=, >, >=: 用于比较两个集合是否相等，或者一个集合是否是另一个集合的子集/超集（基于集合的元素）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# 定义两个集合  
set_a = {1, 2, 3}  
set_b = {1, 2, 3, 4}  
  
# 判断子集和超集关系  
print(set_a.issubset(set_b))  # 输出: True，因为set_a是set_b的子集  
print(set_b.issuperset(set_a))  # 输出: True，因为set_b是set_a的超集  
  
# 使用比较运算符  
print(set_a <= set_b)  # 输出: True，等同于issubset  
print(set_b >= set_a)  # 输出: True，等同于issuperset  
print(set_a == {1, 2, 3})  # 输出: True，集合相等  
print(set_a != set_b)  # 输出: True，集合不相等

集合的函数操作


新增	add(element)	向集合中添加一个元素，如果该元素已存在，则不会进行任何操作
新增	update(*others)	添加其他集合（或任何可迭代对象）中的元素到当前集合中，忽略重复元素
修改	discard(element)	移除集合中的一个元素，如果该元素不存在，则不进行任何操作
修改	remove(element)	移除集合中的一个元素，如果该元素不存在，则抛出KeyError异常
修改	pop()	移除并返回集合中的一个元素（随机），如果集合为空，则抛出KeyError异常
修改	clear()	移除集合中的所有元素，使其变为空集
修改	symmetric_difference_update(other)	以集合为参数，移除当前集合中在另一个集合中也出现的元素，并添加另一个集合中在当前集合中不存在的元素
删除	difference_update(*others)	移除当前集合中在指定其他集合（或任何可迭代对象）中也存在的元素
删除	intersection_update(*others)	保留当前集合中在指定其他集合（或任何可迭代对象）中也存在的元素，移除其他元素
查询	contains(element)	测试元素是否是集合的一部分，返回布尔值（不是函数，但常用）
转换	copy()	返回集合的一个浅拷贝
集合操作	union(*others)	返回一个新集合，该集合是当前集合与指定其他集合（或任何可迭代对象）的并集
集合操作	intersection(*others)	返回一个新集合，该集合是当前集合与指定其他集合（或任何可迭代对象）的交集
集合操作	difference(*others)	返回一个新集合，该集合包含当前集合中但不在指定其他集合（或任何可迭代对象）中的元素
集合操作	symmetric_difference(other)	返回一个新集合，该集合是当前集合与另一个集合的对称差集
集合操作	issubset(other)	测试当前集合是否是另一个集合的子集
集合操作	issuperset(other)	测试当前集合是否是另一个集合的超集

新增

向集合中添加元素主要使用add()方法和update()方法。

add(element)

向集合中添加一个元素，如果该元素已存在，则不会进行任何操作。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# 初始化一个空集合  
my_set = set()  
  
# 向集合中添加元素  
my_set.add(1)  # 添加整数1  
my_set.add("apple")  # 添加字符串"apple"  
  
# 输出集合内容  
print(my_set)  # 运行结果：{1, 'apple'}，注意集合是无序的  
  
# 尝试添加已存在的元素  
my_set.add(1)  # 不会有任何变化，因为1已经存在于集合中  
print(my_set)  # 运行结果仍然为：{1, 'apple'}

update(*others)

添加其他集合（或任何可迭代对象）中的元素到当前集合中，忽略重复元素。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# 初始化一个集合  
my_set = {1, 2}  
  
# 使用update添加另一个集合  
other_set = {3, 4, 2}  # 注意2是重复的  
my_set.update(other_set)  
  
# 输出更新后的集合  
print(my_set)  # 运行结果：{1, 2, 3, 4}，重复元素2被忽略  
  
# 也可以添加其他可迭代对象，如列表  
my_set.update([5, 6, 7])  
print(my_set)  # 运行结果：{1, 2, 3, 4, 5, 6, 7}

修改

集合的修改操作主要体现在添加和删除元素上，因为集合不支持通过索引直接访问或修改元素。但有几个方法可以用来“修改”集合的内容。

discard(element) 和 remove(element)

discard(element)尝试从集合中移除一个元素，如果该元素不存在，则不进行任何操作；remove(element)也尝试移除一个元素，但如果该元素不存在，则会抛出KeyError异常。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
# 初始化一个集合  
my_set = {1, 2, 3}  
  
# 使用discard移除元素  
my_set.discard(2)  
print(my_set)  # 运行结果：{1, 3}，元素2被成功移除  
  
# 尝试移除不存在的元素  
my_set.discard(4)  # 不会有任何异常，因为4不在集合中  
  
# 使用remove移除元素  
try:  
    my_set.remove(1)  
    print(my_set)  # 如果执行到这里，则输出移除1后的集合  
except KeyError:  
    print("KeyError: 尝试移除不存在的元素")  # 运行结果：KeyError: 尝试移除不存在的元素  
  
# 注意：remove操作如果元素不存在会抛出异常

删除

remove(element)

从集合中移除指定的元素。如果元素不存在，则抛出KeyError。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 移除元素3  
my_set.remove(3)  
  
# 打印更新后的集合  
print(my_set)  # 运行结果：{1, 2, 4, 5}  
  
# 尝试移除不存在的元素  
# my_set.remove(6)  # 这会抛出KeyError

discard(element)

尝试从集合中移除指定的元素。如果元素不存在，则不执行任何操作，也不会抛出异常。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 移除元素2  
my_set.discard(2)  
  
# 打印更新后的集合  
print(my_set)  # 运行结果：{1, 3, 4, 5}  
  
# 尝试移除不存在的元素  
my_set.discard(6)  
  
# 由于discard不会抛出异常，所以这里不会打印任何信息  
# 但集合仍然是{1, 3, 4, 5}  
print(my_set)  # 运行结果：{1, 3, 4, 5}

pop()

从集合中移除并返回任意一个元素。集合是无序的，所以返回的元素是不确定的。如果集合为空，则抛出KeyError。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 移除并返回任意一个元素  
popped_element = my_set.pop()  
  
# 打印被移除的元素和更新后的集合  
print(f"被移除的元素是：{popped_element}")  # 运行结果可能不同，例如：被移除的元素是：4  
print(my_set)  # 运行结果可能不同，例如：{1, 2, 3, 5}  
  
# 尝试从空集合中pop元素  
# my_set.clear()  # 首先清空集合  
# popped_element = my_set.pop()  # 这会抛出KeyError

clear()

移除集合中的所有元素，使其变为空集合。

1
2
3
4
5
6
7
8
# 定义一个集合  
my_set = {1, 2, 3, 4, 5}  
  
# 清空集合  
my_set.clear()  
  
# 打印清空后的集合  
print(my_set)  # 运行结果：set()

注意事项

集合是无序的，因此使用pop()方法时，返回的元素是不确定的。
如果尝试从集合中移除不存在的元素，remove()方法会抛出KeyError，而discard()方法则不会。
集合中的元素必须是唯一的，即集合中不会有两个相同的元素。