在本章中，我們將學習能夠將相關信息關聯起來的Python字典。我們將學習如何訪問和修改字典中的信息。鑒於字典可存儲的信息幾乎是不受限制，因此我們會演示如何遍歷字典中的數據。另外，我們還將學習存儲字典的列表、存儲列表的字典和存儲字典的字典。
理解字典后，我們就能夠更准確地為各種真是物體建模。我們可以創建一個表示人的字典，然后想在其中存儲多少信息就存儲多少信息：姓名、年齡、地址、職業以及要描述的任何方面。我們還能夠存儲任意兩種相關的信息，如一系列單詞及其含義，一系列人名及其喜歡的數字，以及一系列山脈及其海拔等。
6.1 一個簡單的字典
來看一個游戲，其中包含一些外星人，這些外星人的顏色和點數各不相同。下面是一個簡單的字典，存儲了有關特性外星人的消息：
alien.py]
alien_0 = {"color":"green","points":5}
print(alien_0["color"])
print(alien_0["points"])
字典alien_0存儲了外星人的顏色和點數。使用兩條print語句來訪問並打印這些信息，如下所示：
green
5
與大多數編程概念一樣，要熟練使用字典，也需要一段時間的練習。使用字典一段時間后，我們就會明白為何它們能夠高效地模擬現實世界中的情形。
剛接觸字典的時候也是很不習慣，其實字典主要包含鍵值對，鍵——值組成一個搭配，有鍵就有對應的值，鍵對應一個值，但是值可以是各種形式的，值可以是字典，也可以是元組，也可以是列表，但是鍵卻是唯一的，所以在使用的時候只要抓住字典的實質，就能輕松應對，當然最主要的還是要自己多加練習對字典的使用，才能游刃有余。
6.2 使用字典
在Python中，字典是一系列鍵——值對。每個鍵都與一個值相關聯，我們可以使用鍵來訪問與之相關聯的值。與鍵相關聯的值可以是數字、字符串、列表乃至字典。事實上，可將任何Python對象用作字典中的值。
在Python中，字典用放在花括號{}中的一系列鍵—值對表示，如前面的示例所示：
alien_0 = {'color':'green','points':5}
鍵—值對是兩個相關聯的值。指定鍵時，Python將返回與之相關聯的值。鍵和值之間用冒號分隔，而鍵—值對之間用逗號分隔。在字典中，我們想存儲多少個鍵-值對都可以。
6.2.1 訪問字典中的值
要獲取與鍵相關聯的值，可依次指定字典名和放在方括號內的鍵，如下所示：
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.
如果你在有外星人被射殺時都運行這段代碼，就會獲取該外星人的點數。
6.2.2 添加鍵-值對
字典是一種動態結構，可隨時在其中添加鍵-值對。要添加鍵-值對，可依次制定字典名、用方括號括起的鍵和相關聯的值。
下面在字典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_positi-
on',而值為0.我們重復這樣的操作，但使用的鍵為'y_position'。打印修改后的字典時，將看到這兩個新增的鍵-值對：
{'color': 'green', 'points': 5}
{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}
這個字典的最終版本包含四個鍵-值對，其中原來的兩個指定外星人的顏色和點數，而新增的兩個指定位置。注意，鍵-值對的排列順序與添加順序不同。
Python不關心鍵-值對的添加順序，而只關心鍵和值之間的關聯關系。
6.2.3 先創建一個空的字典
有時候，在字典中添加鍵-值對是為了方便，而有時候必須這樣做。為此，可先使用一對空的花括號定義一個字典，在分行添加各個鍵-值對。例如，下例演
示了如何以這種方式創建字典alien_0：
alien_0 = {}
alien_0['color'] = "green"
alien_0["points"] = 5
print(alien_0)
這里首先定義了空字典alien_0，再在其中添加顏色和點數，得到前述示例一直在使用的字典：
{'color':'green','points':5}
使用字典來存儲用戶提供的數據或在編寫能自動生成大量鍵-值對的代碼時，通常都需要先定義一個空字典。
6.2.4 修改字典中的值
要修改字典中的值，可依次指定字典名、用方括號括起的鍵以及與該鍵相關聯的新值。例如，假設隨着游戲的運行，需要將一個外星人從綠色改為黃色：
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("Origianl x_position: " + str(alien_0['x_position']))
#向右移動外星人
#根據當前外星人的速度決定將其移動多遠
(1) if alien_0['speed'] == 'slow':
x_increment = 1
elif alien_0['speed'] == 'medium':
x_increment = 2
elif alien_0['speed'] == 'fast':
x_increment = 3
#新位置等於老位置加上增量
(2) alien_0['x_position'] = alien_0['x_position'] + x_increment
print("New x_position: " + str(alien_0['x_position']))
我們首先定義了一個外星人，其中包含初始的x坐標和y坐標，還有速度'medium'.出於簡化考慮，我們省略了顏色和點數，但即便包含這些鍵-值對，這個
示例的工作原理也不會有任何變化。我們還打印了x_position的初始值，旨在讓用戶知道這個外星人想右移動多遠。
在(1)處，使用了一個if-elif-else結構來確定外星人應向右移動多遠，並將這個值存儲在變量x_increment中。如果外星人的速度為'slow'，它將向右
移動一個單位；如果速度為'medium'，將向右移動兩個單位；如果為'fast'，將向右移動三個單位。確定移動量后，將其與x_position的當前值相加，再將
結果關聯到字典中的鍵x_position.
由於這是一個速度中等的外星人，因此其位置將向右移動兩個單位：
Origianl x_position: 0
New x_position: 2
這種技術很棒：通過修改外星人字典中的值，可改變外星人的行為。例如，要將這個速度中等的外星人變成速度很快的外星人，可添加如下代碼行：
alien_0['speed'] = 'fast'
這樣，再次運行這些代碼時，其中的if-elif-else結構將把一個更大的值符給變量x_increment。
6.2.5 刪除鍵-值對
對於字典中不再需要的信息，可使用del語句將相應的鍵-值對徹底刪除。使用del語句時，必須指定字典名和要刪除的鍵。
例如，下面的代碼從字典alien_0中刪除鍵'points'及其值：
alien_0 = {'color':'green','points':5}
print(alien_0)
del alien_0['points']
print(alien_0)
del處的代碼行讓Python將鍵'points'從字典alien_0中刪除，同時刪除與這個鍵相關聯的值。輸出表明，鍵'points'及其值5已從字典中刪除，但其他鍵
-值對未受影響：
{'points': 5, 'color': 'green'}
{'color': 'green'}
6.2.6 由類似對象組成的字典
在前面的示例中，字典存儲的是一個對象（游戲中的一個外星人）的多種信息，但我們也可以使用字典來存儲眾多對象的同一種信息。例如，假設你需要
調查很多人，詢問他們最喜歡的編程語言，可使用一個字典來存儲這種簡單調查的結果，如下所示：
favorite_languages = {'jen':'python',
'sarah':"C",
'edward':'ruby',
'phil':'python'
}
正如我們看到的，我們將一個較大的字典放在了多行中。其中每個鍵都是一個被調查者的名字，而每個值都是被調查者喜歡的語言。確定需要使用多行來定
義字典時，在輸入左花括號后按回車鍵，再在下一行縮進四個空格，指定第一個鍵-值對，並在它后面加上一個逗號。此后我們再次按回車鍵時，文本編輯器將
自動縮進后續鍵-值對，且縮進量與第一個鍵-值對相同。
定義好字典后，在最后一個鍵-值對的下一行添加一個右花括號，並縮進四個空格，使其與字典中的鍵對齊。另外一種不錯的做法是在最后一個鍵-值對后面
也加上逗號，為以后在下一行添加鍵-值對做好准備。
favorite_languages.py
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語句中，我們使用了這種語法；輸出指出了Sarah喜歡的語言：
Sarah's favorite language is C.
這個示例還演示了如何將較長的print語句分成多行。單詞print比大多數字典名都短，因此讓輸出的第一部分緊跟在左括號后面是合理的。請選擇在合適
的地方拆分要打印的內容，並在第一行末尾加上一個拼接運算符（+）。按回車鍵進入print語句的后續各行，並使用Tab鍵將它們對齊並縮進一級。指定要打印
的所有內容后，在print語句的最后一行末尾加上右括號。
動手試一試
6-1 人：使用一個字典來存儲一個熟人的信息，包括名、姓、年齡和居住的城市。該字典應包含鍵first_name、last_name、age和city。將存儲在該字典中的
每項信息都打印出來。
my_wife = {}
my_wife['frist_name'] = 'Zeng'
my_wife["last_name"] = "Mingzhu"
my_wife["age"] = 18
my_wife["city"] = 'ChangSha'
print(my_wife)
運行結果如下：
{'frist_name': 'Zeng', 'age': 18, 'city': 'ChangSha', 'last_name': 'Mingzhu'}
每個人運行結果的順序可能不一樣，從中也看出來字典的一個屬性，就是字典是無需的，沒有固定的順序可言。
6-2 喜歡的數字：使用一個字典來存儲一個些人喜歡的數字。請想出5個人的名字，並將這些名字用作字典中的鍵；想出每個人喜歡的一個數字，並將這些數
字作為值存儲在字典中。打印每個人的名字和喜歡的數字。為讓這個程序更有趣，通過詢問朋友確保數據是真實的。
lucky_nums = {"Zengmingzhu":3,
"Gengchangxue":8,
"Gaozidong":6,
"limei":7,
"liuxs":9
}
#由於字典包含鍵和值，鍵對應值，所以遍歷字典的時候肯定是對鍵個值同時進行操作
#只有同時操作才能得到結果
print("Zengmingzhu's lucky number: " + str(lucky_nums["Zengmingzhu"]))
print("Gengchangxue's lucky number: " + str(lucky_nums["Gengchangxue"]))
print("Gaozidong's lucky number: " + str(lucky_nums["Gaozidong"]))
print("Limei's lucky number: " + str(lucky_nums['limei']))
print("Liuxs's lucky number: " + str(lucky_nums['liuxs']))
6-3 詞匯表：Python字典可用於模擬現實生活中的字典，但為避免混淆，我們將后者稱為詞匯表
countries = {'China':"China was founded in 1949.","America":'The United States was founded in 1776'}
print("China: \n" + countries['China'] )
print('\nAmerica: \n' + countries['America'])
運行結果如下：
China:
China was founded in 1949.
America:
The United States was founded in 1776
6.3 遍歷字典
一個Python字典可能只包含幾個鍵-值對，也可能包含數百個鍵-值對。鑒於字典可能包含大量的數據，Python支持對字典遍歷。字典可用於以各種方式存
儲信息，因此有多種遍歷字典的方式：可遍歷字典中的所有鍵-值對、鍵或值。
6.3.1 遍歷所有的鍵-值對
探索各種遍歷方法前，先來看一個新字典，它用於存儲有關網站用戶的信息。下面的字典存儲一名用戶的用戶名、名和姓：
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('\nkey: '+ key)
print('value: ' + value)
如上所示，要編寫用於遍歷字典的for循環，可聲明兩個變量，用於存儲鍵-值對列表中的鍵和值。對於這兩個列表可以使用任何名稱。下面的代碼使用了
簡單的變量名，這完全可行：
for k,v in user_0.items()
for語句的第二部分包含字典名和方法items()，它返回一個鍵-值對列表。接下來，for循環一次將每個鍵-值對存儲到指定的兩個變量中。在前面的實例中
，我們使用這兩個變量來打印每個鍵及其相關聯的值。第一條print語句中的'\n'確保在輸出每個鍵-值對前都插入一個空行：
key: first
value: enrico
key: username
value: efermi
key: last
value: fermi
注意，即便遍歷字典時，鍵-值對的返回順序也與存儲順序不同。Python不關系鍵-值對的存儲順序，而只跟蹤鍵和值之間的關聯關系。也說明了字典是無序
的，沒有順序之分，不能向列表那樣L[0]調用元素。
在6.2.6節示例favorite_languages.py中，字典存儲的是不同人的同一種信息；對於類似這樣的字典，遍歷所有鍵-值對很合適。如果遍歷字典favorite
_languages,將得到其中每個人的姓名和喜歡的編程語言。由於其中的鍵都是人名，而值都是語言，因此我們在循環中可以使用變量name和language，而不是
key和value，這讓人更容易明白循環的作用：
favorite_languages = {'jen':'python',
'sarah':"C",
'edward':'ruby',
'phil':'python'
}
for name,language in favorite_languages.items():
print('\nname: ' + name)
print('language: ' + language)
上述代碼讓Python遍歷字典中的每個鍵-值對，並將鍵存儲在變量name中，而將值存儲在變量language中。這些描述性名稱能夠讓人非常輕松地明白print
語句是做什么的。
name: sarah
language: C
name: jen
language: python
name: phil
language: python
name: edward
language: ruby
即便字典存儲的是上千乃至百萬人的調查結果，這種循環也管用。
6.3.2 遍歷字典中的所有鍵
在不需要使用字典中的值時，方法keys()很有用。下面來遍歷字典favorite_languages,並將每個被調查者的名字都打印出來：
favorite_languages = {'jen':'python',
'sarah':"C",
'edward':'ruby',
'phil':'python'
}
for name in favorite_languages.keys():
print(name.title())
上述代碼讓Python提取字典favorite_languages中的所有鍵，並依次將它們存儲到變量name中。輸出列出了每個被調查者的名字：
Edward
Sarah
Phil
Jen
遍歷字典時，會默認遍歷所有的鍵，因此，如果將上述代碼中的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的當前值
作為鍵。每個人的名字都會被打印，但只對朋友打印特殊消息：
Sarah
Hi Sarah, I see your favorite language is C.
Phil
Hi Phil, I see your favorite language is Python.
Edward
Jen
方法keys()並非只能用於遍歷；實際上，它返回一個列表，其中包含字典中所有鍵，因此代只是核實'erin'是否包含在這個列表中。由於她並不包含在這
個列表中，因此打印一條消息，邀請她參加調查。
6.3.3 按順序遍歷字典中的所有值
字典總是明確地記錄鍵和值之間的關聯關系，但獲取字典的元素時，獲取順序是不可預測的。這不是問題，因為通常我們想要的只是獲取與鍵相關聯的正確
的值。要以特定的順序返回元素，一種辦法是在for循環中對返回的鍵進行排序。為此，可使用函數sorted()來獲得按特定順序排列的鍵列表的副本：
favorite_languages = {'jen':'python',
'sarah':"C",
'edward':'ruby',
'phil':'python'
}
friends = ['phil','sarah']
for name in sorted(favorite_languages.keys()):
print(name.title() + ', thank you for taking the poll.')
這條for語句類似於其他for語句，但對方法dictionaries.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.
6.3.4 遍歷字典中的所有值
如果我們感興趣的主要是字典中包含的值，可使用方法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)
這條for語句提取字典中的每個值，並將它們依次存儲到變量language中。通過打印這些值，就獲得了一個列表，其中包含被調查者選擇的各種語言：
The following languages have been mentioned:
python
C
python
ruby
這種做法提取字典中所有的值，而沒有考慮是否重復。涉及的值很少時，這也許不是問題，但如果被調查者很多，最終的列表可能包含大量的重復項。為
剔除重復項，可使用集合(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)
通過對包含重復元素的列表調用set(),可讓Python找出列表中獨一無二的元素，並使用這些元素來創建一個集合。上述代碼中，我們使用了集合set()來提
取favorite_languages.values()中不同的語言。
結果是一個不重復的列表，其中列出了被調查者提及的所有語言：
The following languages have been mentioned:
python
ruby
C
隨着我們更深入地學習Python，經常會發現它內置的功能可幫助我們以希望的方式處理數據。
6.4 嵌套
有時候，需要將一系列字典存儲在列表中，或將列表作為值存儲在字典中，這稱為嵌套。我們可以在列表中嵌套字典、在字典中嵌套列表甚至在字典中嵌套
字典。正如下面的示例將演示的，嵌套是一項強大的功能。
6.4.1 字典列表
字典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[0:5]:
print(alien)
print("......")
#顯示創建了多少個外星人
print("Total number of aliens: " + str(len(aliens)))
這些外星人都具有相同的特征，但在Python看來，每個外星人都是獨立的，這讓我們能夠獨立地修改每個外星人。
在什么情況下需要處理這些外星人呢？想象一下，可能隨着游戲的進行，有些外星人會變色且移動速度會加快。必要時，我們可以使用for循環和if語句來
修改某些外星人的顏色。例如，要將前三個外星人修改為黃色的、速度為中等且值為10個點，可以這樣做：
#創建一個用於存儲外星人的空列表
aliens = []
#使用for循環創建30個相同屬性的外星人
for alien_num in range(30):
#for循環的主要目的是讓程序循環30次，每次向列表中添加外星人
new_alien = {'color':'green','points':5,'speed':'slow'}
aliens.append(new_alien)
#使用切片調用前三個元素，並且修改字典的屬性，由於列表中存儲的是字典
for alien in aliens[0:3]:
if alien['color'] == 'green':
alien['color'] = 'yellow'
alien['points'] = 10
alien['speed'] = 'medium'
#顯示前5個外星人
for alien_0 in aliens[0:5]:
print(alien_0)
經常需要在列表中包含大量的字典，而其中每個字典都包含特定對象的眾多信息。例如，我們可能需要為網站的每個用戶創建一個字典，並將這些字典存儲
在一個名為users的里誒保重。在這個列表中，所有字典的結構都相同，因此我們可以遍歷這個列表，並以相同的方式處理其中的每個字典。
6.4.2 在字典中存儲列表
有時候，需要將列表存儲在字典中，而不是將字典存儲在列表中。例如，我們如何描述顧客點的比薩呢？如果使用列表，只能存儲要添加的比薩配料；但如
果使用字典，就不僅可以在其中包含配料列表，還可包含其他有關披薩的描述。
在下面的示例中，存儲了比薩的兩方面信息：外皮類型和配料列表。其中的配料列表是一個與鍵'toppings'相關聯的值。要訪問該列表，我們使用字典名
和鍵'toppings'，就像訪問字典中其他的值一樣。這將返回一個列表，而不是單個值：
#存儲所點比薩的信息
pizza = {'crust':'thick','toppings':['mushrooms','extra cheese']}
#概述所點的比薩
print("Yor ordered a " + pizza['crust'] + '-crust pizza' + 'with the following toppings: ')
for topping in pizza["toppings"]:
print(topping)
我們首先創建了一個字典，其中存儲了有關顧客所點比薩的信息。在這個字典中，一個鍵是'crust'，與之相關聯的值是字符串'thick'；下一個鍵是'
toppings',與之相關聯的值是一個列表，其中存儲了顧客要求添加的所有配料。制作前我們概述了顧客所點的比薩。為打印配料，我們編寫了一個for循環。為
訪問配料列表，我們使用了鍵'toppings',這樣Python將從字典中提取配料列表。
下面的輸出概述了要制作的比薩：
Yor ordered a thick-crust pizzawith the following toppings:
mushrooms
extra cheese
每當需要在字典中將一個鍵關聯到多個值時，都可以在字典中嵌套一個列表。在本章前面有關喜歡的編程語言的示例中，如果將每個人的回答都存儲在一個
列表中，被調查者就可以選擇多種喜歡的語言。在這種情況下，當我們遍歷字典時，與每個被調查者相關聯的都是一個語言列表，而不是一種語言；因此，在遍
歷字典時，與每個被調查者相關聯的都是一個語言列表，而不是一種語言；因此，在遍歷字典的for循環中，我們需要再使用一個for循環來遍歷與被調查者相關
聯的語言列表：
#首先定義一個字典，用於存儲用戶喜歡的語言，包含多種語言，放在一個列表中
favorite_language = {'tom':['python','ruby'],
'zengmz':['C','java'],
'Divad':['C++','php','python'],
'liuxs':['ruby']
}
for name in favorite_language.keys():
print('\n' + name.title() + "'s favorite language are: ")
#使用鍵返回對應列表的值，然后遍歷列表中的每個值
for language in favorite_language[name]:
print('\t' + language)
正如我們看到的，現在與每個名字相關聯的值都是一個列表。請注意，有些人喜歡的語言只有一種，而有些人有多種。遍歷字典時，我們使用了變量langu
來依次存儲字典中的每個值，因為我們知道這些值都是列表。在遍歷字典的主循環中，我們又使用了一個for循環來遍歷每個人喜歡的語言列表。現在，每個人
想列出多少種喜歡的語言都可以：
Divad's favorite language are:
C++
php
python
Zengmz's favorite language are:
C
java
Tom's favorite language are:
python
ruby
Liuxs's favorite language are:
ruby
為進一步改進這個程序，可在遍歷字典的for循環開頭添加一條if語句，通過查看len(languages)的值來確定當前的被調查者喜歡的語言是否有多種。如果
他喜歡的語言有多種，就像以前一樣顯示輸出；如果只有一種，就相應修改輸出的措辭，如顯示Sarah's favorite language is C.
注意：列表和字典的嵌套層級不應太多。如果嵌套層級比前面的示例多得多，很可能有更簡單的解決問題的方案。
6.4.3 在字典中嵌套字典
可在字典中嵌套字典，但這樣做時，代碼可能很快復雜起來。例如，如果有多個網站用戶，每個都有獨特的用戶名，可在字典中將用戶名作為鍵，然后將每
位用戶的信息存儲在一個字典中，並將該字典作為與用戶相關聯的值。在下面的程序中，對於每位用戶，我們都存儲了其三項信息：名、姓、和居住地；為訪問
這些信息，我們遍歷所有的用戶名,並訪問與每個用戶相關聯的信息字典：
users = {'aeinstein':{'first':'albert','last':'einstein','location':'princeton'},
'mcurie':{'first':'marie','last':'curie','location':'paris'},
}
for username in users.keys():
print("\nUsername: " + username)
user = users[username]
full_name = user['first'] + ' ' + user['last']
print("\tFull name: " + full_name)
print("\tLocation: " + user['location'])
我們首先定義了一個名為users的字典，其中包含兩個鍵：用戶名'aeinstein'和'mcurie';與每個鍵相關聯的值都是一個字典，其中包含用戶的名、姓和
居住地。首先，我們遍歷字典users，讓Python依次將每個鍵存儲在變量username中，並依次將與當前鍵相關聯的字典存儲在變量user_info中。
Username: mcurie
Full name: marie curie
Location: paris
Username: aeinstein
Full name: albert einstein
Location: princeton
請注意，表示每位用戶的字典的結構都相同，雖然Python並沒有這樣的要求，但這是的嵌套的字典處理起來更容易。倘若表示每位用戶的字典都包含不同
的鍵，for循環內部的代碼將更復雜。
動手試一試
6-7 人：在為完成練習6-1而編寫的程序中，在創建兩個表示人的字典，然后將這三個字典都存儲在一個名為people的列表中。遍歷這個列表，將其中所有人
的信息都打印出來。
本題考察的是字典的用法，如何遍歷字典
person_0 = {'first_name':"geng","last_name":'changxue','age':26,'city':'dengzhou'}
person_1 = {'first_name':"zeng",'last_name':'mingzhu','age':20,'city':'changsha'}
person_2 = {'first_name':"zhang","last_name":'dapao','age':18,'city':'changchun'}
peoples = [person_0,person_1,person_2]
for people in peoples:
full_name = people["first_name"] + ' ' + people['last_name']
print(full_name.title() + " is " + str(people['age']) + ' old, and lives in ' + people['city'].title() + '.')
運行結果如下：
Geng Changxue is 26 old, and lives in Dengzhou.
Zeng Mingzhu is 20 old, and lives in Changsha.
Zhang Dapao is 18 old, and lives in Changchun.
6-8 寵物：創建多個字典，對於每個字典，都使用一個寵物的名稱來給它命名；在每個字典中，包含寵物的類型及其主人的姓名。將這些字典存儲在一個名為
pets的列表中，在遍歷該列表，並將寵物的所有信息都打印出來。
dog = {"age":3,'master':"loujq"}
cat = {"age":6,"master":"liuxs"}
monkey = {'age':5,'master':'songc'}
pets = [dog,cat,monkey]
#遍歷每個寵物，並進行描述，提取字典中的鍵和值
for pet in pets:
print(pet['master'].title() + "'s pet is " + str(pet["age"]) + " years old.")
運行結果如下：
Loujq's pet is 3 years old.
Liuxs's pet is 6 years old.
Songc's pet is 5 years old.
6-9 喜歡的地方： 創建一個名為favorite_places的字典。在這個字典中，將三個人的名字用作鍵；對於其中的每個人，都存儲它喜歡的1~3個地方。遍歷這個
字典，並將其中每個人的名字及其喜歡的地方打印出來。
#創建一個嵌套列表，字典里面包含列表的情況
favorite_places = {"zeng mingzhu":["bangkok",'chiang mai','singapore'],
"geng changxue":['chengdu',"chongqing",'lasa'],
'zhang xinxin':['qingdao','seoul','pyongyang']
}
#遍歷字典中的鍵和值，其中字典中鍵對應的值是一個列表
for name,place in sorted(favorite_places.items()):
print("\nname: " + name.title())
#由於值是一個列表，要返回每個城市，則需要對列表進行遍歷
for city in place:
print("Favorite places: " + city.title())
運行結果如下：
name: Geng Changxue
Favorite places: Chengdu
Favorite places: Chongqing
Favorite places: Lasa
name: Zeng Mingzhu
Favorite places: Bangkok
Favorite places: Chiang Mai
Favorite places: Singapore
name: Zhang Xinxin
Favorite places: Qingdao
Favorite places: Seoul
Favorite places: Pyongyang
6-10 喜歡的地方
#定義三個人，名字和喜歡的數字，字典中存放的是列表
person_0 = {"name":"liujq",'number':[6,7,9]}
person_1 = {'name':'sora aoi','number':[0,1]}
person_2 = {'name':'Ria Sakurai','number':[7,6,66]}
#將三個人存放在一個列表中
persons = [person_0,person_1,person_2]
#從列表中遍歷三個人，注意，遍歷出來的是字典，我們遍歷的時候使用的是列表的性質，要注意自己的操作對象是什么
for person in persons:
#調用字典中的鍵和值
print("\nName: " + person['name'])
#由於鍵對應的值是一個列表，使用列表的性質遍歷每個人的幸運數字
for num in person['number']:
print("Lucky number: " + str(num))
運行結果如下：
Name: liujq
Lucky number: 6
Lucky number: 7
Lucky number: 9
Name: sora aoi
Lucky number: 0
Lucky number: 1
Name: Ria Sakurai
Lucky number: 7
Lucky number: 6
Lucky number: 66
6-11 城市： 創建一個名為cities的字典，遍歷其中的信息
cities = {'seoul':{"country":'korea',"population":10,'fact':'Pickled cabbage'},
'beijing':{'country':'china','population':100,'face':'noodle'},
'paris':{'country':'frence','population':15,'fact':'hambarger'}
}
#遍歷每個城市的信息，由於屬於嵌套，字典里面嵌套一個字典，要只用字典的屬性
for captial,value in cities.items():
print(value['country'].title() + "'s captial is " + captial + ', and haa the population of ' + str(value['population'])+'.')
運行結果如下：
Frence's captial is paris, and haa the population of 15.
China's captial is beijing, and haa the population of 100.
Korea's captial is seoul, and haa the population of 10.
注意：其實無論嵌套多么復雜，我們要牢記的是，我們處理的對象是什么，是列表還是字典，從列表，字典中遍歷出來的是什么，要根據對象的屬性去處理對象
即可，因為每個對象都有自己獨特的屬性，這點我們一定要牢記，不要看着字典復雜，字典在復雜，它也是由鍵和值組成的鍵-值對，鍵處理簡單，復雜在值上
我們只要關注鍵對應值的屬性即可。
6.5 小結
在本章中，我們學習了：如何定義字典，以及如何使用存儲在字典中的信息；如何訪問和修改字典中的元素，以及如何遍歷字典中的所有信息；如何遍歷字
典中所有的鍵-值對、所有的鍵和所有的值；如何在列表中嵌套字典、在字典中嵌套列表以及在字典中嵌套字典。
個人感悟：其實只要記住字典的屬性即可，我們知道，字典必定包含鍵和值，字典是由鍵-值對組成的，無論怎樣，鍵都是一個值，但是值可以是任意形式，可以
是單個字符串、單個數字、列表以及字典，但是我們在使用的時候，其實還是調用的屬性，比如列表的屬性，字典的屬性，在操作的時候，只是把這些屬性綜合起
來運用而已，比如值是列表的時候，我們就可以調用列表所有的屬性對值進行操作，我們要知道，從字典中提取的值一定要注意它的形式，是一樣什么樣的對象。
另外分享一個小知識，原來字符串也是可以遍歷的，只是返回的是單個字符的情況
>>> a = 'ruby'
>>> for z in a:
... print(z)
...
r
u
b
y