哈嘍大家好，我是鹹魚
我們知道字典是 Python 中最重要且最有用的內建資料結構之一，它們無處不在，是語言本身的基本組成部分
我們可以使用字典來解決許多程式設計問題，那麼今天我們就來看看如何在 Python 中遍歷字典
全文內容：https://realpython.com/iterate-through-dictionary-python/
ps：文中提到的 Python 指的是 CPython 實現；
譯文如下：
字典是 Python 的基石。這門語言的很多方面都是圍繞著字典構建的
模組、類、物件、globals()和 locals() 都是字典與 Python 實現緊密聯絡的例子
以下是 Python 官方檔案定義字典的方式：
An associative array, where arbitrary keys are mapped to values. The keys can be any object with
__hash__()and__eq__()methods
需要注意的是：
與序列不同，序列是支援使用整數索引進行元素存取的可迭代物件，字典按鍵編制索引。這意味著我們可以使用關聯的鍵而不是整數索引來存取儲存在字典中的值
字典中的鍵很像 set ，它是可雜湊和唯一物件的集合。由於鍵需要可雜湊處理，因此不能將可變物件用作字典鍵（即鍵不能是可變資料型別）
另一方面，字典值可以是任何 Python 型別，無論它們是否可雜湊。從字面上看，對值沒有任何限制。我們可以使用任何資料型別作為 Python 字典中的值
在Python 3.6之前，字典是無序的資料結構。這意味著 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 開始，字典變成了緊湊有序的資料結構
>>> # Python 3.6
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
保持 item 有序是一個非常有用的功能。但是，如果使用的程式碼支援較舊的 Python 版本，則不能依賴此功能，因為它可能生成 bug，對於較新的版本，依賴該特性是完全安全的
字典的另一個重要特徵是它們是可變的資料型別。這意味著我們可以根據需要就地新增、刪除和更新其專案
值得注意的是，這種可變性也意味著不能將字典用作另一個字典中的鍵
Python 開發人員經常會遇到這樣的情況：在對其鍵值對執行某些操作時，需要遍歷現有字典
因此，瞭解 Python 中字典迭代的不同方法非常重要。保持 item 有序是一個非常有用的功能
Python 的字典有一些特殊的方法，Python 在內部使用它們來執行一些操作
這兩個方法的命名約定是，在方法名的開頭和末尾分別新增兩個下劃線
可以使用內建 dir() 函數獲取任何 Python 物件提供的方法和屬性的列表。如果使用空字典作為引數執行 dir() ，則將獲得 dict 該類的所有方法和屬性
>>> dir({})
['__class__', '__contains__', '__delattr__', ... , '__iter__', ...]
可以看到'__iter__' 這個屬性，這是 Python 在需要容器資料型別的迭代器時自動呼叫的方法
該方法應該返回一個新的迭代器物件，該物件允許我們遍歷底層容器型別中的所有項
對於 Python 字典，預設情況下允許 .__iter__() 直接迭代鍵。如果你直接在 for 迴圈中使用字典，Python 將自動呼叫 .__iter__() 屬性，你會得到一個遍歷其鍵的迭代器
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> for key in likes:
... print(key)
...
color
fruit
pet
Python 足夠聰明，知道 likes 是一個字典，並且它實現了.__iter__()。在這個例子中，Python自動呼叫.__iter__()，這允許迭代 likes 字典的鍵
這是在 Python 中遍歷字典的主要方法——你只需要把字典直接放進一個 for 迴圈中
如果將此方法與 [key] 運運算元一起使用，則可以在迴圈存取鍵時存取字典的值
>>> for key in likes:
... print(key, "->", likes[key])
...
color -> blue
fruit -> apple
pet -> dog
在本例中，同時使用 key 和 likes[key] 來分別存取目標字典的鍵和值
儘管在 Python 中直接遍歷字典非常簡單，但字典提供了更方便、更明確的工具來獲得相同的結果
.items() 該方法就是這種情況，它定義了一種快速迭代字典的 item 或鍵值對的方法
.items()方法遍歷字典 item使用字典時，同時迴圈存取鍵和值可能是一個常見要求。 .items() 方法返回一個檢視物件，其中包含字典的項作為鍵值元組：
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes.items()
dict_items([('color', 'blue'), ('fruit', 'apple'), ('pet', 'dog')])
字典檢視物件提供字典項的動態檢視。在這裡，動態意味著當字典更改時，檢視會反映這些更改
檢視是可迭代的，因此我們可以使用呼叫 .items() 生成的檢視物件迴圈存取字典中的項，如以下範例所示：
>>> for item in likes.items():
... print(item)
...
('color', 'blue')
('fruit', 'apple')
('pet', 'dog')
在此範例中， 返回一個檢視物件，該物件一次生成一個鍵值對， .items() 並允許我們迴圈存取它們
如果仔細觀察產生的各個專案 .items() ，那麼會注意到它們是 tuple 物件：
>>> for item in likes.items():
... print(item)
... print(type(item))
...
('color', 'blue')
<class 'tuple'>
('fruit', 'apple')
<class 'tuple'>
('pet', 'dog')
可以看到所有的 item 都是元組。一旦知道了這一點，就可以使用元組解包來並行地遍歷鍵和值
要通過鍵和值實現並行迭代，只需將每個 item 的元素解壓縮為兩個不同的變數：一個用於鍵，另一個用於值
>>> for key, value in likes.items():
... print(key, "->", value)
...
color -> blue
fruit -> apple
pet -> dog
for 迴圈頭中的 key 和 value 變數執行解包操作。每次迴圈執行時，key獲得對當前鍵的參照，value獲得對值的參照
這樣，我們就可以更好地控制字典內容。因此，我們將能夠以可讀和 python 的方式分別處理鍵和值
.keys() 方法遍歷字典的鍵Python 字典提供了第二種遍歷其鍵的方法。除了在迴圈中直接使用目標字典外，還可以使用.keys()方法
這個方法返回一個只包含字典鍵的檢視物件
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes.keys()
dict_keys(['color', 'fruit', 'pet'])
該方法 .keys() 返回一個物件，該物件提供 likes 鍵的動態檢視。可以使用此檢視物件迴圈存取字典鍵
>>> for key in likes.keys():
... print(key)
...
color
fruit
pet
當您在 likes上呼叫 .keys() 時，將獲得鍵的檢視。Python 知道檢視物件是可迭代的，所以它開始迴圈
為什麼要使用 .keys() 而不是直接遍歷字典。簡單來說，顯式地使用 .keys()可以讓你更好地表達只遍歷鍵的意圖
.values() 方法遍歷字典值在遍歷字典時面臨的另一個常見需求是隻遍歷值。方法是使用 .values() 方法，它會返回一個包含底層字典中的值的檢視
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes.values()
dict_values(['blue', 'apple', 'dog'])
上面的程式碼返回一個檢視物件， .values() 返回一個檢視物件。
與其他檢視物件一樣，的結果 .values() 也是可迭代的，因此可以在迴圈中使用它
>>> for value in likes.values():
... print(value)
...
blue
apple
dog
使用 .values() ，只能存取目標字典的值
有時，在 Python 中迭代字典時需要更改字典中的值
在下面的例子中，你在一個字典中更新了一堆產品的價格:
>>> 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)這樣直接更新當前的價格
如果像price = round(price * 0.9, 2)這樣，重新分配水果或價格並沒有反映在原來的字典中
就會導致丟失對字典的參照，這樣並沒有實現更改字典中的任何內容
由於 Python 字典是可變的，我們可以根據需要從中刪除現有的 item
在下面的範例中，我們根據項的特定值選擇性地刪除項
注意，為了在遍歷字典時安全地縮小字典，我們需要使用一個副本
>>> 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() 建立目標字典fruits的淺副本。然後迴圈遍歷副本，同時從原始字典中刪除項，在本例中，使用 del 語句刪除字典項
但是也可以使用 .pop() 將目標鍵作為引數
如果在嘗試刪除迴圈中的 item 時不使用目標詞典的副本，則會收到錯誤
>>> 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
當你試圖在迭代過程中從字典中刪除一個 item 時，Python 會引發 RuntimeError
由於原始字典的大小發生了變化，因此如何繼續迭代是不明確的。因此，要避免這個問題，請始終在迭代中使用字典的副本
有時候我們希望在原字典的前提下建立一個只包含滿足特定條件的新字典
我們可以在遍歷原字典的時候加上條件判斷
>>> 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 字典中
還有另一種技術可以用來從字典中過濾 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}
或者通過計算字典的鍵與一組不需要的鍵之間的差分而獲得的鍵集構建一個新詞典
>>> non_citrus = {}
>>> for key in fruits.keys() - {"orange"}:
... non_citrus[key] = fruits[key]
...
>>> non_citrus
{'apple': 0.4, 'banana': 0.25}
在遍歷字典時，我們可以對字典的值進行計算
>>> 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
或者使用內建的 sum() 函數。把字典中的值作為引數直接傳遞給 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'}
需要注意的是，原始字典值中的資料必須是可雜湊資料型別
我們還可以將內建 zip() 函數與 dict() 建構函式一起使用
>>> dict(zip(numbers.values(), numbers.keys()))
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}
上面的範例中，通過 zip() 生成值鍵對的元組，然後，使用生成的元組作為引數並 dict() 構建所需的字典
與列表推導式不同，字典推導式需要一個對映到值的鍵
>>> 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 中，最終用於建立新的所需字典
更簡潔的方法如下：
>>> categories = ["color", "fruit", "pet"]
>>> objects = ["blue", "apple", "dog"]
>>> dict(zip(categories, objects))
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
zip() 函數從原始列表生成鍵值對，而 dict() 建構函式負責建立新字典