集合 set
集合是一种不包含重复元素的数据结构,经常用来判断是否重复这种操作,或者集合中是否存在一个元素。
这一章讲集合,实际上它的底层也是哈希表实现的,所以像实现 DictADT 一样,借助 HashTable 实现它也比较简单。
集合操作
集合可能最常用的就是去重,判断是否存在一个元素等,但是 set 相比 dict 有更丰富的操作,主要是数学概念上的。
如果你学过《离散数学》中集合相关的概念,基本上是一致的。 python 的 set 提供了如下基本的集合操作,
假设有两个集合 A,B,有以下操作:
- 交集: A & B,表示同时在 A 和 B 中的元素。 python 中重载
__and__
实现 - 并集: A | B,表示在 A 或者 B 中的元素,两个集合相加。python 中重载
__or__
实现 - 差集: A - B,表示在 A 中但是不在 B 中的元素。 python 中重载
__sub__
实现 - 对称差: A ^ B,返回在 A 或 B 但是不在 A、B 中都出现的元素。其实就是 (A|B) - (A&B), python 中重载
__xor__
实现
这里使用的 &, |, -, ^ 在 python 内置的 set 实现中都是重载了内置的运算符。这里我们也用这种方式实现,
具体实现我会在视频里演示。python 同样实现了 intersection, union, difference, symmetric_difference 这四个方法,
和使用运算符的功能是一样的。
python frozenset
在 python 里还有一个 frozenset,看它的名字就知道这种也是集合,但是它的内容是无法变动的。一般我们使用
它的常见就是用一个可迭代对象初始化它,然后只用来判重等操作。
实现一个 set ADT
如何实现一个集合的 ADT 呢,其实还是个哈希表,哈希表不是有 key 和 value 嘛,咱把 value 置为 1 不就行了。
class SetADT(HashTable):
def add(self, key):
# 集合其实就是一个 dict,只不过我们把它的 value 设置成 1
return super(SetADT, self).add(key, True)
当然其它数学上的操作就麻烦点了,不过也很容易实现。
源码
# -*- coding: utf-8 -*-
# 从数组和列表章复制的代码
class Array(object):
def __init__(self, size=32, init=None):
self._size = size
self._items = [init] * size
def __getitem__(self, index):
return self._items[index]
def __setitem__(self, index, value):
self._items[index] = value
def __len__(self):
return self._size
def clear(self, value=None):
for i in range(len(self._items)):
self._items[i] = value
def __iter__(self):
for item in self._items:
yield item
class Slot(object):
"""定义一个 hash 表 数组的槽
注意,一个槽有三种状态,看你能否想明白。相比链接法解决冲突,二次探查法删除一个 key 的操作稍微复杂。
1.从未使用 HashMap.UNUSED。此槽没有被使用和冲突过,查找时只要找到 UNUSED 就不用再继续探查了
2.使用过但是 remove 了,此时是 HashMap.EMPTY,该探查点后边的元素扔可能是有key
3.槽正在使用 Slot 节点
"""
def __init__(self, key, value):
self.key, self.value = key, value
class HashTable(object):
UNUSED = None # 没被使用过
EMPTY = Slot(None, None) # 使用却被删除过
def __init__(self):
self._table = Array(8, init=HashTable.UNUSED) # 保持 2*i 次方
self.length = 0
@property
def _load_factor(self):
# load_factor 超过 0.8 重新分配
return self.length / float(len(self._table))
def __len__(self):
return self.length
def _hash(self, key):
return abs(hash(key)) % len(self._table)
def _find_key(self, key):
index = self._hash(key)
_len = len(self._table)
while self._table[index] is not HashTable.UNUSED:
if self._table[index] is HashTable.EMPTY:
index = (index*5 + 1) % _len
continue
elif self._table[index].key == key:
return index
else:
index = (index*5 + 1) % _len
return None
def _find_slot_for_insert(self, key):
index = self._hash(key)
_len = len(self._table)
while not self._slot_can_insert(index):
index = (index*5 + 1) % _len
return index
def _slot_can_insert(self, index):
return (self._table[index] is HashTable.EMPTY or self._table[index] is HashTable.UNUSED)
def __contains__(self, key): # in operator
index = self._find_key(key)
return index is not None
def add(self, key, value):
if key in self:
index = self._find_key(key)
self._table[index].value = value
return False
else:
index = self._find_slot_for_insert(key)
self._table[index] = Slot(key, value)
self.length += 1
if self._load_factor >= 0.8:
self._rehash()
return True
def _rehash(self):
old_table = self._table
newsize = len(self._table) * 2
self._table = Array(newsize, HashTable.UNUSED)
self.length = 0
for slot in old_table:
if slot is not HashTable.UNUSED and slot is not HashTable.EMPTY:
index = self._find_slot_for_insert(slot.key)
self._table[index] = slot
self.length += 1
def get(self, key, default=None):
index = self._find_key(key)
if index is None:
return default
else:
return self._table[index].value
def remove(self, key):
index = self._find_key(key)
if index is None:
raise KeyError()
value = self._table[index].value
self.length -= 1
self._table[index] = HashTable.EMPTY
return value
def __iter__(self):
for slot in self._table:
if slot not in (HashTable.EMPTY, HashTable.UNUSED):
yield slot.key
#########################################
# 上边是从 哈希表章 拷贝过来的代码,我们会直接继承 HashTable 实现 集合 set
#########################################
class SetADT(HashTable):
def add(self, key):
# 集合其实就是一个 dict,只不过我们把它的 value 设置成 1
return super(SetADT, self).add(key, True)
def __and__(self, other_set):
"""交集 A&B"""
new_set = SetADT()
for element_a in self:
if element_a in other_set:
new_set.add(element_a)
return new_set
def __sub__(self, other_set):
"""差集 A-B"""
new_set = SetADT()
for element_a in self:
if element_a not in other_set:
new_set.add(element_a)
return new_set
def __or__(self, other_set):
"""并集 A|B"""
new_set = SetADT()
for element_a in self:
new_set.add(element_a)
for element_b in other_set:
new_set.add(element_b)
return new_set
def test_set_adt():
sa = SetADT()
sa.add(1)
sa.add(2)
sa.add(3)
assert 1 in sa # 测试 __contains__ 方法,实现了 add 和 __contains__,集合最基本的功能就实现啦
sb = SetADT()
sb.add(3)
sb.add(4)
sb.add(5)
assert sorted(list(sa & sb)) == [3]
assert sorted(list(sa - sb)) == [1, 2]
assert sorted(list(sa | sb)) == [1, 2, 3, 4, 5]
if __name__ == '__main__':
test_set_adt()
思考题
- 集合判断一个元素是否存在的时间复杂度是多少?
- 集合的元素 key 需要满足什么概念?可变对象可以吗?
- 请你在 SetADT 基础上实现集合的 remove 操作和 pop 操作
- 你能尝试实现对称差操作吗?这里我没有实现,留给你作为练习
- 你知道如何重载 python 的内置运算符吗?这里我们实现 set 的集合操作就是用到了重载,请阅读相关 python 文档。
- 当元素个数不多的时候,我们可以用 set 来判重,但是如果是大量元素会非常耗费内存。请你了解下 Bloom Filter
延伸阅读
阅读 python 文档关于 set 的相关章节,了解 set 还有哪些操作?比如比较运算符的概念,比较两个集合意味着什么。