?? 信仰：一個人走得遠了，就會忘記自己為了什麼而出發，希望你可以不忘初心，不要隨波逐流，一直走下去
?? 歡迎關注??點贊??收藏??留言??
?? 本文由 原創，CSDN首發！
?? 系列專欄：Python學習
?? 首發時間：2022年5月12日
如果覺得博主的文章還不錯的話，希望小伙伴們三連支持一下哦
字典是 Python 組合數據類型的一種，它能夠將相關信息關聯起來。字典可存儲的信息量幾乎不受限制。在學完字典後，你就能夠更准確地為各種真實物體建模。你可以創建一個表示人的字典，然後想在其中存儲多少信息就存儲多少信息，比如姓名、年齡、地址、職業等等。你還能夠存儲任意兩種相關的信息，如一系列單詞及其含義，一系列人名及其專業，以及一系列山脈及其海拔等等。
首先，我們來看一個游戲，其中包含一些外星人，這些外星人的顏色和點數各不相同。下面是一個簡單的字典，存儲了有關特定外星人的信息：
alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color'])
print(alien_0['points'])
字典 alien_0 存儲了外星人的顏色和點數。使用兩條 print 語句來訪問並打印這些信息，如下所示：
green
5
與大多數編程概念一樣，要熟練使用字典，也需要一段時間的練習。使用字典一段時間後，你就會明白為何它們能夠高效地模擬現實世界中的情形。
在 Python 中，字典是一系列鍵-值對。每個鍵都與一個值相關聯，你可以使用鍵來訪問與之相關聯的值。與鍵相關聯的值可以是數字、字符串、列表乃至字典。事實上，可將任何 Python 對象用作字典中的值。
在 Python 中，字典用放在花括號 {} 中的一系列鍵-值對表示，如前面的示例所示：
alien_0 = {'color': 'green', 'points': 5}
鍵-值對是兩個相關聯的值。指定鍵時，Python 將返回與之相關聯的值。鍵和值之間用冒號分隔，而鍵—值對之間用逗號分隔。在字典中，你想存儲多少個鍵-值對都可以。
最簡單的字典只有一個鍵-值對，如下述修改後的字典 alien_0 所示：
alien_0 = {'color': 'green'}
這個字典只存儲了一項有關 alien_0 的信息，具體地說是這個外星人的顏色。在這個字典中，字符串 ‘color’ 是一個鍵，與之相關聯的值為 ‘green’。
要獲取與鍵相關聯的值，可依次指定字典名和放在方括號內的鍵，如下所示：
alien_0 = {'color': 'green'}
print(alien_0['color'])
這將返回字典 alien_0 中與鍵 ‘color’ 相關聯的值：green
字典中可包含任意數量的鍵-值對。例如，下面是最初的字典 alien_0，其中包含兩個鍵-值對：
alien_0 = {'color': 'green', 'points': 5}
現在，你可以訪問外星人 alien_0 的顏色和點數。如果玩家射殺了這個外星人，你就可以使用下面的代碼來確定玩家應獲得多少個點：
alien_0 = {'color': 'green', 'points': 5}
new_points = alien_0['points']
print("You just earned " + str(new_points) + " points!")
上述代碼首先定義了一個字典，然後從這個字典中獲取與鍵 ‘points’ 相關聯的值，並將這個值存儲在變量 new_points 中。接下來，將這個整數轉換為字符串，並打印一條消息，指出玩家獲得了多少個點：
You just earned 5 points!
如果你在有外星人被射殺時都運行這段代碼，就會獲取該外星人的點數。
字典是一種動態結構，可隨時在其中添加鍵-值對。要添加鍵-值對，可依次指定字典名、用方括號括起的鍵和相關聯的值。
下面在字典 alien_0 中添加兩項信息：外星人的 x 坐標和 y 坐標，讓我們能夠在屏幕的特定位置顯示該外星人。我們將這個外星人放在屏幕左邊緣，且離屏幕上邊緣 25 像素的地方。由於屏幕坐標系的原點通常為左上角，因此要將該外星人放在屏幕左邊緣，可將 x 坐標設置為 0；要將該外星人放在離屏幕頂部 25 像素的地方，可將 y 坐標設置為 25，如下所示：
alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
我們首先定義了前面一直在使用的字典，然後打印這個字典，以顯示其信息。然後，
我們在這個字典中新增了一個鍵-值對，其中的鍵為 ‘x_position’，而值為 0。接著，我們重復這樣的操作，但使用的鍵為 ‘y_position’。打印修改後的字典時，將看到這兩個新增的鍵-值對：
{‘color’: ‘green’, ‘points’: 5}
{‘color’: ‘green’, ‘points’: 5, ‘x_position’: 0, ‘y_position’: 25}
這個字典的最終版本包含 4 個鍵-值對，其中原來的兩個指定外星人的顏色和點數，而新增的兩個指定位置。注意，鍵-值對的排列順序與添加順序不同。Python 不關心鍵-值對的添加順序，而只關心鍵和值之間的關聯關系。
有時候，在空字典中添加鍵-值對是為了方便，而有時候必須這樣做。為此，可先使用一對空的花括號定義一個字典，再分行添加各個鍵-值對。例如，下例演示了如何以這種方式創建字典 alien_0：
alien_0 = {}
alien_0['color'] = 'green'
alien_0['points'] = 5
print(alien_0)
這裡首先定義了空字典 alien_0，再在其中添加顏色和點數，得到前述示例一直在使用的字典：
{‘color’: ‘green’, ‘points’: 5}
使用字典來存儲用戶提供的數據或在編寫能自動生成大量鍵-值對的代碼時，通常都需要先定義一個空字典。
要修改字典中的值，可依次指定字典名、用方括號括起的鍵以及與該鍵相關聯的新值。例如，假設隨著游戲的進行，需要將一個外星人從綠色改為黃色：
alien_0 = {'color': 'green'}
print("The alien is " + alien_0['color'] + ".")
alien_0['color'] = 'yellow'
print("The alien is now " + alien_0['color'] + ".")
我們首先定義了一個表示外星人 alien_0 的字典，其中只包含這個外星人的顏色。接下來，我們將與鍵 ‘color’ 相關聯的值改為 ‘yellow’。輸出表明，這個外星人確實從綠色變成了黃色：
The alien is green.
The alien is now yellow.
來看一個更有趣的例子：對一個能夠以不同速度移動的外星人的位置進行跟蹤。為此，我們將存儲該外星人的當前速度，並據此確定該外星人將向右移動多遠：
alien_0 = {'x_position': 0, 'y_position': 25, 'speed': 'medium'}
print("Original x-position: " + str(alien_0['x_position']))
# 向右移動外星人
# 據外星人當前速度決定將其移動多遠
if alien_0['speed'] == 'slow':
x_increment = 1
elif alien_0['speed'] == 'medium':
x_increment = 2
else:
x_increment = 3
# 新位置等於老位置加上增量
alien_0['x_position'] = alien_0['x_position'] + x_increment
print("New x-position: " + str(alien_0['x_position']))
首先我們定義了一個外星人，其中包含初始的 x 坐標和 y 坐標，還有速度 ‘medium’。出於簡化考慮，我們省略了顏色和點數，但即便包含這些鍵-值對，這個示例的工作原理也不會有任何變化。我們還打印了 x_position 的初始值，旨在讓用戶知道這個外星人向右移動了多遠。
然後，使用了一個 if-elif-else 結構來確定外星人應向右移動多遠，並將這個值存儲在變量 x_increment 中。如果外星人的速度為 ‘slow’，它將向右移動一個單位；如果速度為 ‘medium’，將向右移動兩個單位；如果為 ‘fast’，將向右移動三個單位。確定移動量後，將其與 x_position 的當前值相加，再將結果關聯到字典中的鍵 x_position。
由於這是一個速度中等的外星人，因此其位置將向右移動兩個單位：
Original x-position: 0
New x-position: 2
這種技術很棒：通過修改外星人字典中的值，可改變外星人的行為。例如，要將這個速度中等的外星人變成速度很快的外星人，可添加如下代碼行：
alien_0['speed'] = fast
這樣，再次運行這些代碼時，其中的 if-elif-else 結構將把一個更大的值賦給變量
x_increment。
對於字典中不再需要的信息，可使用 del 語句將相應的鍵-值對徹底刪除。使用 del 語句時，必須指定字典名和要刪除的鍵。
例如，下面的代碼從字典 alien_0 中刪除鍵 ‘points’ 及其值：
alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
del alien_0['points']
print(alien_0)
del alien_0[‘points’] 讓 Python 將鍵 ‘points’ 從字典 alien_0 中刪除，同時刪除與這個鍵相關聯的值。輸出表明，鍵 ‘points’ 及其值 5 已從字典中刪除，但其他鍵-值對未受影響：
{‘color’: ‘green’, ‘points’: 5}
{‘color’: ‘green’}
注意：刪除的鍵-值對永遠消失了。
在前面的示例中，字典存儲的是一個對象（游戲中的一個外星人）的多種信息，但你也可以使用字典來存儲眾多對象的同一種信息。例如，假設你要調查很多人，詢問他們最喜歡的編程語言，可使用一個字典來存儲這種簡單調查的結果，如下所示：
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
正如你看到的，我們將一個較大的字典放在了多行中。其中每個鍵都是一個被調查者的名字，而每個值都是被調查者喜歡的語言。確定需要使用多行來定義字典時，在輸入左花括號後按回車鍵，再在下一行縮進四個空格，指定第一個鍵-值對，並在它後面加上一個逗號。此後你再次按回車鍵時，文本編輯器將自動縮進後續鍵-值對，且縮進量與第一個鍵-值對相同。
定義好字典後，在最後一個鍵-值對的下一行添加一個右花括號，並縮進四個空格，使其與字典中的鍵對齊。另外一種不錯的做法是在最後一個鍵-值對後面也加上逗號，為以後在下一行添加鍵-值對做好准備。
注意：對於較長的列表和字典，大多數編輯器都有以類似方式設置其格式的功能。對於較長的字典，還有其他一些可行的格式設置方式，因此在你的編輯器或其他源代碼中，你可能會看到稍微不同的格式設置方式。
給定被調查者的名字，可使用這個字典輕松地獲悉他喜歡的語言：
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
print("Sarah's favorite language is " +
favorite_languages['sarah'].title() +
".")
為獲悉 Sarah 喜歡的語言，我們使用如下代碼：
favorite_languages['sarah']
在 print 語句中，我們使用了 favorite_languages[‘sarah’].title() 這種語法輸出了 Sarah 喜歡的語言：
Sarah’s favorite language is C.
這個示例還演示了如何將較長的 print 語句分成多行。單詞 print 比大多數字典名都短，因此讓輸出的第一部分緊跟在左括號後面是合理的。請選擇在合適的地方拆分要打印的內容，並在第一行末尾加上一個拼接運算符（+）。按回車鍵進入 print 語句的後續各行，並使用 Tab 鍵將它們對齊並縮進一級。指定要打印的所有內容後，在 print 語句的最後一行末尾加上右括號。
一個 Python 字典可能只包含幾個鍵-值對，也可能包含數百萬個鍵-值對。鑒於字典可能包含大量的數據，Python 支持對字典遍歷。字典可用於以各種方式存儲信息，因此有多種遍歷字典的方式：可遍歷字典的所有鍵-值對、鍵或值。
探索各種遍歷方法前，先來看一個新字典，它用於存儲有關網站用戶的信息。下面的字典存儲一名用戶的用戶名、名和姓：
user_0 = {
'username': 'efermi',
'first': 'enrico',
'last': 'fermi',
}
利用前面介紹過的知識，可訪問 user_0 的任何一項信息，但如果要獲悉該用戶字典中的所有信息，該怎麼辦呢？
我們可以使用一個 for 循環來遍歷這個字典：
user_0 = {
'username': 'efermi',
'first': 'enrico',
'last': 'fermi',
}
for key, value in user_0.items():
print("
Key: " + key)
print("Value: " + value)
我們要編寫用於遍歷字典的 for 循環，可聲明兩個變量，用於存儲鍵-值對中的鍵和值。對於這兩個變量，可使用任何名稱。下面的代碼使用了簡單的變量名，這完全可行：
for k, v in user_0.items()
for 語句的第二部分包含字典名和方法 items()，它返回一個鍵-值對列表。接下來，for 循環依次將每個鍵-值對存儲到指定的兩個變量中。在前面的示例中，我們使用這兩個變量來打印每個鍵及其相關聯的值。第一條 print 語句中的 “ ” 確保在輸出每個鍵-值對前都插入一個空行：
Key: username
Value: efermiKey: first
Value: enricoKey: last
Value: fermi
注意，即便遍歷字典時，鍵-值對的返回順序也與存儲順序不同。Python 不關心鍵-值對的存儲順序，而只跟蹤鍵和值之間的關聯關系。
在前面的例子 favorite_languages 中，字典存儲的是不同人的同一種信息；對於類似這
樣的字典，遍歷所有的鍵-值對很合適。如果遍歷字典 favorite_languages，將得到其中每個人的姓名和喜歡的編程語言。由於其中的鍵都是人名，而值都是語言，因此我們在循環中使用變量 name 和 language，而不是 key 和 value，這讓人更容易明白循環的作用：
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
for name, language in favorite_languages.items():
print(name.title() + "'s favorite language is " +
language.title() + ".")
上述代碼中 for 循環讓 Python 遍歷字典中的每個鍵—值對，並將鍵存儲在變量 name 中，而將值存儲在變量 language 中。這些描述性名稱能夠讓人非常輕松地明白 print 語句是做什麼的。
僅使用幾行代碼，我們就將全部調查結果顯示出來了：
Jen’s favorite language is Python.
Sarah’s favorite language is C.
Phil’s favorite language is Python.
Edward’s favorite language is Ruby.
即便字典存儲的是上千乃至上百萬人的調查結果，這種循環也管用。
在不需要使用字典中的值時，方法 keys() 很有用。下面來遍歷字典 favorite_languages，並將每個被調查者的名字都打印出來：
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
for name in favorite_languages.keys():
print(name.title())
上述代碼中 for 循環讓 Python 提取字典 favorite_languages 中的所有鍵，並依次將它們存儲到變量 name 中。輸出了每個被調查者的名字：
Jen
Sarah
Phil
Edward
遍歷字典時，會默認遍歷所有的鍵，因此，如果將上述代碼中的 for name in favorite_
languages.keys(): 替換為 for name in favorite_languages:，輸出將不變。
如果顯式地使用方法 keys() 可讓代碼更容易理解，你可以選擇這樣做，但如果你願意，也可省略它。
在這種循環中，可使用當前鍵來訪問與之相關聯的值。下面來打印兩條消息，指出兩位朋友喜歡的語言。我們像前面一樣遍歷字典中的名字，但在名字為指定朋友的名字時，打印一條消息，指出其喜歡的語言：
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
friends = ['phil', 'sarah']
for name in favorite_languages.keys():
print(name.title())
if name in friends:
print(" Hi " + name.title() +
", I see your favorite language is " +
favorite_languages[name].title() + "!")
上述代碼中，我們創建了一個列表，其中包含我們要通過打印消息，指出其喜歡的語言的朋友。在循環中，我們打印每個人的名字，並檢查當前的名字是否在列表 friends 中。如果在列表中，就打印一句特殊的問候語，其中包含這位朋友喜歡的語言。為訪問喜歡的語言，我們使用了字典名，並將變量 name 的當前值作為鍵。每個人的名字都會被打印，但只對朋友打印特殊消息：
Jen
Sarah
Hi Sarah, I see your favorite language is C!
Edward
Phil
Hi Phil, I see your favorite language is Python!
你還可以使用 keys() 確定某個人是否接受了調查。下面的代碼確定 Erin 是否接受了調查：
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
if 'erin' not in favorite_languages.keys():
print("Erin, please take our poll!")
方法 keys() 並非只能用於遍歷；實際上，它返回一個列表，其中包含字典中的所有鍵，因此，代碼中的 if 語句只是核實 ‘erin’ 是否包含在這個列表中。由於 ‘erin’ 並不包含在這個列表中，因此打印一條消息，邀請她參加調查：
Erin, please take our poll!
字典總是明確地記錄鍵和值之間的關聯關系，但獲取字典的元素時，獲取順序是不可預測的。這不是問題，因為通常你想要的只是獲取與鍵相關聯的正確的值。
要以特定的順序返回元素，一種辦法是在 for 循環中對返回的鍵進行排序。為此，可使用函數 sorted() 來獲得按特定順序排列的鍵列表的副本：
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
for name in sorted(favorite_languages.keys()):
print(name.title() + ", thank you for taking the poll.")
這條 for 語句類似於其他 for 語句，但對方法 dictionary.keys() 的結果調用了函數 sorted()。這讓 Python 列出字典中的所有鍵，並在遍歷前對這個列表進行排序。輸出表明，按順序顯示了所有被調查者的名字：
Edward, thank you for taking the poll.
Jen, thank you for taking the poll.
Phil, thank you for taking the poll.
Sarah, thank you for taking the poll.
如果你感興趣的主要是字典包含的值，可使用方法 values()，它返回一個值列表，而不包含任何鍵。例如，如果我們想獲得一個這樣的列表，即其中只包含被調查者選擇的各種語言，而不包含被調查者的名字，可以這樣做：
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
print("The following languages have been mentioned:")
for language in favorite_languages.values():
print(language.title())
這條 for 語句提取字典中的每個值，並將它們依次存儲到變量 language 中。通過打印這些值，就獲得了一個列表，其中包含被調查者選擇的各種語言：
The following languages have been mentioned:
Python
C
Ruby
Python
這種做法提取字典中所有的值，而沒有考慮是否重復。涉及的值很少時，這也許不是問題，但如果被調查者很多，最終的列表可能包含大量的重復項。為剔除重復項，可使用集合（set）。
集合類似於列表，但每個元素都必須是獨一無二的：
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
print("The following languages have been mentioned:")
for language in set(favorite_languages.values()):
print(language.title())
通過對包含重復元素的列表調用 set()，可讓 Python 找出列表中獨一無二的元素，並使用這些元素來創建一個集合。在上述代碼中，我們使用了 set() 來提取 favorite_languages.values() 中不同的語言。
結果是一個不重復的列表，其中列出了被調查者提及的所有語言：
The following languages have been mentioned:
Ruby
Python
C
隨著你更深入地學習 Python，經常會發現它內置的功能可幫助你以希望的方式處理數據。
有時候，需要將一系列字典存儲在列表中，或將列表作為值存儲在字典中，這稱為嵌套。你可以在列表中嵌套字典、在字典中嵌套列表甚至在字典中嵌套字典。正如下面的示例將演示的，嵌套是一項強大的功能。
字典 alien_0 包含一個外星人的各種信息，但無法存儲第二個外星人的信息，更別說屏幕上全部外星人的信息了。如何管理成群結隊的外星人呢？一種辦法是創建一個外星人列表，其中每個外星人都是一個字典，包含有關該外星人的各種信息。例如，下面的代碼創建一個包含三個外星人的列表：
alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
aliens = [alien_0, alien_1, alien_2]
for alien in aliens:
print(alien)
我們首先創建了三個字典，其中每個字典都表示一個外星人。接著我們將這些字典都放到一個名為 aliens 的列表中。最後，我們遍歷這個列表，並將每個外星人都打印出來：
{‘color’: ‘green’, ‘points’: 5}
{‘color’: ‘yellow’, ‘points’: 10}
{‘color’: ‘red’, ‘points’: 15}
更符合現實的情形是，外星人不止三個，且每個外星人都是使用代碼自動生成的。在下面的示例中，我們使用 range() 生成了 30 個外星人：
aliens = [] # 創建一個用於存儲外星人的空列表
# 創建30個綠色的外星人
for alien_number in range(30):
new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
aliens.append(new_alien) #把外星人添加到列表裡
# 顯示前五個外星人
for alien in aliens[:5]:
print(alien)
print("...")
# 顯示創建了多少個外星人
print("Total number of aliens: " + str(len(aliens)))
在這個示例中，首先創建了一個空列表，用於存儲接下來將創建的所有外星人。接著，
我們使用 range() 返回一系列數字，其唯一的用途是告訴 Python 我們要重復這個循環多少次。每次執行這個循環時，都創建一個外星人，並將其附加到列表 aliens 末尾。然後，我們使用一個切片來打印前五個外星人。最後，打印列表的長度，以證明確實創建了 30 個外星人：
{‘color’: ‘green’, ‘points’: 5, ‘speed’: ‘slow’}
{‘color’: ‘green’, ‘points’: 5, ‘speed’: ‘slow’}
{‘color’: ‘green’, ‘points’: 5, ‘speed’: ‘slow’}
{‘color’: ‘green’, ‘points’: 5, ‘speed’: ‘slow’}
{‘color’: ‘green’, ‘points’: 5, ‘speed’: ‘slow’}
…
Total number of aliens: 30
這些外星人都具有相同的特征，但在 Python 看來，每個外星人都是獨立的，這讓我們能夠獨立地修改每個外星人。
在什麼情況下需要處理成群結隊的外星人呢？想象一下，可能隨著游戲的進行，有些外星人會變色且移動速度會加快。必要時，我們可以使用 for 循環和 if 語句來修改某些外星人的顏色。
例如，要將前三個外星人修改為黃色的、速度為中等且值 10 個點，可以這樣做：
# 創建一個用於存儲外星人的空列表
aliens = []
# 創建30個綠色的外星人
for alien_number in range(0, 30):
new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
aliens.append(new_alien)
# 修改前3個外星人
for alien in aliens[0:3]:
if alien['color'] == 'green':
alien['color'] = 'yellow'
alien['speed'] = 'medium'
alien['points'] = 10
# 顯示前5個外星人
for alien in aliens[0:5]:
print(alien)
print("...")
鑒於我們要修改前三個外星人，需要遍歷一個只包含這些外星人的切片。當前，所有外星人都是綠色的，但情況並非總是如此，因此我們編寫了一條 if 語句來確保只修改綠色外星人。如果外星人是綠色的，我們就將其顏色改為 ‘yellow’，將其速度改為 ‘medium’，並將其點數改為 10，如下面的輸出所示：
{‘color’: ‘yellow’, ‘points’: 10, ‘speed’: ‘medium’}
{‘color’: ‘yellow’, ‘points’: 10, ‘speed’: ‘medium’}
{‘color’: ‘yellow’, ‘points’: 10, ‘speed’: ‘medium’}
{‘color’: ‘green’, ‘points’: 5, ‘speed’: ‘slow’}
{‘color’: ‘green’, ‘points’: 5, ‘speed’: ‘slow’}
…
你可以進一步擴展這個循環，在其中添加一個 elif 代碼塊，將黃色外星人改為移動速度快且值 15 個點的紅色外星人，如下所示（這裡只列出了循環，而沒有列出整個程序）：
for alien in aliens[0:3]:
if alien['color'] == 'green':
alien['color'] = 'yellow'
alien['speed'] = 'medium'
alien['points'] = 10
elif alien['color'] == 'yellow':
alien['color'] = 'red'
alien['speed'] = 'fast'
alien['points'] = 15
經常需要在列表中包含大量的字典，而其中每個字典都包含特定對象的眾多信息。例如，你可能需要為網站的每個用戶創建一個字典，並將這些字典存儲在一個名為 users 的列表中。在這個列表中，所有字典的結構都相同，因此你可以遍歷這個列表，並以相同的方式處理其中的每個字典。
有時候，需要將列表存儲在字典中，而不是將字典存儲在列表中。例如，你如何描述顧客點的比薩呢？如果使用列表，只能存儲要添加的比薩配料；但如果使用字典，就不僅可在其中包含配料列表，還可包含其他有關比薩的描述。
在下面的示例中，存儲了比薩的兩方面信息：外皮類型和配料列表。其中的配料列表是一個與鍵 ‘toppings’ 相關聯的值。要訪問該列表，我們使用字典名和鍵 ‘toppings’，就像訪問字典中的其他值一樣。這將返回一個配料列表，而不是單個值：
# 存儲所點比薩的信息
pizza = {
'crust': 'thick',
'toppings': ['mushrooms', 'extra cheese'],
}
# 概述所點的比薩
print("You ordered a " + pizza['crust'] + "-crust pizza " +
"with the following toppings:")
for topping in pizza['toppings']:
print(" " + topping)
我們首先創建了一個字典，其中存儲了有關顧客所點比薩的信息。在這個字典中，
一個鍵是 ‘crust’，與之相關聯的值是字符串 ‘thick’；下一個鍵是 ‘toppings’，與之相關聯的值是一個列表，其中存儲了顧客要求添加的所有配料。制作前我們概述了顧客所點的比薩。為打印配料，我們編寫了一個 for 循環。為訪問配料列表，我們使用了鍵 ‘toppings’，這樣 Python 將從字典中提取配料列表。
下面的輸出概述了要制作的比薩：
You ordered a thick-crust pizza with the following toppings:
mushrooms
extra cheese
每當需要在字典中將一個鍵關聯到多個值時，都可以在字典中嵌套一個列表。在前面有關喜歡的編程語言的示例中，如果將每個人的回答都存儲在一個列表中，被調查者就可選擇多種喜歡的語言。在這種情況下，當我們遍歷字典時，與每個被調查者相關聯的都是一個語言列表，而不是一種語言；因此，在遍歷該字典的 for 循環中，我們需要再使用一個 for 循環來遍歷與被調查者相關聯的語言列表：
favorite_languages = {
'jen': ['python', 'ruby'],
'sarah': ['c'],
'edward': ['ruby', 'go'],
'phil': ['python', 'haskell'],
}
for name, languages in favorite_languages.items():
print("
" + name.title() + "'s favorite languages are:")
for language in languages:
print(" " + language.title())
正如你看到的，現在與每個名字相關聯的值都是一個列表。請注意，有些人喜歡的語言只有一種，而有些人有多種。遍歷字典時，我們使用了變量 languages 來依次存儲字
典中的每個值，因為我們知道這些值都是列表。在遍歷字典的主循環中，我們又使用了一個 for 循環來遍歷每個人喜歡的語言列表。現在，每個人想列出多少種喜歡的語言都可以：
**
Jen’s favorite languages are:
Python
RubySarah’s favorite languages are:
CEdward’s favorite languages are:
Ruby
GoPhil’s favorite languages are:
Python
Haskell**
為進一步改進這個程序，可在遍歷字典的 for 循環開頭添加一條 if 語句，通過查看 len(languages) 的值來確定當前的被調查者喜歡的語言是否有多種。如果他喜歡的語言有多種，就像以前一樣顯示輸出；如果只有一種，就相應修改輸出的措辭，如顯示 Sarah’s favorite language is C。
注意：列表和字典的嵌套層級不應太多。如果嵌套層級比前面的示例多得多，很可能有更簡單的解決問題的方案。
可在字典中嵌套字典，但這樣做時，代碼可能很快復雜起來。例如，如果有多個網站用戶，每個都有獨特的用戶名，可在字典中將用戶名作為鍵，然後將每位用戶的信息存儲在一個字典中，並將該字典作為與用戶名相關聯的值。在下面的程序中，對於每位用戶，我們都存儲了其三項信息：名、姓和居住地；為訪問這些信息，我們遍歷所有的用戶名，並訪問與每個用戶名相關聯的信息字典：
users = {
'aeinstein': {
'first': 'albert',
'last': 'einstein',
'location': 'princeton',
},
'mcurie': {
'first': 'marie',
'last': 'curie',
'location': 'paris',
},
}
for username, user_info in users.items():
print("
Username: " + username)
full_name = user_info['first'] + " " + user_info['last']
location = user_info['location']
print(" Full name: " + full_name.title())
print(" Location: " + location.title())
我們首先定義了一個名為 users 的字典，其中包含兩個鍵：用戶名 ‘aeinstein’ 和 ‘mcurie’；與每個鍵相關聯的值都是一個字典，其中包含用戶的名、姓和居住地。在處，我們遍歷字典 users，讓 Python 依次將每個鍵存儲在變量 username 中，並依次將與當前鍵相關聯的字典存儲在變量 user_info 中。在主循環內部，我們將用戶名打印出來。
在 for 循環中，我們訪問內部的字典。變量 user_info 包含用戶信息字典，而該字典包含三個鍵：‘first’、‘last’ 和 ‘location’；對於每位用戶，我們都使用這些鍵來生成整潔的姓名和居住地，然後打印有關用戶的簡要信息：
**
Username: aeinstein
Full name: Albert Einstein
Location: PrincetonUsername: mcurie
Full name: Marie Curie
Location: Paris**
請注意，表示每位用戶的字典的結構都相同，雖然 Python 並沒有這樣的要求，但這使得嵌套的字典處理起來更容易。倘若表示每位用戶的字典都包含不同的鍵，for 循環內部的代碼將更復雜。
本文介紹了：如何定義字典，以及如何使用存儲在字典中的信息；如何訪問和修改字典中的元素，以及如何遍歷字典中的所有信息；如何遍歷字典中所有的鍵-值對、所有的鍵和所有的值；如何在列表中嵌套字典、在字典中嵌套列表以及在字典中嵌套字典。這些都是基礎，為我們後面寫出美妙的代碼做鋪墊，一起加油吧
??這次的分享就到這裡啦
??有出錯的地方歡迎在評論區指出來，共同進步，謝謝啦
