dict 和 set

Mr.Hope ... 2020-05-25 Python 大约 10 分钟

dictset 是 Python 中常用的数据结构。

# dict

Python 内置了字典: dict 的支持,dict 全称 dictionary,在其他语言中也称为 map,使用键-值(key-value)存储,具有极快的查找速度。

举个例子,假设要根据同学的名字查找对应的成绩,如果用 list 实现,需要两个 list:

names = ['Michael', 'Bob', 'Tracy']
scores = [95, 75, 85]
1
2

给定一个名字,要查找对应的成绩,就先要在 names 中找到对应的位置,再从 scores 取出对应的成绩,list 越长,耗时越长。

如果用 dict 实现,只需要一个“名字”-“成绩”的对照表,直接根据名字查找成绩,无论这个表有多大,查找速度都不会变慢。用 Python 写一个 dict 如下:

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
1
2
3

为什么 dict 查找速度这么快?因为 dict 的实现原理和查字典是一样的。假设字典包含了 1 万个汉字,我们要查某一个字,一个办法是把字典从第一页往后翻,直到找到我们想要的字为止,这种方法就是在 list 中查找元素的方法,list 越大,查找越慢。

第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字。无论找哪个字,这种查找速度都非常快,不会随着字典大小的增加而变慢。

dict 就是第二种实现方式,给定一个名字,比如 'Michael',dict 在内部就可以直接计算出 Michael 对应的存放成绩的“页码”,也就是 95 这个数字存放的内存地址,直接取出来,所以速度非常快。

您可以猜到,这种 key - value 存储方式,在放进去的时候,必须根据 key 算出 value 的存放位置,这样,取的时候才能根据 key 直接拿到 value。

把数据放入 dict 的方法,除了初始化时指定外,还可以通过 key 放入:

>>> d['Adam'] = 67
>>> d['Adam']
67
由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉:
>>> d['Jack'] = 90
>>> d['Jack']
90
>>> d['Jack'] = 88
>>> d['Jack']
88
1
2
3
4
5
6
7
8
9
10

如果 key 不存在,dict 就会报错:

>>> d['Thomas']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Thomas'
1
2
3
4

要避免 key 不存在的错误,有两种办法,一是通过 in 判断 key 是否存在:

>>> 'Thomas' in d
False
1
2

二是通过 dict 提供的 get() 方法,如果 key 不存在,可以返回 None,或者自己指定的 value:

>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
1
2
3

注意

返回 None 的时候 Python 的交互环境不显示结果。

要删除一个 key,用 pop(key) 方法,对应的 value 也会从 dict 中删除:

>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}
1
2
3
4

请务必注意,dict 内部存放的顺序和 key 放入的顺序是没有关系的。

和 list 比较,dict 有以下几个特点:

  • 查找和插入的速度极快,不会随着 key 的增加而变慢;
  • 需要占用大量的内存,内存浪费多。

而 list 相反:

  • 查找和插入的时间随着元素的增加而增加;
  • 占用空间小,浪费内存很少。

所以,dict 是用空间来换取时间的一种方法。

dict 可以用在需要高速查找的很多地方,在 Python 代码中几乎无处不在,正确使用 dict 非常重要,需要牢记的第一条就是 dict 的 key 必须是不可变对象

这是因为 dict 根据 key 来计算 value 的存储位置,如果每次计算相同的 key 得出的结果不同,那 dict 内部就完全混乱了。这个通过 key 计算位置的算法称为哈希算法(Hash)。

要保证 hash 的正确性,作为 key 的对象就不能变。在 Python 中,字符串、整数等都是不可变的,因此,可以放心地作为 key。而 list 是可变的,就不能作为 key:

>>> key = [1, 2, 3]
>>> d[key] = 'a list'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
1
2
3
4
5

关于 dict 的补充内容请看脚注[1]

# set

set 和 dict 类似,也是一组 key 的集合,但不存储 value。由于 key 不能重复,所以,在 set 中,没有重复的 key。

要创建一个 set,需要提供一个 list 作为输入集合:

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
1
2
3

注意,传入的参数 [1, 2, 3] 是一个 list,而显示的 {1, 2, 3} 只是告诉您这个 set 内部有 1,2,3 这 3 个元素,显示的顺序也不表示 set 是有序的。。

重复元素在 set 中自动被过滤:

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}
1
2
3

通过 add(key) 方法可以添加元素到 set 中,可以重复添加,但不会有效果:

>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
1
2
3
4
5
6

通过 remove(key) 方法可以删除元素:

>>> s.remove(4)
>>> s
{1, 2, 3}
1
2
3

set 可以看成数学意义上的无序和无重复元素的集合,因此,两个 set 可以做数学意义上的交集、并集等操作:

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
1
2
3
4
5
6

set 和 dict 的唯一区别仅在于没有存储对应的 value,但是,set 的原理和 dict 一样,所以,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证 set 内部“不会有重复元素”。试试把 list 放入 set,看看是否会报错。

# 不可变对象

上面我们讲了,str 是不变对象,而 list 是可变对象。

