Python字典dict使用教程：快速查找键值对的高效方法

网站地址:

dict

Python 自身带有对字典：dict 的支持，dict 的全称为 dictionary，在其他语言里它也被称作 map，通过键 - 值（key-value）的方式来进行存储，并且有着极为快速的查找速度。

举个例子，假如要依据同学的名字去查找相对应的成绩，要是通过 list 来实现的话，那就需要两个 list 。

names = 
scores = [95, 75, 85]

给定一个名字，若要查找对应的成绩，需先在 names 里找到其对应的位置，接着从 scores 中取出对应的成绩，当 list 变长时，耗时会变长。

若使用 dict 来实现的话，仅需一个“名字”-“成绩”的对照表格。能够直接依据名字去查找成绩，不管这个表格的规模有多大，其查找速度都不会减慢。用 Python 编写一个 dict 示例如下：

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

为什么 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

如果key不存在，dict就会报错：

>>> d['Thomas']
追踪回溯（最近的调用最后）：
  File "<stdin>", line 1, in <module>
KeyError: 'Thomas'

要避免出现 key 不存在的错误，有以下两种办法。其一，通过 in 来判断 key 是否存在。

>>> 'Thomas' in d
False

二是利用 dict 所提供的 get 方法，倘若 key 不存在，那么能够返回 None ，亦或是自行指定的 value ：

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

如果注意到返回 None 的情况，那么 Python 的交互式命令行不会显示结果。

要删除一个键，可使用 pop(key) 方法，这样与之对应的值也会从字典中被删除。

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

请务必注意，dict 内部存放的顺序与 key 放入的顺序无关。

和list比较，dict有以下几个特点：

查找速度极快，且不会随 key 的增加而变慢；插入速度也极快，同样不会因 key 增加而变慢。占用内存量大，存在较多内存浪费。

而list相反：

查找的时间会随着元素的增加而增加；插入的时间也会随着元素的增加而增加。它占用的空间小，对内存的浪费也很少。

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

dict 能在很多需要高速查找的地方被使用，在 Python 代码里几乎到处都有它的身影。正确使用 dict 是很重要的，需要牢记的首要一点是 dict 的 key 必须是不可变对象。

这是因为 dict 是依据 key 去计算 value 的存储位置的。倘若每次对相同的 key 进行计算所得到的结果不一样，那么 dict 内部就会彻底陷入混乱状态。将通过 key 来计算位置的这种算法称作哈希算法（Hash）。

为保证 hash 的正确性，作为 key 的对象不能发生改变。在 Python 中，字符串是不可变的，所以能够放心地用作 key。整数也是不可变的，同样可以用作 key。而 list 是可变的，故而不能作为 key。

>>> key = [1, 2, 3]
>>> d[key] = 'a list'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
类型错误：不可哈希的类型：“列表”

set

set 与 dict 相似，它是一组 key 的集合。并且，set 不存储 value。因为 key 不能重复，所以在 set 里，不存在重复的 key。

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

>>> s = set([1, 2, 3])
>>> s
{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}

通过 add(key) 方法能够将元素添加到 set 里，即便重复添加，也不会产生实际效果。

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

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

>>> s.remove(4)
>>> s
{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}

set 和 dict 的唯一差异在于 set 没有存储对应的 value。然而，set 的原理与 dict 相同，正因如此，同样不能放入可变对象，因为无法对两个可变对象是否相等进行判断，也就无法确保 set 内部“不会有重复元素”。你可以尝试将 list 放入 set 中，查看是否会报错。

再议不可变对象

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

对于可变对象，像 list 这样的。当对 list 进行操作时，list 内部的内容会发生变化，例如：

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']

而对于不可变对象，比如str，对str进行操作呢：

>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'

字符串具有 replace()方法，它确实将字符串变成了'Abc'，然而变量 a 最终仍然是'abc'，这该如何理解呢？

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

>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'

要牢记，a 是变量，“abc”是字符串对象。有时我们会说对象 a 的内容是“abc”，但实际上是 a 本身是变量，它指向的对象内容才是“abc”。

当调用 a.replace('a', 'A!)时，是对字符串对象'abc'调用了 replace 方法。这个方法名为 replace，但它并没有对字符串'abc'的内容进行改变。相反，创建了一个新字符串“Abc”并通过 replace 方法返回。若用变量 b 指向这个新字符串，就便于理解了。此时变量 a 依然指向原有的字符串“abc”，而变量 b 则指向新字符串“Abc”。

对于不变对象而言，调用它自身的任意方法，都不会使该对象自身的内容发生改变。相反，这些方法会创建出新的对象并将其返回，从而保证了不可变对象本身始终是不可变的。