老Python总结的字典相关知识

字典

Python中的字典（dict）也被称为映射（mapping）或者散列（hash），是支持Python底层实现的重要数据结构。

同时，也是应用最为广泛的数据结构，内部采用hash存储，存储方式为键值对，需要注意的是键（key）必须为不可变类型，而值（value）可以是任意类型。

字典本身属于可变容器类型，其中一组键值对被视为容器中的一组数据项。

字典的优点是单点查找速度极快，而不能够支持范围查找，此外也比较占用内存。

基本声明

以下是使用类的形式进行声明：

userInfo = dict(name="YunYa", age=18, hobby=["football, music"])
print("值:%r,类型：%r" % (userInfo, type(userInfo)))
# 值:{'name': 'YunYa', 'age': 18, 'hobby': ['football, music']},类型：<class 'dict'>

也可以选择使用更方便的字面量形式，使用{}对键值对进行包裹，键值对采用k:v的形式分割，多个键值对之间使用,进行分割：

userInfo = {"name": "YunYa", "age": 18, "hobby": ["football, music"]}
print("值:%r,类型：%r" % (userInfo, type(userInfo)))
# 值:{'name': 'YunYa', 'age': 18, 'hobby': ['football, music']},类型：<class 'dict'>

声明dict时，千万注意key只能是不可变类型。

如str，int，float，bool，tuple等等，使用可变类型作为key会抛出异常。

声明速度

字面量形式和实例类的形式声明究竟哪个更快？

实际上字面量形式比实例类的速度大约快3倍。

我们可以使用一个timeit模块，来测出两者的时间差：

$ python -m timeit -n 1000000 -r 5 -v "dict()"
raw times: 0.0865 0.0849 0.0845 0.0962 0.0842
1000000 loops, best of 5: 0.0842 usec per loop
$  python -m timeit -n 1000000 -r 5 -v "{}"
raw times: 0.0273 0.027 0.0278 0.0284 0.0265
1000000 loops, best of 5: 0.0265 usec per loop

① -n 语句执行多少次

② -r 重复计时器的次数，默认为5

为什么会出现这样的情况，可以使用dis模块来探索，该模块会通过反汇编来查看到语句执行情况的字节码。

$ echo "{}" > demo.py
$ python -m dis demo.py
  1           0 BUILD_MAP                0
              3 POP_TOP
              4 LOAD_CONST               0 (None)
              7 RETURN_VALUE
$ echo "dict()" > demo.py
$ python -m dis demo.py
  1           0 LOAD_NAME                0 (dict)
              3 CALL_FUNCTION            0
              6 POP_TOP
              7 LOAD_CONST               0 (None)
             10 RETURN_VALUE

可以查看到，使用dict()形式进行声明时，必定会调用函数、调用函数的过程会发起系统调用栈的进出栈操作，故更加耗时。

不仅仅是字典的声明、包括所有内置数据结构的声明都推荐使用字面量形式。

如下所示，列表也有相同的情况发生，其他内置的数据结构不再进行演示：

$ echo "[]" > demo.py
$ python -m dis demo.py
  1           0 BUILD_LIST               0
              3 POP_TOP
              4 LOAD_CONST               0 (None)
              7 RETURN_VALUE
$ echo "list()" > demo.py
$ python -m dis demo.py
  1           0 LOAD_NAME                0 (list)
              3 CALL_FUNCTION            0
              6 POP_TOP
              7 LOAD_CONST               0 (None)
             10 RETURN_VALUE

续行操作

在Python中，字典中的数据项如果过多，可能会导致整个字典太长。

Python虽然提供了续行符\，但是在字典中可以忽略续行符，如下所示：

userInfo = {
    "name": "YunYa",
    "age": 18,
    "hobby": ["football, music"]}
print("值:%r,类型：%r" % (userInfo, type(userInfo)))
# 值:{'name': 'YunYa', 'age': 18, 'hobby': ['football, music']},类型：<class 'dict'>

多维嵌套

字典中可以进行多维嵌套，如字典套字典，字典套元组，字典套列表等：

dic = {
    "k1": [1, 2, 3],
    "k2": (1, 2, 3),
    "k3": {
        "k3-1": 1,
        "k3-2": 2,
    },
}

