我們知道字典是 Python 中最重要且最有用的內(nèi)置數(shù)據(jù)結(jié)構(gòu)之一，它們無處不在，是語言本身的基本組成部分

我們可以使用字典來解決許多編程問題，那么今天我們就來看看如何在 Python 中遍歷字典

全文內(nèi)容：https://realpython.com/iterate-through-dictionary-python/

ps：文中提到的 Python 指的是 CPython 實現(xiàn)；

譯文如下：

字典是 Python 的基石。這門語言的很多方面都是圍繞著字典構(gòu)建的

模塊、類、對象、globals()和 locals() 都是字典與 Python 實現(xiàn)緊密聯(lián)系的例子

以下是 Python 官方文檔定義字典的方式：

An associative array, where arbitrary keys are mapped to values. The keys can be any object with __hash__() and __eq__() methods

需要注意的是：

• 字典將鍵映射到值，并將它們存儲在數(shù)組或集合中。鍵值對通常稱為 items
• 字典鍵必須是可哈希類型，這意味著它們必須具有在鍵的生命周期內(nèi)永遠不會更改的哈希值

與序列不同，序列是支持使用整數(shù)索引進行元素訪問的可迭代對象，字典按鍵編制索引。這意味著我們可以使用關(guān)聯(lián)的鍵而不是整數(shù)索引來訪問存儲在字典中的值

字典中的鍵很像 set ，它是可哈希和唯一對象的集合。由于鍵需要可哈希處理，因此不能將可變對象用作字典鍵（即鍵不能是可變數(shù)據(jù)類型）

另一方面，字典值可以是任何 Python 類型，無論它們是否可哈希。從字面上看，對值沒有任何限制。我們可以使用任何數(shù)據(jù)類型作為 Python 字典中的值

在Python 3.6之前，字典是無序的數(shù)據(jù)結(jié)構(gòu)。這意味著 item 的順序通常與插入順序不匹配

>>> # Python 3.5
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}

>>> likes
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}

可以看到，生成的詞典中 item 的順序與最初插入 item 的順序不匹配

在 Python 3.6 及更高版本中，字典的鍵和值保持與將它們插入底層字典的順序相同。即從3.6 開始，字典變成了緊湊有序的數(shù)據(jù)結(jié)構(gòu)

>>> # Python 3.6
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}

>>> likes
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}

保持 item 有序是一個非常有用的功能。但是，如果使用的代碼支持較舊的 Python 版本，則不能依賴此功能，因為它可能生成 bug，對于較新的版本，依賴該特性是完全安全的

字典的另一個重要特征是它們是可變的數(shù)據(jù)類型。這意味著我們可以根據(jù)需要就地添加、刪除和更新其項目

值得注意的是，這種可變性也意味著不能將字典用作另一個字典中的鍵

如何在 python 中遍歷字典

Python 開發(fā)人員經(jīng)常會遇到這樣的情況：在對其鍵值對執(zhí)行某些操作時，需要遍歷現(xiàn)有字典

因此，了解 Python 中字典迭代的不同方法非常重要。保持 item 有序是一個非常有用的功能

• 直接遍歷字典

Python 的字典有一些特殊的方法，Python 在內(nèi)部使用它們來執(zhí)行一些操作

這兩個方法的命名約定是，在方法名的開頭和末尾分別添加兩個下劃線

可以使用內(nèi)置 dir() 函數(shù)獲取任何 Python 對象提供的方法和屬性的列表。如果使用空字典作為參數(shù)運行 dir() ，則將獲得 dict 該類的所有方法和屬性

>>> dir({})
['__class__', '__contains__', '__delattr__', ... , '__iter__', ...]

可以看到'__iter__' 這個屬性，這是 Python 在需要容器數(shù)據(jù)類型的迭代器時自動調(diào)用的方法

該方法應(yīng)該返回一個新的迭代器對象，該對象允許我們遍歷底層容器類型中的所有項

對于 Python 字典，默認情況下允許 .__iter__() 直接迭代鍵。如果你直接在 for 循環(huán)中使用字典，Python 將自動調(diào)用 .__iter__() 屬性，你會得到一個遍歷其鍵的迭代器

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> for key in likes:
...     print(key)
...
color
fruit
pet

Python 足夠聰明，知道 likes 是一個字典，并且它實現(xiàn)了.__iter__()。在這個例子中，Python自動調(diào)用.__iter__()，這允許迭代 likes 字典的鍵

這是在 Python 中遍歷字典的主要方法——你只需要把字典直接放進一個 for 循環(huán)中

如果將此方法與 [key] 運算符一起使用，則可以在循環(huán)訪問鍵時訪問字典的值

>>> for key in likes:
...     print(key, "->", likes[key])
...
color -> blue
fruit -> apple
pet -> dog

在本例中，同時使用 key和 likes[key] 來分別訪問目標(biāo)字典的鍵和值

盡管在 Python 中直接遍歷字典非常簡單，但字典提供了更方便、更明確的工具來獲得相同的結(jié)果

.items() 該方法就是這種情況，它定義了一種快速迭代字典的 item 或鍵值對的方法

• .items()方法遍歷字典 item

使用字典時，同時循環(huán)訪問鍵和值可能是一個常見要求。 .items() 方法返回一個視圖對象，其中包含字典的項作為鍵值元組：

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes.items()
dict_items([('color', 'blue'), ('fruit', 'apple'), ('pet', 'dog')])

字典視圖對象提供字典項的動態(tài)視圖。在這里，動態(tài)意味著當(dāng)字典更改時，視圖會反映這些更改

視圖是可迭代的，因此我們可以使用調(diào)用 .items() 生成的視圖對象循環(huán)訪問字典中的項，如以下示例所示：

>>> for item in likes.items():
...     print(item)
...
('color', 'blue')
('fruit', 'apple')
('pet', 'dog')

在此示例中， 返回一個視圖對象，該對象一次生成一個鍵值對， .items() 并允許我們循環(huán)訪問它們

如果仔細觀察產(chǎn)生的各個項目 .items() ，那么會注意到它們是 tuple 對象：

>>> for item in likes.items():
...     print(item)
...     print(type(item))
...
('color', 'blue')
<class 'tuple'>
('fruit', 'apple')
<class 'tuple'>
('pet', 'dog')

可以看到所有的 item 都是元組。一旦知道了這一點，就可以使用元組解包來并行地遍歷鍵和值

要通過鍵和值實現(xiàn)并行迭代，只需將每個 item 的元素解壓縮為兩個不同的變量：一個用于鍵，另一個用于值

>>> for key, value in likes.items():
...     print(key, "->", value)
...
color -> blue
fruit -> apple
pet -> dog

for 循環(huán)頭中的 key 和 value 變量執(zhí)行解包操作。每次循環(huán)運行時，key獲得對當(dāng)前鍵的引用，value獲得對值的引用

這樣，我們就可以更好地控制字典內(nèi)容。因此，我們將能夠以可讀和 python 的方式分別處理鍵和值

• .keys() 方法遍歷字典的鍵

Python 字典提供了第二種遍歷其鍵的方法。除了在循環(huán)中直接使用目標(biāo)字典外，還可以使用.keys()方法

這個方法返回一個只包含字典鍵的視圖對象

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes.keys()
dict_keys(['color', 'fruit', 'pet'])

該方法 .keys() 返回一個對象，該對象提供 likes 鍵的動態(tài)視圖?？梢允褂么艘晥D對象循環(huán)訪問字典鍵

>>> for key in likes.keys():
...     print(key)
...
color
fruit
pet

當(dāng)您在 likes上調(diào)用 .keys() 時，將獲得鍵的視圖。Python 知道視圖對象是可迭代的，所以它開始循環(huán)

為什么要使用 .keys() 而不是直接遍歷字典。簡單來說，顯式地使用 .keys()可以讓你更好地表達只遍歷鍵的意圖

• .values() 方法遍歷字典值

在遍歷字典時面臨的另一個常見需求是只遍歷值。方法是使用 .values() 方法，它會返回一個包含底層字典中的值的視圖

>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes.values()
dict_values(['blue', 'apple', 'dog'])

上面的代碼返回一個視圖對象， .values() 返回一個視圖對象。

與其他視圖對象一樣，的結(jié)果 .values() 也是可迭代的，因此可以在循環(huán)中使用它

>>> for value in likes.values():
...     print(value)
...
blue
apple
dog

使用 .values() ，只能訪問目標(biāo)字典的值

• 在迭代期間更改值

有時，在 Python 中迭代字典時需要更改字典中的值

在下面的例子中，你在一個字典中更新了一堆產(chǎn)品的價格:

>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> for fruit, price in fruits.items():
...     fruits[fruit] = round(price * 0.9, 2)
...
>>> fruits
{'apple': 0.36, 'orange': 0.32, 'banana': 0.23}

在上面的例子中需要注意的是：為了更新值，我們使用了原始的字典，而不是像price = round(price * 0.9, 2)這樣直接更新當(dāng)前的價格

如果像price = round(price * 0.9, 2)這樣，重新分配水果或價格并沒有反映在原來的字典中

就會導(dǎo)致丟失對字典的引用，這樣并沒有實現(xiàn)更改字典中的任何內(nèi)容

• 在迭代期間安全地刪除 item

由于 Python 字典是可變的，我們可以根據(jù)需要從中刪除現(xiàn)有的 item

在下面的示例中，我們根據(jù)項的特定值選擇性地刪除項

