数学上,把set称做由不同的元素组成的集合,集合(set)的成员通常被称做集合元素(set elements)。Python把这个概念引入到它的集合类型对象里。集合对象是一组无序排列的可哈希的值。集合关系测试和union
、intersection
、difference
(并集,交集,差集)等操作符在Python里也同样如我们所预想地那样工作。
首先python数据结构分为可变和不可变,set属于可变序列
集合中的元素有三个特征:
python中集合(set)是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素,还可以计算交集、差集、并集等。它与列表(list)的行为类似,区别在于set不能包含重复的值,而且set元素是无序的。
在python中可以用大括号 {}
创建集合。注意:如果要创建或初始化一个空集合,你必须用 set() 而不是 {}
。因为后者{}
作为创建一个空的字典,以后我们会介绍字典这种数据结构。
s1 = set() # 创建空集合, 必须用set(),不能用直接用{}创建
print(s1) # 打印空集合不是{} 而是set(),是为了和空字典区分
print(type(s1))
# set()
#
d = {} # 这个是创建空字典,注意区别
print(d, type(d))
# {}
可以自己加入元素创建
也可以利用set()
函数从已有的数据结构(列表、字符串、元组)直接转化为集合(主要目的是为了去重)
s1 = {2, 1, 3}
print(s1) # 下面输出结果看出,集合是无序的
# {1, 2, 3}
s2 = {1, 2, 3, 3} # 虽然加入的元素有重复,但是集合自动去重
print(s2)
# {1, 2, 3}
# 使用工厂创建集合,但是注意参数是可迭代的
s3 = set('12aa')
print(s3)
# {'1', '2', 'a'}
s4 = set([1, 2, 'a', 'a'])
print(s4)
# {1, 2, 'a'}
s5 = set(((1,2),(3,4),(1,3),(1,2)))
print(s5)
# {(1, 2), (1, 3), (3, 4)}
讨论:
根据上面代码,我们发现,创建空集合只能用
set()
,不能用{}
。而且非空集合打印结果是由{}
包裹起来的,前面我们学元组(tuple),它的打印结果是由()
包裹起来的。另外有第二段代码可以看出集合是无序的,通过set()
可以把其他数据结构转换为集合,而且自动去重。
集合添加元素使用set.add()
集合删除元素使用set.remove()
s1 = {2, 1, 3}
print(s1)
# {1, 2, 3}
s1.add(4)
print(s1)
# {1, 2, 3, 4}
s1.remove(2)
print(s1)
# {1, 3, 4}
注意集合中删除指定元素不要用pop!!
首先pop()只能在可变序列中使用
在列表,字典中都可以用pop(),列表中pop参数是索引,字典中pop参数是key
而set中没有索引也没有key的概念,所以
set.pop()
中不添加任何参数而且
set.pop()
的作用是随机删除集合中的一个元素,它是随即删除,所以其效果非常不可控,建议不要在集合中使用pop()
循环遍历,只能用for循环遍历
# 集合遍历使用for
s1 = {5, 4, 3, 2, 1}
# print(s1)
# # {1, 2, 3, 4, 5}
for x in s1:
print(x, end=" ")
# 1 2 3 4 5
可以看到上面打印和遍历的结果并不是按照原来集合中输入的顺序
所以再一次说明,集合就是无序的
集合没有索引,不能使用索引获取对应元素,比如使用s[1]
会报错,想想为什么?
s1={1,2,3}
print(s1[1])
# TypeError: 'set' object does not support indexing
因为集合是无序的!所以不肯定不能有索引。如果有索引即代表其是有序的
数学符号 | Python符号 | 函数版 | 含义 |
---|---|---|---|
- 或| - | - | difference() | 差集,相对补集 |
∩ | & | intersection() | 交集 |
∪ | | | union() | 并集 |
≠ | != | 不等于 | |
= | == | 等于 | |
∈ | in | 是成员关系 | |
∉ | not in | 非成员关系 |
例子
s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7, 8}
print(s1 - s2) # 差集,等价于s1.difference(s2)
# {1, 2, 3}
print(s2 - s1) # 等价于s2.difference(s1)
# {8, 6, 7}
print(s1 & s2) # 交集 等价于s1.intersection(s2),s1和s2互换位置也可
# {4, 5}
print(s1 | s2) # 并集 等价于s1.union(s2),s1和s2互换位置也可
# {1, 2, 3, 4, 5, 6, 7, 8}
print(s1 ^ s2) # 交叉补集 即并集减去交集
# {1, 2, 3, 6, 7, 8}
print(6 in s1)
# False
print(6 not in s1)
# True
注意函数和符号的用法完全等价,其都会产生一个新的对象,不会对原集合s1和s2进行修改
如果要对集合进行交并补操作并原地修改需要用到赋值操作
# 将s1更新为s1和s2的交集
s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7, 8}
s1.intersection(s2)
print(s1)
# {1, 2, 3, 4, 5} 没有对s1进行修改
s1 = s1.intersection(s2) # 一定要用到赋值操作
print(s1)
# {4, 5}
方法 | 描述 |
---|---|
add() | 为集合添加元素 |
update() | 给集合添加元素 |
clear() | 移除集合中的所有元素 |
copy() | 拷贝一个集合 |
pop() | 随机移除元素 |
remove() | 移除指定元素 |
discard() | 删除集合中指定的元素 |
isdisjoint() | 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。 |
issubset() | 判断指定集合是否为该方法参数集合的子集。 |
issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
symmetric_difference() | 返回两个集合中不重复的元素集合。 |
symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。 |
union() | 返回两个集合的并集,等同于 | |
difference() | 返回多个集合的差集,等同于 - |
difference_update() | 移除集合中的元素,该元素在指定的集合也存在。 |
intersection() | 返回集合的交集 |
intersection_update() | 返回集合的交集。 |
例子
s1 = {1, 2, 3}
s1.add(4)
s1.add(3) # 添加重复元素,自动去重
print(s1)
# {1, 2, 3, 4}
s2 = {3, 4, 5}
s1.update(s2)
print(s1)
# {1, 2, 3, 4, 5}
s1.remove(1)
print(s1)
# {2, 3, 4, 5}
操作 | 平均情况 | 最坏情况 |
---|---|---|
x in s | O(1) | O(n) |
并集 s|t | O(len(s)+len(t)) | |
交集 s&t | O(min(len(s), len(t)) | O(len(s) * len(t)) |
差集 s-t | O(len(s)) | |
s.difference_update(t) | O(len(t)) | |
交叉补集 s^t | O(len(s)) | O(len(s) * len(t)) |
对称差集s.symmetric_difference_update(t) | O(len(t)) | O(len(t) * len(s)) |
底层实现机制,面试常见问题
核心:集合的底层和字典的底层一样,都是哈希表
集合能如此高效,和它的内部的数据结构密不可分。不同于其他数据结构,集合的内部结构是一张哈希表:哈希表内只存储单一的元素。不了解哈希原理和特性的可网上搜索一下,以后我们也会写一些这方面内容。
当向集合中插入数据时,Python会根据通过 hash(valuse) 函数,计算该元素对应的哈希值。得到哈希值(例如为 hash)之后,再结合集合要存储数据的个数(例如 n),就可以得到该元素应该插入到哈希表中的位置(比如用 取模法 hash%n 方式)。
如果哈希表中此位置是空的,那么此元素就可以直接插入其中;反之,如果此位置已被其他元素占用,那么 Python 会比较这两个元素的哈希值是否相等:
重点:
在哈希表中查找数据,和插入操作类似,Python 会根据哈希值,找到该元素应该存储到哈希表中的位置,然后和该位置的元素比较元素值:
对于删除操作,Python 会暂时对这个位置的元素赋于一个特殊的值,等到重新调整哈希表的大小时,再将其删除。
重点:
虽然哈希冲突和哈希表大小的调整,都会导致速度减缓,但是这种情况发生的次数极少。所以,平均情况下,仍能保证插入、查找和删除的时间复杂度为 O(1)。
set的去重是通过两个函数**__hash__
和__eq__
**结合实现的。
当两个元素的哈希值不相同时,就认为这两个变量是不同的
当两个元素哈希值一样时,调用**__eq__
**方法,当返回值为True时认为这两个变量是同一个,应该去除一个。返回FALSE时,不去重。