类型转换

字典可以与布尔类型和字符串进行转换，这是最常用的。

dic = {"k1": "v1", "k2": "v2"}
boolDict = bool(dic)  # 布尔类型
strDict = str(dic)    # 字符串类型
print("值:%r,类型：%r" % (boolDict, type(boolDict)))
print("值:%r,类型：%r" % (strDict, type(strDict)))
# 值:True,类型：<class 'bool'>
# 值:"{'k1': 'v1', 'k2': 'v2'}",类型：<class 'str'>

如果要将字典转换为列表、元组、集合类型，直接转换只会拿到键，并不会拿到值。

尤其注意这一点，但是其实这样用的场景十分少见，记住就行了：

dic = {"k1": "v1", "k2": "v2"}
listDict = list(dic)    # 列表类型
tupleDict = tuple(dic)  # 元组类型
setDict = set(dic)      # 集合类型
print("值:%r,类型：%r" % (listDict, type(listDict)))
print("值:%r,类型：%r" % (tupleDict, type(tupleDict)))
print("值:%r,类型：%r" % (setDict, type(setDict)))
# 值:['k1', 'k2'],类型：<class 'list'>
# 值:('k1', 'k2'),类型：<class 'tuple'>
# 值:{'k2', 'k1'},类型：<class 'set'>

重复key

一个字典中的key必须是唯一的，若不是唯一的则value可能面临被覆盖的危险：

dic = {"name": "云崖", "age": 18, "name": "Yunya"}
print(dic)
# {'name': 'Yunya', 'age': 18}

同理，True和1，False和0也会彼此进行覆盖：

dic = {True: "云崖", "age": 18, 1: "Yunya"}
print(dic)
# {True: 'Yunya', 'age': 18}

如果你对此不了解，建议回退到布尔类型一章节中再次查看True&1andFalse&0之间的关系。

[]操纵字典

由于字典并非顺序存储（下面会简单介绍），故不支持索引操作。

但是字典也提供了[]操作语法，它是根据key来操作value的。

增删改查

以下示例展示了如何使用[]对字典中的value进行操纵：

dic = {"k1": "v1", "k2": "v2"}
# 增
dic["k3"] = "v3"
print(dic)
# {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
# 删，如果没有该key，则抛出keyError
del dic["k2"]
print(dic)
# {'k1': 'v1', 'k3': 'v3'}
# 改，如果没有该key，则抛出keyError
dic["k3"] = "VV3"
print(dic)
# {'k1': 'v1', 'k3': 'VV3'}
# 查，如果没有该key，则抛出keyError
result = dic["k1"]
print(result)
# v1

多维操作

字典套列表的多维操作如下，首先需要拿到该列表：

dic = {"k1": [1, 2, 3, 4]}
# 取出3
result = dic["k1"][2]
print(result)
# 3
# k1的列表，添加元素 "A"
dic["k1"].append("A")
print(dic)
# {'k1': [1, 2, 3, 4, 'A']}

字典套字典的多维操作如下，首先需要拿到被操纵的字典：

dic = {
    "k1":{
        "k1-1":{
            "k1-2":{
                "k1-3":"HELLO,WORLD",
            }
        }
    }
}
# 拿到 k1-3 对应的value
result = dic["k1"]["k1-1"]["k1-2"]["k1-3"]
print(result)
# HELLO,WORLD

解构语法

**语法

**语法用于将字典中的k:v全部提取出来。

我们可以利用该语法的特性来对字典进行合并，将两个旧字典合并成一个新字典：

dic_1 = {"d1k1": "A", "d1k2": "B"}
dic_2 = {"d2k1": "C", "d2k2": "D"}
result = {**dic_1, **dic_2}
print(result)
# {'d1k1': 'A', 'd1k2': 'B', 'd2k1': 'C', 'd2k2': 'D'}

解构赋值

字典支持平行变量赋值操作吗？当然可以！但是这样只会拿到字典的key：

dic = {"k1": "v1", "k2": "v2"}
first, last = dic
print(first)
print(last)
# k1
# k2

