本文Python版本为3.7.X，阅读本文之前需了解python字典的基本用法。

介绍

字典（dict）是Python中内置的一个数据结构，由多个键值对组成，键（key）和值（value)用冒号分隔，每个键值对之间用逗号（，）分隔，整个字典包括在大括号中（{})，键必须是唯一的，值可以取任何类型，但是键必须是不可变类型，如字符串，数字或元组。

推荐：《python教程》

底层使用了hash表来关联key和value,dict是无序的。特点包括：

● 查找和插入的速度极快，不会随着key的增加而变慢；

● 需要占用的内存较多

所以，dict是一种以空间换取时间的数据结构，应用于需要快速查找的场景。

操作：常用方法

get()

返回指定键的值，如果key不存在，则返回默认值（默认为None），而不会报错，语法为dict.get(key)。

dict_1['age'] = 24In [7]: print(dict_1.get('age'))24In [11]: print(dict_1.get('nama'))NoneIn [12]: print(dict_1['nama'])---------------------------------------------------------------------------KeyError                                  Traceback (most recent call last)<ipython-input-12-ef61a380920e> in <module>----> 1 print(dict_1['nama'])KeyError: 'nama'

key in dict

使用in操作符来判断键是否存在于字典中，存在则返回True，否则返回False，语法为：key in dict。

In [15]: dict_1Out[15]: {'name': None, 'age': 24, 'sex': None}In [16]: print('name' in dict_1)TrueIn [17]: print('nama' in dict_1)False

在python 2中该功能使用has_key()方法实现。

items()

以列表形式返回可遍历的（键， 值）元组数组，语法为dict.items()。

In [18]: dict_1Out[18]: {'name': None, 'age': 24, 'sex': None}In [19]: print(dict_1.items())dict_items([('name', None), ('age', 24), ('sex', None)])In [20]: for key, value in dict_1.items():    ...:     print(key, value)    ...:name Noneage 24sex None

keys()

以列表返回一个字典的所有键：dict.keys()

In [21]: dict_1Out[21]: {'name': None, 'age': 24, 'sex': None}In [22]: print(dict_1.keys())dict_keys(['name', 'age', 'sex'])

values()

以列表形式返回字典中的所有值：dict.values()

In [27]: dict_1Out[27]: {'name': None, 'age': 24, 'sex': None, 'sub_name': 'Tony'}In [28]: print(dict_1.values())dict_values([None, 24, None, 'Tony'])setdefault()和get()类似，用户获得与给顶尖相关联的值，不同的是，该方法如果键不存在时会添加键并将值设为默认值，语法为：dict.setdefault(key, default=None)。In [23]: dict_1Out[23]: {'name': None, 'age': 24, 'sex': None}In [24]: print(dict_1.setdefault('name'))NoneIn [25]: print(dict_1.setdefault('name', 'Tony'))NoneIn [26]: print(dict_1.setdefault('sub_name', 'Tony'))TonyIn [27]: dict_1Out[27]: {'name': None, 'age': 24, 'sex': None, 'sub_name': 'Tony'}

update()

语法为：dict_1.update(dict_2)，用于把dict_2的键值对更新到dict_1中，如果有相同的键会被覆盖。

In [31]: dict_1Out[31]: {'name': None, 'age': 24, 'sex': None, 'sub_name': 'Tony'}In [32]: dict_2Out[32]: {'name': 'Mary', 'age': 18, 'sex': None, 'sub_name': ''}In [33]: dict_1.update(dict_2)In [34]: dict_1Out[34]: {'name': 'Mary', 'age': 18, 'sex': None, 'sub_name': ''}

clear()

删除字典中的所有项，dict.clear()，举个例子：

In [1]: dict_1 = dict(name="Tony", age=24)In [2]: dict_2 = dict_1In [3]: print(dict_2){'name': 'Tony', 'age': 24}In [4]: dict_2.clear()In [5]: dict_2Out[5]: {}In [6]: dict_1Out[6]: {}

copy()

浅拷贝原始字典，返回一个具有相同键值对的新字典，dict.copy()，举个例子：

In [1]: dict_1 = dict(name='Tony', info=['boy', 24])In [2]: dict_3 = dict_1.copy()In [3]: dict_3['name'] = "Ring"In [4]: dict_3['info'].remove('boy')In [5]: dict_3Out[5]: {'name': 'Ring', 'info': [24]}In [6]: dict_1Out[6]: {'name': 'Tony', 'info': [24]}

fromkeys()

创建一个新字典，dict.fromkeys(seq[, value])，以序列seq中的元素做字典的键，value为字典所有键对应的初始值，其中value为可选参数， 默认为None。适用于数据初始化，举个例子：

In [1]: info = ['name', 'age', 'sex']In [2]: dict_1 = dict.fromkeys(info)In [3]: dict_1Out[3]: {'name': None, 'age': None, 'sex': None}