注意，為了在遍歷字典時安全地縮小字典，我們需要使用一個副本

>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> for fruit in fruits.copy():
...     if fruits[fruit] >= 0.30:
...         del fruits[fruit]
...
>>> fruits
{'banana': 0.25}

在本例中，使用 .copy() 創(chuàng)建目標(biāo)字典fruits的淺副本。然后循環(huán)遍歷副本，同時從原始字典中刪除項，在本例中，使用 del 語句刪除字典項

但是也可以使用 .pop() 將目標(biāo)鍵作為參數(shù)

如果在嘗試刪除循環(huán)中的 item 時不使用目標(biāo)詞典的副本，則會收到錯誤

>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> for fruit in fruits:
...     if fruits[fruit] >= 0.30:
...         del fruits[fruit]
...
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    for fruit in fruits:
RuntimeError: dictionary changed size during iteration

當(dāng)你試圖在迭代過程中從字典中刪除一個 item 時，Python 會引發(fā) RuntimeError

由于原始字典的大小發(fā)生了變化，因此如何繼續(xù)迭代是不明確的。因此，要避免這個問題，請始終在迭代中使用字典的副本

遍歷期間對字典的操作

• 根據(jù)值來過濾 item

有時候我們希望在原字典的前提下創(chuàng)建一個只包含滿足特定條件的新字典

我們可以在遍歷原字典的時候加上條件判斷

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> small_numbers = {}
>>> for key, value in numbers.items():
...     if value <= 2:
...         small_numbers[key] = value
...
>>> small_numbers
{'one': 1, 'two': 2}

在此示例中，篩選值小于的項目 2 ，并將它們添加到 small_numbers 字典中

還有另一種技術(shù)可以用來從字典中過濾 item。因為鍵的視圖對象類似于 Python 集合對象

因此，它們支持集合操作，例如并集、交集和差分?？梢岳眠@種類似集合的行為從字典中過濾某些鍵

>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> fruits.keys() - {"orange"}
{'apple', 'banana'}

還可以更簡潔

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> {key: value for key, value in numbers.items() if value <= 2}
{'one': 1, 'two': 2}

或者通過計算字典的鍵與一組不需要的鍵之間的差分而獲得的鍵集構(gòu)建一個新詞典

>>> non_citrus = {}
>>> for key in fruits.keys() - {"orange"}:
...     non_citrus[key] = fruits[key]
...
>>> non_citrus
{'apple': 0.4, 'banana': 0.25}

• 算術(shù)運算

在遍歷字典時，我們可以對字典的值進行計算

>>> incomes = {"apple": 5600.00, "orange": 3500.00, "banana": 5000.00}
>>> total_income = 0.00
>>> for income in incomes.values():
...     total_income += income
...
>>> total_income
14100.0

或者使用內(nèi)置的 sum() 函數(shù)。把字典中的值作為參數(shù)直接傳遞給 sum() 來求和

>>> incomes = {"apple": 5600.00, "orange": 3500.00, "banana": 5000.00}
>>> sum(incomes.values())
14100.0

• 鍵值交換

我們可以在遍歷的時候交換字典的鍵和值

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> swapped = {}
>>> for key, value in numbers.items():
...     swapped[value] = key
...
>>> swapped
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

更簡潔的寫法

>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> {value: key for key, value in numbers.items()}
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

需要注意的是，原始字典值中的數(shù)據(jù)必須是可哈希數(shù)據(jù)類型

我們還可以將內(nèi)置 zip() 函數(shù)與 dict() 構(gòu)造函數(shù)一起使用

>>> dict(zip(numbers.values(), numbers.keys()))
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

上面的示例中，通過 zip() 生成值鍵對的元組，然后，使用生成的元組作為參數(shù)并 dict() 構(gòu)建所需的字典

字典推導(dǎo)式

與列表推導(dǎo)式不同，字典推導(dǎo)式需要一個映射到值的鍵

>>> categories = ["color", "fruit", "pet"]
>>> objects = ["blue", "apple", "dog"]
>>> likes = {key: value for key, value in zip(categories, objects)}
>>> likes
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}

上面的對象中， zip() 接收兩個可迭代對象（ categories 、objects ）生成了一個 tuple 對象，然后被解壓縮到 key 和 value 中，最終用于創(chuàng)建新的所需字典

更簡潔的方法如下：

>>> categories = ["color", "fruit", "pet"]
>>> objects = ["blue", "apple", "dog"]
>>> dict(zip(categories, objects))
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}

zip() 函數(shù)從原始列表生成鍵值對，而 dict() 構(gòu)造函數(shù)負責(zé)創(chuàng)建新字典

到此這篇關(guān)于Python 遍歷字典的方法匯總的文章就介紹到這了,更多相關(guān)Python 遍歷字典內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論