有办法拿到value么？借助字典的values()方法即可做到，它的本质是将value全部提取出来，组成一个可迭代对象：

dic = {"k1": "v1", "k2": "v2"}
first, last = dic.values()
print(first)
print(last)
# v1
# v2

你可以理解为，将value全部提取出来后转换为一个列表，类似于[“v1”, “v2”]，在Python2中的确是这样，但是到了Python3中做法改变了，目前按下不表。

对于一些不想要的数据项，你也可以按照列表的解构赋值操作来进行，这里不再举例。

常用方法

方法一览

常用的dict方法一览：

方法名	返回值	描述
get()	v or None	取字典key对应的value，如果key不存在返回None
setdefault()	v	获取字典key对应的value，如该字典中不存在被获取的key则会进行新增k:v，并返回v
update()	None	对原有的字典进行更新
pop()	v	删除该字典中的键值对，如果不填入参数key或者key不存在则抛出异常
keys()	Iterable	返回一个可迭代对象，该可迭代对象中只存有字典的所有key
values()	Iterable	返回一个可迭代对象，该可迭代对象中只存有字典的所有value
items()	Iterable	返回一个可迭代对象，该可迭代对象中存有字典中所有的key与value，类似于列表套元组
clear()	None	清空当前字典

基础公用函数：

函数名	返回值	描述
len()	integer	返回容器中的项目数

获取长度

使用len()方法来进行字典长度的获取。

返回int类型的值。

dic = {"name": "云崖", "age": 18}
print(len(dic))
# 2 一组键值对被视为一个数据项，故2组键值对长度为2

Python在对内置的数据类型使用len()方法时，实际上是会直接的从PyVarObject结构体中获取ob_size属性，这是一种非常高效的策略。

PyVarObject是表示内存中长度可变的内置对象的C语言结构体。

直接读取这个值比调用一个方法要快很多。

get()

使用get()方法获取字典key对应的value，相比于[]操作更加的人性化，因为[]一旦获取不存在的key则会抛出异常，而该方法则是返回None。

dic = {"name": "云崖", "age": 18}
username = dic.get("name")
userhobby = dic.get("hobby")
print("用户姓名:",username)
print("用户爱好:",userhobby)
# 用户姓名: 云崖
# 用户爱好: None

setdefault()

使用setdefault()方法来获取字典key对应的value，如该字典中不存在被获取的key则会进行新增k:v，并返回v。

返回字典原有的value或者新设置的k:v。

dic = {"name": "云崖", "age": 18}
# 字典有name，则取字典里的name
username = dic.setdefault("name","云崖先生")   
# 字典没有hobby，则设置hobby的value为足球与篮球并返回
userhobby = dic.setdefault("hobby","足球与篮球")  
print("用户姓名:",username)
print("用户爱好:",userhobby)
# 用户姓名: 云崖
# 用户爱好: 足球与篮球

update()

使用update()方法对原有的字典进行更新。

返回None。

dic = {"name": "云崖", "age": 18}
dic.update(
    {"hobby": ["篮球", "足球"]}
)
print(dic)
# {'name': '云崖', 'age': 18, 'hobby': ['篮球', '足球']}

pop()

使用pop()方法删除该字典中的键值对，如果不填入参数key或者key不存在则抛出异常。

返回被删除的value。

dic = {"name": "云崖", "age": 18}
result = dic.pop("age")
print(result)
print(dic)
# 18
# {'name': '云崖'}

keys()

返回一个可迭代对象，该可迭代对象中只存有字典的所有key。

Python2中返回的是列表，Python3中返回的是可迭代对象。

dic = {"name": "云崖", "age": 18}
key_iter = dic.keys()
print(key_iter)
# dict_keys(['name', 'age'])

values()

返回一个可迭代对象，该可迭代对象中只存有字典的所有value。

Python2中返回的是列表，Python3中返回的是可迭代对象。

dic = {"name": "云崖", "age": 18}
value_iter = dic.values()
print(value_iter)
# dict_values(['云崖', 18])

items()

返回一个可迭代对象，该可迭代对象中存有字典中所有的key与value，类似于列表套元组。

Python2中返回的是二维列表，Python3中返回的是可迭代对象。

