科技改變生活 · 科技引領未來
科技改變生活 · 科技引領未來
來源：Python數據之道作者：陽哥大家好，我是陽哥。字典（dict）是python中的基礎數據類型之一，字典的設計并不復雜，我們經常會用到這種數據類型。同時，字典也有一些比較實用的情景。學習任何一種編程語言，基礎數據類型都是必備的底層基礎
來源：Python數據之道
作者：陽哥
大家好，我是陽哥。
字典（dict）是 python 中的基礎數據類型之一，字典的設計并不復雜，我們經常會用到這種數據類型。
同時，字典也有一些比較實用的情景。
學習任何一種編程語言，基礎數據類型都是必備的底層基礎，今天，我們來學習下 Python 中字典的使用。
主要內容包括：
01、基本用法
在 Python 中，字典是一種可以將相關的兩個信息關聯起來的操作，并且字典可存儲的信息量幾乎不受限制。
字典是 Python 提供的一種常用的數據結構，它用于存放具有映射關系的數據。為了保存具有映射關系的數據，Python 提供了字典，字典相當于保存了兩組數據，其中一組數據是關鍵數據，被稱為 key；另一組數據可通過 key 來訪問，被稱為 value。
創建字典
字典是以 key、value 的形式創建的。
字典的每個鍵值 key=>value 對用冒號 : 分割，每個鍵值對之間用逗號 , 分割，整個字典包括在花括號 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
一般情況下，字典的創建可以有以下幾種方式：
# 創建一個空的字典 my_dict1 = {} # 創建 key 值為整數的字典 my_dict2 = {1: 'apple', 2: 'ball'} # 創建 key 值為 string 的字典 my_dict3 = {'name1': 'apple', 'name2': 'ball'} # 創建 key 值為 數字 和 string 混合的字典 my_dict4 = {'name': 'apple', 1: [2, 4, 3]} # 用 dict() 函數創建字典 my_dict5 = dict({1:'apple', 2:'ball'}) # 以元組的形式組成序列創建字典 my_dict6 = dict([(1,'apple'), (2,'ball')]) print('my_dict1:', my_dict1) print('my_dict2:', my_dict2) print('my_dict3:', my_dict3) print('my_dict4:', my_dict4) print('my_dict5:', my_dict5) print('my_dict6:', my_dict6) 結果如下：
my_dict1: {} my_dict2: {1: 'apple', 2: 'ball'} my_dict3: {'name1': 'apple', 'name2': 'ball'} my_dict4: {'name': 'apple', 1: [2, 4, 3]} my_dict5: {1: 'apple', 2: 'ball'} my_dict6: {1: 'apple', 2: 'ball'} 也可以通過下面的方式來創建空白字典
# 創建空白字典的另一種方式 my_dict7 = dict() # print('my_dict7:', my_dict7) my_dict7 結果如下：
{} 獲取字典中的元素
通過 key 來獲取 value
獲取字典中的元素，可以直接通過 key 值來獲取對應的 value，如下：
my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3]} print(my_dict8['name']) print(my_dict8.get('name')) 結果如下：
John John 請注意，如果字典的key值中沒有該元素，則不能獲取相應的 value，這種情況下產生錯誤。
print(my_dict8['name1']) 結果如下：
--------------------------------------------------------------------------- KeyError Traceback (most recent call last) in ----> 1 print(my_dict8['name1']) KeyError: 'name1' 通過 value 來獲取 key
通過 value 來獲取 key 值，在 Python 中并沒有提供直接的方法，我們可以通過自定義函數來實現，如下：
def get_keys(d, value): return [k for k,v in d.items() if v == value] 函數中，d 是字典。
在字典中修改或添加元素
在字典中，可以修改已有 key 對應的 value 值，或者添加新的 key-value 鍵值對數據，如下：
my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3]} # 修改已有 key 對應的 value 的值 my_dict8['age'] = 98 # 添加新的 key-value 數據組 my_dict8['gender'] = 'man' my_dict8 結果如下：
{'name': 'John', 'age': 98, 1: [2, 4, 3], 'gender': 'man'} 從字典中刪除元素
從字典中刪除元素，或者刪除整個字典，有以下一些方式。
pop() 方法
移除字典數據pop()方法的作用是：刪除指定給定鍵所對應的值，返回這個值并從字典中把它移除。
# 使用 pop()方法來刪除 my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3]} my_dict8.pop('age') my_dict8 結果如下：
{'name': 'John', 1: [2, 4, 3]} del 方法
# 使用 del 方法來刪除 my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3]} del my_dict8['name'] my_dict8 結果如下：
{'age': 25, 1: [2, 4, 3]} popitem() 方法
# 使用 popitem()方法來刪除 my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man', 'school': 'UCI', 'city': 'NewYork'} my_dict8.popitem() my_dict8 結果如下：
{'name': 'John', 'age': 25, 1: [2, 4, 3], 'gender': 'man', 'school': 'UCI'} 關于 popitem() 方法：
在Python 3.5版本以及之前的時候，使用 popitem() 可能是隨機刪除的，但我曾經用的 Python3.6版本，好像不是隨機刪除的，是刪除的最后一項。
從 Python 3.7 版本開始，使用 popitem() 方法是刪除最后一項，因為字典默認是記住了順序的：
Ordered dictionaries are just like regular dictionaries but have some extra capabilities relating to ordering operations.
They have become less important now that the built-in dict class gained the ability to remember insertion order (this new behavior became guaranteed in Python 3.7).
另外，我查閱了一下 Python3.7 版本中的描述，如下：
popitem()
Remove and return a (key, value) pair from the dictionary. Pairs are returned in LIFO order.
popitem() is useful to destructively iterate over a dictionary, as often used in set algorithms. If the dictionary is empty, calling popitem() raises a KeyError.
Changed in version 3.7: LIFO order is now guaranteed. In prior versions, popitem() would return an arbitrary key/value pair.
https://docs.python.org/3/library/stdtypes.html#mapping-types-dict
在 Python3.7 版本中，是按照 LIFO 的原則進行刪除的，是有序進行刪除的。
LIFO （Last-in, first-out）即后進來的先刪除（也可理解為按后面往前的排序進行刪除）
clear()方法
clear()方法是用來清除字典中的所有數據，因為是原地操作，所以返回 None（也可以理解為沒有返回值）
# 使用 clear()方法來清空字典中的所有數據，返回的是一個空字典 my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'} my_dict8.clear() my_dict8 結果如下：
{} del 方法
del 方法可以刪除字典中指定 key 值的內容。
另外， del 可以刪除整個字典，與 clear() 方法的清空字典中所有數據是不一樣的。演示如下：
使用 del方法是刪除字典中指定 key 值對應的內容
# 使用 del方法是刪除字典中指定 key 值對應的內容 my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'} del my_dict8['age'] my_dict8 結果如下：
{'name': 'John', 1: [2, 4, 3], 'gender': 'man'} 使用 del方法是刪除整個字典，刪除后，再運行程序，會報錯誤
# 使用 del方法是刪除整個字典，刪除后，再運行程序，會報錯誤 my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'} del my_dict8 my_dict8 結果如下：
--------------------------------------------------------------------------- NameError Traceback (most recent call last) in 4 del my_dict8 5 ----> 6 my_dict8 NameError: name 'my_dict8' is not defined 字典內置函數&方法
Python字典包含了以下內置函數：
序號函數及描述len(dict)計算字典元素個數，即鍵的總數。str(dict)輸出字典可打印的字符串表示。type(variable)返回輸入的變量類型，如果變量是字典就返回字典類型。
len(), str(), type() 函數
my_dict6 = dict([(1,'apple'), (2,'ball')]) my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'} print(len(my_dict8)) print(str(my_dict6)) print(type(my_dict8)) 結果如下：
4 {1: 'apple', 2: 'ball'} 'dict'> Python字典包含以下一些方法：
函數函數描述clear()刪除字典內所有元素，返回空字典copy()返回一個字典的淺復制fromkeys(seq[, val])創建一個新字典，以序列 seq 中元素做字典的鍵，val 為字典所有鍵對應的初始值get(key, default=None)返回指定鍵的值，如果值不在字典中返回 default 值items()以列表返回可遍歷的(鍵, 值) 元組數組keys()以列表返回一個字典所有的鍵setdefault(key, default=None)和 get()類似, 但如果鍵不存在于字典中，將會添加鍵并將值設為 defaultupdate(dict2)把字典 dict2 的鍵/值對更新到 dict里values()以列表返回字典中的所有值pop(key[,default])刪除字典給定鍵 key 所對應的值，返回值為被刪除的值。key 值必須給出。否則，返回 default值。popitem()隨機返回并刪除字典中的一對鍵和值。Python 3.6及以后版本，以 LIFO 的原則進行刪除的，是有序進行刪除的。
clear(), get(), pop(), popitem() 等在上面已介紹的方法，這里不做重復，僅演示其他方法的使用。
copy, keys, values, items 方法
my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'} print('copy:', my_dict8.copy()) print('keys:', my_dict8.keys()) print('values:', my_dict8.values()) print('items:', my_dict8.items()) 結果如下：
copy: {'name': 'John', 'age': 25, 1: [2, 4, 3], 'gender': 'man'} keys: dict_keys(['name', 'age', 1, 'gender']) values: dict_values(['John', 25, [2, 4, 3], 'man']) items: dict_items([('name', 'John'), ('age', 25), (1, [2, 4, 3]), ('gender', 'man')]) update 方法
通過 update 方法，可以更新字典的數據內容：
my_dict6 = {'name': 'Lemon', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'} my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'} my_dict8.update(my_dict6) my_dict8 結果如下：
{'name': 'Lemon', 'age': 25, 1: [2, 4, 3], 'gender': 'man'} fromkeys 方法
fromkeys（）方法的演示如下：
請注意，該結果與 zip（） 方法之后的結果是不一樣的。
seq = ['name', 'age', 'city'] value = ['Lemon', 18, 'cs'] my_dict9 = dict.fromkeys(seq, value) my_dict9 結果如下：
{'name': ['Lemon', 18, 'cs'], 'age': ['Lemon', 18, 'cs'], 'city': ['Lemon', 18, 'cs']} zip（）方法
seq = ['name', 'age', 'city'] value = ['Lemon', 18, 'cs'] my_dict10 = dict(zip(seq, value)) my_dict10 結果如下：
{'name': 'Lemon', 'age': 18, 'city': 'cs'} setdefault 方法
dict.setdefault(key, default=None)
該方法接收兩個參數，第一個參數是健的名稱，第二個參數是默認值。
假如字典中不存在給定的鍵，則把默認值賦值給對應的value，并返回默認值；
反之，不修改value，只返回value。
my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'} print('字典中存在的key，返回對應value：', my_dict8.setdefault('age', 0)) print('字典中不存在的key，返回默認值：', my_dict8.setdefault('age1', 0)) 結果如下：
字典中存在的key，返回對應value： 25 字典中不存在的key，返回默認值： 0 此外，還可以用 setdefault() 方法統計一個列表里單詞出現的次數：
# 用 setdefault() 方法統計一個列表里單詞出現的次數 strings = ('Lemon', 'kitten', 'Lemon', 'Lemon', 'lemon_zs', 'Lemon', 'Lemon', 'lemon_zs') counts = {} for kw in strings: counts[kw] = counts.setdefault(kw, 0) + 1 counts 結果如下：
{'Lemon': 5, 'kitten': 1, 'lemon_zs': 2} 02、字典推導式（dict comprehension）
字典推導式的一般表達式如下：
{key: value for (key, value) in iterable}
有些用法與列表推導式是類似的，可以參考下面的內容：
用字典推導式的方法創建字典：
my_dict01 = {x: x*x for x in range(6)} my_dict01 結果如下：
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25} 通過兩個list創建字典：
keys = ['name', 'age', 'city'] values = ['Lemon', 18, 'cs'] my_dict02 = {k:v for (k,v) in zip(keys,values)} my_dict02 結果如下：
{'name': 'Lemon', 'age': 18, 'city': 'cs'} 在特定條件下，用字典推導式的方法創建字典：
my_dict03 = {x: x*x for x in range(10) if x%2==0} my_dict03 結果如下：
{0: 0, 2: 4, 4: 16, 6: 36, 8: 64} 03、嵌套型字典
什么是嵌套型的字典
字典是以 key、value 的形式創建的， 而嵌套型的字典有一個特征，就是 key 對應的 value 值也可以是一個字典。最簡潔的嵌套型字典如下：
d = {key1 : {key3 : value3}, key2 : {key4 : value4} } 創建一個嵌套型字典
nested_dict01 = {1: {'name':'Lemon', 'age': '18', 'city':'cs'}, 2: {'name':'Lemon_zs', 'age': '18', 'city':'changsha'}} nested_dict01 結果如下：
{1: {'name': 'Lemon', 'age': '18', 'city': 'cs'}, 2: {'name': 'Lemon_zs', 'age': '18', 'city': 'changsha'}} 上述的嵌套型字典中，字典第一層的 key 分別是 1 和 2， 而他們對應的 value 值又是都是字典， 里面的字典的 key 都是 "name", "age" 和 "city"， 但對應的 value 不一樣。
從嵌套型字典中獲取元素
從嵌套型字典中獲取元素，跟從 list， 以及數組中獲取元素時有些類似的。
嵌套型字典 用 [] 進行不同層級元素的獲取。
nested_dict01 = {1: {'name':'Lemon', 'age': '18', 'city':'cs'}, 2: {'name':'Lemon_zs', 'age': '18', 'city':'changsha'}} print(nested_dict01[1]['name']) print(nested_dict01[2]['city']) 結果如下：
Lemon changsha 修改嵌套型字典的元素 （更改、增加或刪除元素）
針對嵌套型字典，同樣是可以更新、增加或刪除元素的.
增加一個空的字典
nested_dict01 = {1: {'name':'Lemon', 'age': '18', 'city':'cs'}, 2: {'name':'Lemon_zs', 'age': '18', 'city':'changsha'}} # 增加一個空的字典 nested_dict01[3] = {} nested_dict01 結果如下：
{1: {'name': 'Lemon', 'age': '18', 'city': 'cs'}, 2: {'name': 'Lemon_zs', 'age': '18', 'city': 'changsha'}, 3: {}} 修改或增加新的元素
# 修改元素內容 nested_dict01[2]['age'] = '26' # 增加新的元素 nested_dict01[3]['name'] = 'zws' nested_dict01 結果如下：
{1: {'name': 'Lemon', 'age': '18', 'city': 'cs'}, 2: {'name': 'Lemon_zs', 'age': '26', 'city': 'changsha'}, 3: {'name': 'zws'}} 在嵌套型字典中直接添加一個字典
# 在嵌套型字典中直接添加一個字典 nested_dict01[5]={'name': 'rx', 'age':'3', 'city':'ly'} nested_dict01 結果如下：
{1: {'name': 'Lemon', 'age': '18', 'city': 'cs'}, 2: {'name': 'Lemon_zs', 'age': '26', 'city': 'changsha'}, 3: {'name': 'zws'}, 5: {'name': 'rx', 'age': '3', 'city': 'ly'}} 刪除某個具體元素內容
# 刪除某個具體元素內容 del nested_dict01[5]['city'] nested_dict01 結果如下：
{1: {'name': 'Lemon', 'age': '18', 'city': 'cs'}, 2: {'name': 'Lemon_zs', 'age': '26', 'city': 'changsha'}, 3: {'name': 'zws'}, 5: {'name': 'rx', 'age': '3'}} 刪除嵌套字典里面的某個字典
# 刪除嵌套字典里面的某個字典 del nested_dict01[5] nested_dict01 結果如下：
{1: {'name': 'Lemon', 'age': '18', 'city': 'cs'}, 2: {'name': 'Lemon_zs', 'age': '26', 'city': 'changsha'}, 3: {'name': 'zws'}} 通過 for 循環來獲取嵌套字典內的元素
for main_id, main_info in nested_dict01.items(): print('nmain id: ', main_id) for key in main_info: print(key+':', main_info[key]) 結果如下：
main id: 1 name: Lemon age: 18 city: cs main id: 2 name: Lemon_zs age: 26 city: changsha main id: 3 name: zws 用 pprint 輸出嵌套型字典
用 pprint 可以使字典顯示層次更清晰，需要安裝 pprint，安裝命令如下：
pip install pprint
演示如下：
# 需要安裝 pprint # pip install pprint # pprint 可以使字典顯示層次更清晰 import pprint menu = {'dinner':{'chicken':'good','beef':'average', 'vegetarian':{'tofu':'good', 'salad':{'caeser':'bad', 'italian':'average'}}, 'pork':'bad'}} pprint.pprint(menu) 結果如下：
{'dinner': {'beef': 'average', 'chicken': 'good', 'pork': 'bad', 'vegetarian': {'salad': {'caeser': 'bad', 'italian': 'average'}, 'tofu': 'good'}}} 嵌套型字典的一些用途
可能有些疑惑，字典嵌套這么多層，在哪些地方可以用呢？
這里分享一個用途。嵌套型字典，經常在機器學習中的決策樹算法中涉及到。
比如下面的 menu， 是一個字典。它也可以用樹的形式顯示出來，這在 決策樹中會經常用到。
menu = {'dinner':{'chicken':'good','beef':'average', 'vegetarian':{'tofu':'good', 'salad':{'caeser':'bad', 'italian':'average'}}, 'pork':'bad'}} 示例：
from sklearn.tree import DecisionTreeClassifier, export_graphviz from sklearn import tree from sklearn.datasets import load_wine from IPython.display import SVG from graphviz import Source from IPython.display import display # load dataset data = load_wine() # feature matrix X = data.data # target vector y = data.target # class labels labels = data.feature_names # print dataset description # print(data.DESCR) estimator = DecisionTreeClassifier() estimator.fit(X, y) graph = Source(tree.export_graphviz(estimator, out_file=None , feature_names=labels, class_names=['0', '1', '2'] , filled = True)) display(SVG(graph.pipe(format='svg'))) 可視化效果如下：
04 小結
以上就是 python 中關于字典使用的基礎內容，在實踐中，咱們還會大量應用到字典。相對來說，嵌套字典會比較復雜些。當我們熟練使用字典的基本方法時，還是可以應對這些問題的。
有時候，也會有一些比較獨特的字典，比如 key-value 鍵值對中的 value 是 pandas 中的 dataframe ，其基礎原理，一些常用的方法還是一樣的。
丁夕