dict 和 set

廖雪峰...大约 10 分钟

dict 和 set 是 Python 中常用的数据结构。

set

set 和 dict 类似，也是一组 key 的集合，但不存储 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 的唯一区别仅在于没有存储对应的 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 │─────────────────>│ 'abc' │
└───┘                  └───────┘

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

┌───┐                  ┌───────┐
│ a │─────────────────>│ 'abc' │
└───┘                  └───────┘
┌───┐                  ┌───────┐
│ b │─────────────────>│ 'Abc' │
└───┘                  └───────┘

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

小结

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

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

补充内容
要理解 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 的哈希值相同(鸽笼原理)，这种情况叫“冲突”，设计哈希表的时候要采取办法减少冲突，实在冲突了也要想办法补救。不过这是编译器的事情，况且对于初学者的我们来说碰到的冲突的概率基本等于零，就不用操心了。 ↩︎

昵称

邮箱

网址

按正序
按倒序
按热度

dict 和 set

dict

set

不可变对象

小结

预览: