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

我們可以使用字典來(lái)解決許多編程問(wèn)題，那么今天我們就來(lái)看看如何在 Python 中遍歷字典

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

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

譯文如下：

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

模塊、類、對(duì)象、globals()和 locals() 都是字典與 Python 實(shí)現(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

需要注意的是：

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

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

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

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

在Python 3.6之前，字典是無(wú)序的數(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 有序是一個(gè)非常有用的功能。但是，如果使用的代碼支持較舊的 Python 版本，則不能依賴此功能，因?yàn)樗赡苌?bug，對(duì)于較新的版本，依賴該特性是完全安全的

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

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

如何在 python 中遍歷字典

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

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

• 直接遍歷字典

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

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

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

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

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

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

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

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

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

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

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

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

在本例中，同時(shí)使用 key和 likes[key] 來(lái)分別訪問(wèn)目標(biāo)字典的鍵和值

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

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

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

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

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

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

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

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

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

如果仔細(xì)觀察產(chǎn)生的各個(gè)項(xiàng)目 .items() ，那么會(huì)注意到它們是 tuple 對(duì)象：

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

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

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

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

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

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

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

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

這個(gè)方法返回一個(gè)只包含字典鍵的視圖對(duì)象

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

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

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

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

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

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

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

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

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

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

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

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

• 在迭代期間更改值

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

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

>>> 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)前的價(jià)格

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

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

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

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

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

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

>>> 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)遍歷副本，同時(shí)從原始字典中刪除項(xiàng)，在本例中，使用 del 語(yǔ)句刪除字典項(xiàng)

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

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

>>> 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)你試圖在迭代過(guò)程中從字典中刪除一個(gè) item 時(shí)，Python 會(huì)引發(fā) RuntimeError

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

遍歷期間對(duì)字典的操作

• 根據(jù)值來(lái)過(guò)濾 item

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

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

>>> 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}

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

還有另一種技術(shù)可以用來(lái)從字典中過(guò)濾 item。因?yàn)殒I的視圖對(duì)象類似于 Python 集合對(duì)象

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

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

還可以更簡(jiǎn)潔

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

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

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

• 算術(shù)運(yùn)算

在遍歷字典時(shí)，我們可以對(duì)字典的值進(jìn)行計(jì)算

>>> 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() 來(lái)求和

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

• 鍵值交換

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

>>> 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'}

更簡(jiǎn)潔的寫法

>>> 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'}

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

字典推導(dǎo)式

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

>>> 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'}

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

更簡(jiǎn)潔的方法如下：

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

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

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

最新評(píng)論