python如何遍歷字典中的key和value

Python是一種高級(jí)編程語言，它支持多種數(shù)據(jù)類型，其中字典是一種非常常用的數(shù)據(jù)類型。字典是一種無序的鍵值對(duì)集合，可以通過鍵來訪問值。在Python中，我們可以使用不同的方法來遍歷字典中的鍵和值，本文將從多個(gè)角度來分析Python如何遍歷字典中的key和value。

一、使用for循環(huán)遍歷字典中的key和value

使用for循環(huán)可以循環(huán)遍歷字典中的每一個(gè)元素。下面是一個(gè)示例代碼：

dict = {'Name': 'John', 'Age': 25, 'Location': 'New York'}
for key in dict:
print(key, dict[key])

輸出結(jié)果為：

Name John

Age 25

Location New York

在這個(gè)示例中，我們首先定義了一個(gè)字典，然后使用for循環(huán)遍歷字典中的每一個(gè)元素。在循環(huán)體中，我們可以使用字典的key來訪問對(duì)應(yīng)的value，并將它們打印出來。

二、使用items()方法遍歷字典中的key和value

Python中的字典類提供了一個(gè)items()方法，它可以返回字典中所有的鍵值對(duì)。下面是一個(gè)示例代碼：

dict = {'Name': 'John', 'Age': 25, 'Location': 'New York'}
for key, value in dict.items():
print(key, value)

輸出結(jié)果為：

Name John

Age 25

Location New York

在這個(gè)示例中，我們使用items()方法來獲取字典中的所有鍵值對(duì)，并使用for循環(huán)依次遍歷每一個(gè)鍵值對(duì)。在循環(huán)體中，我們可以使用鍵值對(duì)中的key和value來進(jìn)行操作。

三、使用keys()方法遍歷字典中的key

如果我們只想遍歷字典中的key，可以使用keys()方法。下面是一個(gè)示例代碼：

dict = {'Name': 'John', 'Age': 25, 'Location': 'New York'}
for key in dict.keys():
print(key)

輸出結(jié)果為：

Name

Age

Location

在這個(gè)示例中，我們使用keys()方法來獲取字典中的所有key，并使用for循環(huán)依次遍歷每一個(gè)key。在循環(huán)體中，我們只打印了key。

四、使用values()方法遍歷字典中的value

如果我們只想遍歷字典中的value，可以使用values()方法。下面是一個(gè)示例代碼：

dict = {'Name': 'John', 'Age': 25, 'Location': 'New York'}
for value in dict.values():
print(value)

輸出結(jié)果為：

John

25

New York

在這個(gè)示例中，我們使用values()方法來獲取字典中的所有value，并使用for循環(huán)依次遍歷每一個(gè)value。在循環(huán)體中，我們只打印了value。

五、使用列表推導(dǎo)式遍歷字典中的key和value

除了上述方法，我們還可以使用列表推導(dǎo)式來遍歷字典中的key和value。下面是一個(gè)示例代碼：

dict = {'Name': 'John', 'Age': 25, 'Location': 'New York'}
items = [(key, value) for key, value in dict.items()]
print(items)

輸出結(jié)果為：

[('Name', 'John'), ('Age', 25), ('Location', 'New York')]

在這個(gè)示例中，我們使用列表推導(dǎo)式來遍歷字典中的所有鍵值對(duì)，并將它們存儲(chǔ)在一個(gè)列表中。在列表推導(dǎo)式中，我們使用了字典的items()方法來獲取所有鍵值對(duì)，并使用for循環(huán)遍歷每一個(gè)鍵值對(duì)。在每一次循環(huán)中，我們使用了一個(gè)元組來存儲(chǔ)當(dāng)前的鍵值對(duì)。

六、總結(jié)

本文從多個(gè)角度分析了Python如何遍歷字典中的key和value，包括使用for循環(huán)、items()方法、keys()方法、values()方法和列表推導(dǎo)式。通過本文的介紹，讀者可以更加深入地了解Python中遍歷字典的方法，為日后的編程工作提供幫助。

Python 遍歷字典的若干方法

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

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

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

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

譯文如下：

字典是 Python 的基石。這門語言的很多方面都是圍繞著字典構(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)行元素訪問的可迭代對(duì)象，字典按鍵編制索引。這意味著我們可以使用關(guān)聯(lián)的鍵而不是整數(shù)索引來訪問存儲(chǔ)在字典中的值

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

另一方面，字典值可以是任何 Python 類型，無論它們是否可哈希。從字面上看，對(duì)值沒有任何限制。我們可以使用任何數(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 有序是一個(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)部使用它們來執(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)訪問鍵時(shí)訪問字典的值

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

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

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

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

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

使用字典時(shí)，同時(shí)循環(huá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)訪問字典中的項(xiàng)，如以下示例所示：

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

在此示例中， 返回一個(gè)視圖對(duì)象，該對(duì)象一次生成一個(gè)鍵值對(duì)， .items() 并允許我們循環(huá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)，就可以使用元組解包來并行地遍歷鍵和值

要通過鍵和值實(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)訪問字典鍵

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

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

為什么要使用 .keys() 而不是直接遍歷字典。簡(jiǎn)單來說，顯式地使用 .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() ，只能訪問目標(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à)格并沒有反映在原來的字典中

就會(huì)導(dǎo)致丟失對(duì)字典的引用，這樣并沒有實(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 語句刪除字典項(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)你試圖在迭代過程中從字典中刪除一個(gè) item 時(shí)，Python 會(huì)引發(fā) RuntimeError

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

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

• 根據(jù)值來過濾 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ù)可以用來從字典中過濾 item。因?yàn)殒I的視圖對(duì)象類似于 Python 集合對(duì)象

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

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

或者通過計(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() 來求和

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

上面的示例中，通過 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)文章希望大家以后多多支持腳本之家！