本文共 13786 字，大约阅读时间需要 45 分钟。
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']},类型： 也可以选择使用更方便的字面量形式，使用{}对键值对进行包裹，键值对采用k:v的形式分割，多个键值对之间使用,进行分割：
userInfo = {"name": "YunYa", "age": 18, "hobby": ["football, music"]}print("值:%r,类型：%r" % (userInfo, type(userInfo)))# 值:{'name': 'YunYa', 'age': 18, 'hobby': ['football, music']},类型： 声明dict时，千万注意key只能是不可变类型。
如str，int，float，bool，tuple等等，使用可变类型作为key会抛出异常。
字面量形式和实例类的形式声明究竟哪个更快？
实际上字面量形式比实例类的速度大约快3倍。
我们可以使用一个模块，来测出两者的时间差：
$ python -m timeit -n 1000000 -r 5 -v "dict()"raw times: 0.0865 0.0849 0.0845 0.0962 0.08421000000 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.02651000000 loops, best of 5: 0.0265 usec per loop ① -n 语句执行多少次
② -r 重复计时器的次数，默认为5
为什么会出现这样的情况，可以使用模块来探索，该模块会通过反汇编来查看到语句执行情况的字节码。
$ 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']},类型： 字典中可以进行多维嵌套，如字典套字典，字典套元组，字典套列表等：
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,类型： # 值:"{'k1': 'v1', 'k2': 'v2'}",类型： 如果要将字典转换为列表、元组、集合类型，直接转换只会拿到键，并不会拿到值。
尤其注意这一点，但是其实这样用的场景十分少见，记住就行了：
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'],类型： # 值:('k1', 'k2'),类型： # 值:{'k2', 'k1'},类型： 一个字典中的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，则抛出keyErrordel dic["k2"]print(dic)# {'k1': 'v1', 'k3': 'v3'}# 改，如果没有该key，则抛出keyErrordic["k3"] = "VV3"print(dic)# {'k1': 'v1', 'k3': 'VV3'}# 查，如果没有该key，则抛出keyErrorresult = dic["k1"]print(result)# v1 字典套列表的多维操作如下，首先需要拿到该列表：
dic = {"k1": [1, 2, 3, 4]}# 取出3result = 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 对应的valueresult = 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 = dicprint(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()方法获取字典key对应的value，相比于[]操作更加的人性化，因为[]一旦获取不存在的key则会抛出异常，而该方法则是返回None。
dic = {"name": "云崖", "age": 18}username = dic.get("name")userhobby = dic.get("hobby")print("用户姓名:",username)print("用户爱好:",userhobby)# 用户姓名: 云崖# 用户爱好: None 使用setdefault()方法来获取字典key对应的value，如该字典中不存在被获取的key则会进行新增k:v，并返回v。
返回字典原有的value或者新设置的k:v。
dic = {"name": "云崖", "age": 18}# 字典有name，则取字典里的nameusername = dic.setdefault("name","云崖先生") # 字典没有hobby，则设置hobby的value为足球与篮球并返回userhobby = dic.setdefault("hobby","足球与篮球") print("用户姓名:",username)print("用户爱好:",userhobby)# 用户姓名: 云崖# 用户爱好: 足球与篮球 使用update()方法对原有的字典进行更新。
返回None。
dic = {"name": "云崖", "age": 18}dic.update( {"hobby": ["篮球", "足球"]})print(dic)# {'name': '云崖', 'age': 18, 'hobby': ['篮球', '足球']} 使用pop()方法删除该字典中的键值对，如果不填入参数key或者key不存在则抛出异常。
返回被删除的value。
dic = {"name": "云崖", "age": 18}result = dic.pop("age")print(result)print(dic)# 18# {'name': '云崖'} 返回一个可迭代对象，该可迭代对象中只存有字典的所有key。
Python2中返回的是列表，Python3中返回的是可迭代对象。
dic = {"name": "云崖", "age": 18}key_iter = dic.keys()print(key_iter)# dict_keys(['name', 'age']) 返回一个可迭代对象，该可迭代对象中只存有字典的所有value。
Python2中返回的是列表，Python3中返回的是可迭代对象。
dic = {"name": "云崖", "age": 18}value_iter = dic.values()print(value_iter)# dict_values(['云崖', 18]) 返回一个可迭代对象，该可迭代对象中存有字典中所有的key与value，类似于列表套元组。
Python2中返回的是二维列表，Python3中返回的是可迭代对象。
dic = {"name": "云崖", "age": 18}items_iter = dic.items()print(items_iter)# dict_items([('name', '云崖'), ('age', 18)]) 清空当前字典。
返回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]
所以，干脆Python规定，key必须是不可变类型！如果有重复则新的覆盖旧的。
如何通过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 % 84
得到结果是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 % 80 得到的结果是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源码，中的perturb。
现在，我们的这个散列表中0和4的索引位置都已经存在数据了。
如果现在存入一个teacher:wang，那么结果会是怎么样？
>>> hash("teacher")4789346189807557228>>> 4789346189807557228 % 84 可以发现，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个键值对，其内存空间占用的位置并不会释放。
整形的hash值是其本身：
>>> hash(1)1>>> hash(2)2>>> hash(3)3>>> hash(10000)10000
在Python3.3开始，str、bytes、datetime等对象在计算散列值的时候会进行加盐处理。
这个盐引用内部的一个常量，该常量在每次CPython启动时会生成不同的盐值。
所以你会发现每次重启Python3.3以后的解释器，对相同字符串进行hash()求散列值得出的结果总是不一样的：
$ python3Python 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 darwinType "help", "copyright", "credits" or "license" for more information.>>> hash("k1")8214688532022610754>>> exit()$ python3Python 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 darwinType "help", "copyright", "credits" or "license" for more information.>>> hash("k1")-7444020267993088839>>> exit() 再看Python2.7，由于没有加盐策略，所以每次重启得到的hash结果是相同的：
$ pythonPython 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 darwinType "help", "copyright", "credits" or "license" for more information.>>> hash("k1")13696082283123634>>> exit()$ pythonPython 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 darwinType "help", "copyright", "credits" or "license" for more information.>>> hash("k1")13696082283123634>>> exit() 字典无序的观念似乎已经深入人心，但那已经都是过去式了。
在Python3.6之后，字典变的有序了。
2012年12月10日星期一的时候，R. David Murray向Python官方发送了一封邮件，提出建议让Python的字典变的有序。
这样的做法能够让Python字典的空间占用量更小，迭代速度更快，以下是邮件内容：
我们先看看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 = 0while n < len(hashTable): if hashTableOrderArray[n] is not None: print(hashTable[hashTableOrderArray[n]]) else: break n += 1
这样只需遍历3次即可，而如果不用这个顺序数组，则要完整遍历整个散列表，即8次才能拿出所有的键值对。
字典特性如下：
参考文章：
转载地址：http://owikz.baihongyu.com/