dic = {"name": "云崖", "age": 18}
items_iter = dic.items()
print(items_iter)
# dict_items([('name', '云崖'), ('age', 18)])

clear()

清空当前字典。

返回None。

dic = {"name": "云崖", "age": 18}
dic.clear()
print(dic)
# {}

其他方法

方法	返回值	描述
popitem()	(k, v)	随机删除一组键值对,并将删除的键值放到元组内返回
fromkeys(iter,value)	dict	第一个参数是可迭代对象，其中每一个元素都为新生成字典的key，第二个参数为同一的value值

示例演示：

dic1 = dict(k1="v1", k2="v2", k3="v3", k4="v4")
print(dic1.popitem())
# ('k4', 'v4') 
dic2 = dict.fromkeys([1, 2, 3, 4], None)
print(dic2)
# {1: None, 2: None, 3: None, 4: None}

原理浅析

高效查找

为什么要有字典这种数据结构？

如果对一个无序的列表查找其中某一个value（不能进行排序），必须经过一个一个的遍历，速度会很慢。

[3, 2, 8, 9, 11, 13]
# 如果要获取数据项11，必须经过5次查找

有没有一种办法，能够让速度加快？

为了不违背不能排序的前提，我们只能在列表存入value的时候做文章。

我们可以每个value都造一个独一无二的身份标识，根据这个身份标识符计算出value需要插入到列表的索引位置。

在取的时候同理，通过身份标识符直接就可以拿到value所在列表的索引值，无疑速度会快很多。

一个小总结：

• 有一个身份标识，身份标识必须是唯一的
• 提供一个根据身份标识计算出插入位置的算法

回到字典的本质，字典的key就是value的身份标识，而根据key计算出插入位置的算法被封装在了hash()函数中，这个算法也被称之为hash算法。

为什么key必须是唯一的，参照下面这个示例：

["k1", "k2", "k3", "k4", "k5", "k6"]
[  3,    2,    8,    9,   11,   13]

• 假如k5变成了k6，那么就有2个k6对应2个不同的value
• 这么做的后果就是，使用k6获取value的时候，根本不知道你需要的value是哪一个

所以，干脆Python规定，key必须是不可变类型！如果有重复则新的覆盖旧的。

hash()过程

如何通过hash()函数，确定value的插入位置？

实际上每个键值对在存入字典之前，都会通过hash()函数对key计算出一个hash值（也被称为散列值）：

>>> hash("k1")
7036545863130266253

而字典的底层结构是由一个2维数组嵌套组成的，也被称为散列表、hash表。

如下所示，每次创建字典的时候，字典都会初始化生成一个固定长度且内容全是空的2维数组，Python内部生成的散列表长度为8（可参见PyDictObject结构体源码）：

[
	 ①  ②  ③
	[空, 空, 空], index: 0
	[空, 空, 空], index: 1
	[空, 空, 空], index: 2
	[空, 空, 空], index: 3
	[空, 空, 空], index: 4
	[空, 空, 空], index: 5
	[空, 空, 空], index: 6
	[空, 空, 空]  index: 7
]

①：存放根据key计算出的hash值

②：存放key的引用

③：存放value的引用

现在，我们要存储name:yunya的键值对，对name计算hash值：

>>> hash("name")
3181345887314224636

用计算出的hash值与散列表长度进行求余运算：

>>> 3181345887314224636 % 8
4

得到结果是4，就在散列表4的索引位置插入：

[
	 ①  ②  ③
	[空, 空, 空], index: 0
	[空, 空, 空], index: 1
	[空, 空, 空], index: 2
	[空, 空, 空], index: 3
	[3181345887314224636, "name"的引用, "yunya"], index: 4
	[空, 空, 空], index: 5
	[空, 空, 空], index: 6
	[空, 空, 空]  index: 7
]

再次插入age:18，并用计算出的hash值与散列表长度进行求余运算:

>>> hash("age")
7064862892218627464
>>> 7064862892218627464 % 8
0

得到的结果是0，就在散列表0的索引位置插入：

