第3章：字典和集合-扩展：dict 从无序到有序

在 Python 3.5（含）以前，字典是不能保证顺序的，键值对 A 先插入字典，键值对 B 后插入字典，但是当你打印字典的 keys 列表时，你会发现 B 可能在 A 的前面。

但是从 Python 3.6 开始，字典是变成有顺序的了。你先插入键值对 A，后插入键值对 B，那么当你打印 keys 列表的时候，你就会发现 B在 A 的后面。

不仅如此，从 Python3.6 开始，下面的三种遍历操作，效率要高于 Python 3.5 之前：

for key in my_dict
for value in my_dict.values()
for key, value in my_dict.items()

从Python 3.6开始，字典占用内存空间的大小，视字典里面键值对的个数，只有原来的30%~95%。

Python 3.6到底对字典做了什么优化呢？为了说明这个问题，我们需要先来说一说，在 Python3.5（含）之前，字典的底层原理。

Python3.5 及之前版本的 dict 底层原理： 

当我们初始化一个空字典的时候，CPython的底层会初始化一个二维数组，如下面的示意图所示：

my_dict = {}

'''
此时的内存示意图：

[[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---]]
'''

现在，我们往字典里面添加一个数据：

my_dict['name'] = 'kingname'

'''
插入数据后的内存示意图：

[[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[1278649844881305901, 指向'name'的指针, 指向'kingname'的指针],
[---, ---, ---],
[---, ---, ---]]
'''

这里解释一下，为什么添加了一个键值对以后，内存变成了这个样子：

1. 首先我们 Python 会调用 hash 函数，计算 name 这个字符串在“当前运行时”的 hash 值：

   >>> hash('name')
   1278649844881305901
   

   特别注意，这里强调了『当前运行时』，这是因为，Python自带的这个 hash 函数，和我们传统上认为的 Hash 函数是不一样的。Python自带的这个 hash 函数计算出来的值，只能保证在每一个运行时的时候不变，但是当你关闭 Python 再重新打开，那么它的值就可能会改变；
2. 假设在某一个运行时里面，hash(‘name’) 的值为 1278649844881305901。现在我们要把这个数对 8 取余数：

   >>> 1278649844881305901 % 8
   5
   

   余数为 5，那么就把这个键值对放在刚刚初始化的二维数组中，下标为 5 的这一行。由于 name 和 kingname 是两个字符串，所以底层 C 语言会使用两个字符串变量存放这两个值，然后得到他们对应的指针。于是，这个二维数组下标为 5 的这一行，第一个值为 name 的 hash 值，第二个值为 name 这个字符串所在的内存的地址（指针就是内存地址），第三个值为 kingname 这个字符串所在的内存的地址。

现在，我们再来插入两个键值对：

my_dict['age'] = 26
my_dict['salary'] = 999999

'''
插入数据后的内存示意图：

[[-4234469173262486640, 指向'salary'的指针, 指向 999999 的指针],
[1545085610920597121, 指向'age'的指针, 指向 26 的指针],
[---, ---, ---],
[---, ---, ---],
[---, ---, ---],
[1278649844881305901, 指向'name'的指针, 指向'kingname'的指针],
[---, ---, ---],
[---, ---, ---]]
'''

那么字典怎么读取数据呢？首先假设我们要读取 age 对应的值：

1. Python 先调用 hash(age) 计算 age 的 hash 值；
2. 再用这个 hash 值对 8 取余数；
3. 得到的余数就是 age 键值对在二维数组中的下标，然后根据下标取得 age 对应在内存中的值；

从上得知，dict 插入键值对，是通过 key 的哈希值取余来确定插入顺序的，余数有大有小，不可控制，所以字典是无序的；

注意事项：

1. 开放寻址，当两个不同的 key，经过 Hash 以后，再对 8 取余数，可能余数会相同。此时 Python 为了不覆盖之前已有的值，就会使用开放寻址技术重新寻找一个新的位置存放这个新的键值对。
2. 当字典的键值对数量超过当前数组长度的 2/3 时，数组会进行扩容，8 行变成 16 行，16 行变成 32 行。长度变了以后，原来的余数位置也会发生变化，此时就需要移动原来位置的数据，导致插入效率变低。

Python3.6 以后 dict 的底层原理：

在 Python 3.6 以后，字典的底层数据结构发生了变化，现在当你初始化一个空的字典以后，它在底层是这样的：

my_dict = {}

'''
此时的内存示意图：

indices = [None, None, None, None, None, None, None, None]
entries = []
'''

当你初始化一个字典以后，Python 单独生成了一个长度为 8 的一维数组。然后又生成了一个空的二维数组。

现在，我们往字典里面添加一个键值对：

my_dict['name'] = 'kingname'

'''
此时的内存示意图：

indices = [None, 0, None, None, None, None, None, None]
entries = [[-5954193068542476671, 指向'name'的指针, 执行'kingname'的指针]]
'''

为什么内存会变成这个样子呢？我们来一步一步地看：

1. 在当前运行时，name 这个字符串的 hash 值为 -5954193068542476671，这个值对 8 取余数是 1；
2. Python 把 indices 这个一维数组里面，下标为 1 的位置修改为 0，0 代表 name 对应的 item 在 entries 二维数组中的下标；

现在我们再来插入两条数据：

my_dict['address'] = 'xxx'
my_dict['salary'] = 999999

'''
此时的内存示意图：

indices = [1, 0, None, None, None, None, 2, None]
entries = [[-5954193068542476671, 指向'name'的指针, 执行'kingname'的指针],
          [9043074951938101872, 指向'address'的指针，指向'xxx'的指针],
          [7324055671294268046, 指向'salary'的指针, 指向 999999 的指针]
         ]
'''

现在如果我要读取数据怎么办呢？假如我要读取 salary 的值:

1. Python 先调用 hash(age) 计算 age 的 hash 值；
2. 再用这个 hash 值对 8 取余数为 6；
3. 在 indices 一维数组中获取下标为 6 的值，这个值为 2；
4. 在 entries 二维数组中获取下标为 2 的值，这个值就是 salary 对应的数据，最后返回 salary 的值；

在新的版本中，当插入新的数据的时候，始终只是往 entries 的后面添加数据，这样就能保证插入的顺序。当我们要遍历字典的 keys 和 values 的时候，直接遍历 entries 即可，里面每一行都是有用的数据，不存在跳过的情况，减少了遍历的个数。