对于可变对象,比如 list,对 list 进行操作,list 内部的内容是会变化的,比如:

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']
1
2
3
4

而对于不可变对象,比如 str,对 str 进行操作呢:

>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'
1
2
3
4
5

虽然字符串有个 replace() 方法,也确实变出了 'Abc',但变量 a 最后仍是 'abc',应该怎么理解呢?

我们先把代码改成下面这样:

>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'
1
2
3
4
5
6

要始终牢记的是,a 是变量,而 'abc' 才是字符串对象!有些时候,我们经常说,对象 a 的内容是 'abc',但其实是指,a 本身是一个变量,它指向的对象的内容才是 'abc':

┌───┐                  ┌───────┐
│ a │─────────────────>│ 'abc' │
└───┘                  └───────┘
1
2
3

当我们调用 a.replace('a', 'A') 时,实际上调用方法 replace 是作用在字符串对象 'abc' 上的,而这个方法虽然名字叫 replace,但却没有改变字符串 'abc' 的内容。相反,replace 方法创建了一个新字符串 'Abc' 并返回,如果我们用变量 b 指向该新字符串,就容易理解了,变量 a 仍指向原有的字符串 'abc',但变量 b 却指向新字符串 'Abc' 了:

┌───┐                  ┌───────┐
│ a │─────────────────>│ 'abc' │
└───┘                  └───────┘
┌───┐                  ┌───────┐
│ b │─────────────────>│ 'Abc' │
└───┘                  └───────┘
1
2
3
4
5
6

所以,对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的。

# 小结

使用 key-value 存储结构的 dict 在 Python 中非常有用,选择不可变对象作为 key 很重要,最常用的 key 是字符串。

tuple 虽然是不变对象,但试试把 (1, 2, 3)(1, [2, 3]) 放入 dict 或 set 中,并解释结果。


  1. 补充内容

    要理解 dict 的有关内容需要您理解哈希表(map)的相关基础知识,这个其实是《算法与数据结构》里面的内容。

    1. list 和 tuple 其实是用链表顺序存储的,也就是前一个元素中存储了下一个元素的位置,这样只要找到第一个元素的位置就可以顺藤摸瓜找到所有元素的位置,所以 list 的名字其实就是个指针,指向 list 的第一个元素的位置。list 的插入和删除等可以直接用链表的方式进行,比如我要在第 1 个元素和第 2 个元素中间插入一个元素,那么直接在链表的最后面(我们假设这个 list 只有两个元素,那么也就是在第 3 个元素的位置上)插入这个元素,然后把第一个元素指针指向这个元素(第 3 个位置),然后再把新插入的元素的指针指向原来的第 2 个元素,这样插入操作就完成了。读取这个 list 的时候,先用 list 的名字(就是个指针,指向第 1 个元素的位置)找到第一个元素,然后用第 1 一个元素的指针找到第 2 个元素(位置 3),然后用第 2 个元素的指针找到第 3 个元素(位置 2),以此类推。所以 list 的顺序和内存中的实际顺序其实不一定完全对应。这种存储方式不会浪费内存,但查找起来特别费时间,因为要按照链表一个一个找下去,如果您的 list 特别大的话,那么要等好久才会找到结果。

    2. dict 则为了快速查找使用了一种特别的方法,哈希表。哈希表采用哈希函数从 key 计算得到一个数字(哈希函数有个特点: 对于不同的 key,有很大的概率得到的哈希值也不同),然后直接把 value 存储到这个数字所对应的地址上,比如 key='ABC',value=10,经过哈希函数得到 key 对应的哈希值为 123,那么就申请一个有 1000 个地址(从 0 到 999)的内存,然后把 10 存放在地址为 123 的地方。类似的,对于 key='BCD',value=20,得到 key 的哈希值为 234,那么就把 20 存放在地址为 234 的地方。对于这样的表查找起来是非常方便的。只要给出 key,计算得到哈希值,然后直接到对应的地址去找 value 就可以了。无论有几个元素,都可以直接找到 value,无需遍历整个表。不过虽然 dict 查找速度快,但内存浪费严重,您看我们只存储了两个元素,都要申请一个长度为 1000 的内存。

    3. 现在您知道为啥 key 要用不可变对象了吧?因为不可变对象是常量,每次的哈希值算出来都是固定的,这样就不会出错。比如 key='ABC',value=10,存储地址为 123,假设我突发奇想,把 key 改成 'BCD',那么当查找 'BCD' 的 value 的时候就会去 234 的地址找,但那里啥也没有,这就乱套了。

    对于不同的 key,有很大的概率得到的哈希值也不同。那么有很小的概率不同的 key 可以得到相同的哈希值了?没错,比如对于我们的例子来说,哈希值只有 3 位,那么只要元素个数超过 1000,就一定会有至少两个 key 的哈希值相同(鸽笼原理),这种情况叫“冲突”,设计哈希表的时候要采取办法减少冲突,实在冲突了也要想办法补救。不过这是编译器的事情,况且对于初学者的我们来说碰到的冲突的概率基本等于零,就不用操心了。 ↩︎