[
	 ①  ②  ③
	[7064862892218627464, "age"的引用, 18], index: 0
	[空, 空, 空], index: 1
	[空, 空, 空], index: 2
	[空, 空, 空], index: 3
	[3181345887314224636, "name"的引用, "yunya"], index: 4
	[空, 空, 空], index: 5
	[空, 空, 空], index: 6
	[空, 空, 空]  index: 7
]

可以看见，这个2维数组不是按照顺序进行插入的，总有一些空的位置存在，该数组也被称为稀松数组。

由于数组是稀松的，所以dict不支持范围获取（能获取到空值），但单点存取的速度很快。

读取的时候也同理，但是Python的hash函数底层实现是否真的利用hash值对稀松数组长度进行简单的求余运算，这个还有待商榷。

因为hash算法的实现有很多种，长度求余只是最为简单的一种而已，这里用作举例，如果想具体了解其算法可以查看Python源码，PyDictObject.c中的perturb。

散列冲突

现在，我们的这个散列表中0和4的索引位置都已经存在数据了。

如果现在存入一个teacher:wang，那么结果会是怎么样？

>>> hash("teacher")
4789346189807557228
>>> 4789346189807557228 % 8
4

可以发现，teacher的hash值求余算结果也是4，这个时候就会发生散列冲突。

最常见的做法是，向后挪！因为索引5的位置是空的，我们可以将这个键值对插入到索引5的位置：

[
	 ①  ②  ③
	[7064862892218627464, "age"的引用, 18], index: 0
	[空, 空, 空], index: 1
	[空, 空, 空], index: 2
	[空, 空, 空], index: 3
	[3181345887314224636, "name"的引用, "yunya"], index: 4
	[4789346189807557228, "teacher"的引用, "wang"], index: 5
	[空, 空, 空], index: 6
	[空, 空, 空]  index: 7
]

这种查找空位的方法叫做开放定址法（openaddressing），向后查找也被称为线性探测（linearprobing）。

如果此时又插入一个数据项，最后key的插入索引位置也是4，则继续向后查找空位，如果查找到7还是没有空位，又从0开始找。

上述方法是解决散列冲突的基础方案，当然也还有更多的其他解决方案，这里再说就过头了，放在后面数构一章中再进行介绍吧。

扩容机制

Python的dict会对散列表的容量做出判定。

当容量超过三分之二时，即进行扩容（resize）机制。

如果散列表大小为8，在即将插入第3个键值对时进行扩容，扩容策略为已有散列表键值对个数 * 2。

即散列表大小扩展为12。

如果整个散列表已有键值对个数达到了50000，则扩容策略为已有散列表键值对个数 * 4。

此外，dict只会进行扩容，不会进行缩容，如果删除了1个键值对，其内存空间占用的位置并不会释放。

不同的key优化策略

整形是其本身

整形的hash值是其本身：

>>> hash(1)
1
>>> hash(2)
2
>>> hash(3)
3
>>> hash(10000)
10000

加盐策略

在Python3.3开始，str、bytes、datetime等对象在计算散列值的时候会进行加盐处理。

这个盐引用内部的一个常量，该常量在每次CPython启动时会生成不同的盐值。

所以你会发现每次重启Python3.3以后的解释器，对相同字符串进行hash()求散列值得出的结果总是不一样的：

$ python3
Python 3.6.8 (v3.6.8:3c6b436a57, Dec 24 2018, 02:04:31)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> hash("k1")
8214688532022610754
>>> exit()
$ python3
Python 3.6.8 (v3.6.8:3c6b436a57, Dec 24 2018, 02:04:31)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> hash("k1")
-7444020267993088839
>>> exit()

再看Python2.7，由于没有加盐策略，所以每次重启得到的hash结果是相同的：

