Python字典你必須知道的用法系列

本文Python版本為3.7.X，閱讀本文之前需瞭解python字典的基本用法。

介紹

字典（dict）是Python中內建的一個數據結構，由多個鍵值對組成，鍵（key）和值（value)用冒號分隔，每個鍵值對之間用逗號（，）分隔，整個字典包括在大括號中（{})，鍵必須是唯一的，值可以取任何型別，但是鍵必須是不可變型別，如字串，數字或元組。

底層使用了hash表來關聯key和value,dict是無序的。特點包括：

查詢和插入的速度極快，不會隨著key的增加而變慢；
需要佔用的記憶體較多

所以，dict是一種以空間換取時間的資料結構，應用於需要快速查詢的場景。

操作

常用方法

get()

返回指定鍵的值，如果key不存在，則返回預設值（預設為None），而不會報錯，語法為dict.get(key)。

dict_1['age'] = 24

In [7]: print(dict_1.get('age'))
24

In [11]: print(dict_1.get('nama'))
None

In [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_1
Out[15]: {'name': None, 'age': 24, 'sex': None}

In [16]: print('name' in dict_1)
True

In [17]: print('nama' in dict_1)
False

在python 2中該功能使用has_key()方法實現。

items()

以列表形式返回可遍歷的（鍵，值）元組陣列，語法為dict.items()。

In [18]: dict_1
Out[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 None
age 24
sex None

keys()

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

In [21]: dict_1
Out[21]: {'name': None, 'age': 24, 'sex': None}

In [22]: print(dict_1.keys())
dict_keys(['name', 'age', 'sex'])

values()

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

In [27]: dict_1
Out[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_1
Out[23]: {'name': None, 'age': 24, 'sex': None}

In [24]: print(dict_1.setdefault('name'))
None

In [25]: print(dict_1.setdefault('name', 'Tony'))
None

In [26]: print(dict_1.setdefault('sub_name', 'Tony'))
Tony

In [27]: dict_1
Out[27]: {'name': None, 'age': 24, 'sex': None, 'sub_name': 'Tony'}

update()

語法為：dict_1.update(dict_2)，用於把dict_2的鍵值對更新到dict_1中，如果有相同的鍵會被覆蓋。

In [31]: dict_1
Out[31]: {'name': None, 'age': 24, 'sex': None, 'sub_name': 'Tony'}

In [32]: dict_2
Out[32]: {'name': 'Mary', 'age': 18, 'sex': None, 'sub_name': ''}

In [33]: dict_1.update(dict_2)

In [34]: dict_1
Out[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_1

In [3]: print(dict_2)
{'name': 'Tony', 'age': 24}

In [4]: dict_2.clear()

In [5]: dict_2
Out[5]: {}

In [6]: dict_1
Out[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_3
Out[5]: {'name': 'Ring', 'info': [24]}

In [6]: dict_1
Out[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_1
Out[3]: {'name': None, 'age': None, 'sex': None}

常見操作

合併字典

有四種方式：

常規處理

In [15]: dict_1
Out[15]: {'Tony': 24}

In [16]: dict_2
Out[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_3
Out[20]: {'Tony': 24, 'ben': 18}

update()

In [9]: dict_1
Out[9]: {'Tony': 24}

In [10]: dict_2
Out[10]: {'ben': 18}

In [12]: dict_3 = dict_1.copy()

In [13]: dict_3.update(dict_2)

In [14]: dict_3
Out[14]: {'Tony': 24, 'ben': 18}

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

In [33]: dict_1
Out[33]: {'Tony': 24}

In [34]: dict_2
Out[34]: {'ben': 18}

In [35]: dict_3 = dict(dict_1, **dict_2)

In [36]: dict_3
Out[36]: {'Tony': 24, 'ben': 18}

進階

字典推導式

和列表推導式類似，優點是底層用C實現，會快很多，推薦使用。

對換字典的鍵值

使用字典推導式可以輕鬆對換一個字典的鍵值：

In [42]: dict_4
Out[42]: {24: 'Tony', 18: 'ben'}

In [43]: dict_3
Out[43]: {'Tony': 24, 'ben': 18}

In [44]: dict_4 = {k:v for v, k in dict_3.items()}

In [45]: dict_4
Out[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]: b
Out[90]: {'Ring': 23, 'Tony': 24}

生成有序字典

在Python3.6之前的字典是無序的，但是有時候我們需要保持字典的有序性，orderDict可以在dict的基礎上實現字典的有序性，這裡的有序指的是按照字典key插入的順序來排列，這樣就實現了一個先進先出的dict，當容量超出限制時，先刪除最早新增的key。
舉例：

In [49]: from collections import OrderedDict

In [50]: ordered_dict = OrderedDict([('a', 2), ('b', 4), ('c', 5)])

In [51]: for key, value in ordered_dict.items():
    ...:     print(key, value)
    ...:
a 2
b 4
c 5

可以看到OrderedDict是按照字典建立時的插入順序來排序。

原理：OrderedDict內部維護了一個雙向連結串列，它會根據元素加入的順序來排列鍵的位置，這也就導致OrderedDict的大小是普通字典的2倍多。

合併列表中key相同的字典

也就是生成所謂的一鍵多值字典，需要將對應的多個值儲存在其它容器比如列表或集合，取決於多值是否需要保證唯一性。