常见操作

合并字典

有四种方式：

常规处理

In [15]: dict_1Out[15]: {'Tony': 24}In [16]: dict_2Out[16]: {'ben': 18}In [17]: dict3 = dict()In [18]: for key, value in dict_1.items():    ...:     dict_3[key] = value    ...:In [19]: for key, value in dict_2.items():    ...:     dict_3[key] = value    ...:In [20]: dict_3Out[20]: {'Tony': 24, 'ben': 18}

update()

In [9]: dict_1Out[9]: {'Tony': 24}In [10]: dict_2Out[10]: {'ben': 18}In [12]: dict_3 = dict_1.copy()In [13]: dict_3.update(dict_2)In [14]: dict_3Out[14]: {'Tony': 24, 'ben': 18}

借助字典的dict(d1, **d2)方法

In [33]: dict_1Out[33]: {'Tony': 24}In [34]: dict_2Out[34]: {'ben': 18}In [35]: dict_3 = dict(dict_1, **dict_2)In [36]: dict_3Out[36]: {'Tony': 24, 'ben': 18}

进阶

字典推导式

和列表推导式类似，优点是底层用C实现，会快很多，推荐使用。

对换字典的键值

使用字典推导式可以轻松对换一个字典的键值：

In [42]: dict_4Out[42]: {24: 'Tony', 18: 'ben'}In [43]: dict_3Out[43]: {'Tony': 24, 'ben': 18}In [44]: dict_4 = {k:v for v, k in dict_3.items()}In [45]: dict_4Out[45]: {24: 'Tony', 18: 'ben'}

从字典中提取子集

想创建一个字典，其本身是另一个字典的子集。

举个例子：

In [88]: a = {'Ben': 18, 'Jack': 12, 'Ring': 23, 'Tony': 24}In [89]: b = {k:v for k, v in a.items() if v > 18}In [90]: bOut[90]: {'Ring': 23, 'Tony': 24}

生成有序字典

在Python3.6之前的字典是无序的，但是有时候我们需要保持字典的有序性，orderDict可以在dict的基础上实现字典的有序性，这里的有序指的是按照字典key插入的顺序来排列，这样就实现了一个先进先出的dict，当容量超出限制时，先删除最早添加的key。

举例：

In [49]: from collections import OrderedDictIn [50]: ordered_dict = OrderedDict([('a', 2), ('b', 4), ('c', 5)])In [51]: for key, value in ordered_dict.items():    ...:     print(key, value)    ...:a 2b 4c 5

可以看到OrderedDict是按照字典创建时的插入顺序来排序。

原理：OrderedDict内部维护了一个双向链表，它会根据元素加入的顺序来排列键的位置，这也就导致OrderedDict的大小是普通字典的2倍多。

合并列表中key相同的字典

也就是生成所谓的一键多值字典，需要将对应的多个值保存在其它容器比如列表或集合，取决于多值是否需要保证唯一性。

举个例子：

In [64]: from collections import defaultdictIn [65]: a = [{'a': 1}, {'b': 3}, {'c': 4}, {'a':5}, {'b':2}, {'b': 4}]In [66]: b = defaultdict(list)In [67]: [b[k].append(v) for item in a for k, v in item.items()]Out[67]: [None, None, None, None, None, None]In [68]: bOut[68]: defaultdict(list, {'a': [1, 5], 'b': [3, 2, 4], 'c': [4]})In [69]: b['a']Out[69]: [1, 5]

寻找两个字典的异同

场景：寻找两个字典中的异同，包括相同的键或者相同的值。

分析：字典是一系列键值之间的映射集合，有以下特点：

keys()会返回字典中的所有键，并且字典的键是支持集合操作的，所以利用集合的交叉并补即可对字典的键进行处理；

items()返回(key, value)组成的对象，支持集合操作；

values()并不支持集合操作，因为并不能保证所有的值是唯一的，但是如果必须要判断操作，可以先将值转化为集合来实现。

举例：

In [78]: a = {'a':1, 'b':2, 'c':3}In [79]: b = {'b':3, 'c':3, 'd':4}In [80]: a.keys() & b.keys()Out[80]: {'b', 'c'}In [81]: a.keys() - b.keys()Out[81]: {'a'}In [82]: a.items() & b.items()Out[82]: {('c', 3)}

再举一个例子，在创建一个字典时，期望可以去除某些键：

In [85]: aOut[85]: {'a': 1, 'b': 2, 'c': 3}In [86]: c = {k: a[key] for k in a.keys() - {'b'}}In [87]: cOut[87]: {'a': 3, 'c': 3}

本文来自 python教程 栏目，欢迎学习！

以上就是Python字典中你必须知道的用法的详细内容，更多请关注24课堂在线网其它相关文章！