$ python
Python 2.7.10 (default, Feb 22 2019, 21:55:15)
[GCC 4.2.1 Compatible Apple LLVM 10.0.1 (clang-1001.0.37.14)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> hash("k1")
13696082283123634
>>> exit()
$ python
Python 2.7.10 (default, Feb 22 2019, 21:55:15)
[GCC 4.2.1 Compatible Apple LLVM 10.0.1 (clang-1001.0.37.14)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> hash("k1")
13696082283123634
>>> exit()

有序字典

字典无序的观念似乎已经深入人心，但那已经都是过去式了。

在Python3.6之后，字典变的有序了。

2012年12月10日星期一的时候，R. David Murray向Python官方发送了一封邮件，提出建议让Python的字典变的有序。

这样的做法能够让Python字典的空间占用量更小，迭代速度更快，以下是邮件内容：

https://mail.python.org/pipermail/python-dev/2012-December/123028.html

我们先看看2.7中的字典：

>>> {chr(i) : i for i in range(10)}
{'\x01': 1, '\x00': 0, '\x03': 3, '\x02': 2, '\x05': 5, '\x04': 4, '\x07': 7, '\x06': 6, '\t': 9, '\x08': 8}

再来看3.6中的字典：

>>> {chr(i) : i for i in range(10)}
{'\x00': 0, '\x01': 1, '\x02': 2, '\x03': 3, '\x04': 4, '\x05': 5, '\x06': 6, '\x07': 7, '\x08': 8, '\t': 9}

果然！它确实变的有序了，关于具体细节，可以参照这封邮件，已经表述的很清楚了，下面做一个简单的示例。

首先，以前的散列表就是一个单纯的稀松二维数组：

[
	[空, 空, 空], index: 0
	[空, 空, 空], index: 1
	[空, 空, 空], index: 2
	...
]

键值对的读取顺序来源与填加顺序。

索引靠前的会被先遍历拿到，索引靠后只能后被遍历出来。

如果这个散列表长度为8，前7个都没有数据项存入，仅有8才有，那么遍历完整个散列表需要8次：

[
	[空, 空, 空], index: 0
	[空, 空, 空], index: 1
	[空, 空, 空], index: 2
	...
	[hash值, key的引用, value的引用], index: 7
]

而Python3.6之后，又新增了一个顺序数组，该数组与散列表的长度相等，初始均为8，并且会跟随散列表的扩容而进行扩容，如下示例初始状态：

[None, None, None, ...]
[
	[空, 空, 空], index: 0
	[空, 空, 空], index: 1
	[空, 空, 空], index: 2
	...
]

如果说第1个键值对，被插入到散列表索引1的位置，那么在顺序数组中，则在索引0处记录下该键值对被插入在散列表中的位置(1)，如下图所示：

[1, None, None, ...]
[
	[空, 空, 空], index: 0
	[hash值, key的引用, value的引用], index: 1
	[空, 空, 空], index: 2
	...
]

如果第2个键值对，被插入到散列表索引0的位置，那么在顺序数组中，则在索引1处记录下该键值对被插入在散列表中的位置(0)，如下图所示：

[1, 0, None, ...]
[
	[hash值, key的引用, value的引用], index: 0
	[hash值, key的引用, value的引用], index: 1
	[空, 空, 空], index: 2
	...
]

在遍历的时候，会遍历这个顺序数组，然后通过索引值拿到散列表中对应位置的数据项，如果遍历到的值为None就结束遍历，而不用遍历完整个散列表：

[1, 0, 7, None, None, None, None, None]
[
	[hash值, key的引用, value的引用], index: 0
	[hash值, key的引用, value的引用], index: 1
	[空, 空, 空], index: 2
	...
	[hash值, key的引用, value的引用], index: 7
]

类似于：

hashTableOrderArray = [1, 0, 7, None, None, None, None, None]
hashTable = [
    ["hash", "k2", "v2"],
    ["hash", "k1", "v1"],
    [None, None, None],
    [None, None, None],
    [None, None, None],
    [None, None, None],
    [None, None, None],
    ["hash", "k3", "v3"],
]
n = 0
while n < len(hashTable):
    if hashTableOrderArray[n] is not None:
        print(hashTable[hashTableOrderArray[n]])
    else:
        break
    n += 1

这样只需遍历3次即可，而如果不用这个顺序数组，则要完整遍历整个散列表，即8次才能拿出所有的键值对。

字典特性

字典特性如下：

• 字典是一个可变的容器类型
• 字典内部由散列表组成
• 字典的单点读写速度很快，但是不支持范围查找
• 字典的key必须是不可变的
• 字典在3.6之后变得有序了，这样做提升了遍历效率

参考文章：PyDictObject实现