第6章 字典

字典的使用

在Python中，字典（dictionary）是一系列键值对。每个键（key）都与一个值（value）关联，可以使用键来访问与之关联的值。与键关联的值可以是数、字符串、列表乃至字典。事实上，可将任意Python对象用作字典中的值。

在 Python 中的字典用放在花括号{}中的一系列键值对表示，写法为：$\{key:value\}$

键和值之间用冒号分隔，每一个key:value我们称它为一个键值对，键和值之间用冒号分隔，键值对之间用逗号分隔。在字典中，你想存储多少个键值对都可以。

访问字典中的值

来看一个包含外星人的游戏，这些外星人的颜色和分数各不相同。
字典alien_0存储了这个外星人的颜色和分数。

>>> alien_0 = {'color': 'green', 'points': 5}
#要获取与键关联的值，可指定字典名并把键放在后面的方括号内
>>> alien_0['color'] 
'green'
>>> print(alien_0['color'])
green
# 如果玩家消灭了这个外星人，玩家应获得多少分：
>>> new_points = alien_0['points']
>>> print(f"You just earned {new_points} points!")
You just earned 5 points!

上述代码首先定义了一个字典。从这个字典中获取与键'points'关联的值，并将这个值赋给变量new_points。最后打印一条消息，指出玩家获得了多少分。

添加键值对

字典是一种动态结构，可随时在其中添加键值对。要添加键值对，可依次指定字典名、用方括号括起来的键和与该键关联的值。

在字典alien_0中添加两项信息：外星人的x坐标和y坐标，以便在屏幕的特定位置上显示该外星人。我们将这个外星人放在屏幕左边缘上，距离屏幕上边缘25像素。由于屏幕坐标系的原点通常在左上角，因此要将该外星人放在屏幕左边缘，可将x坐标设置为0；要将该外星人放在距离屏幕上边缘25像素的地方，可将y坐标设置为25，如下所示：

>>> alien_0 = {'color': 'green', 'points': 5}
>>> print(alien_0)
{'color':'green','points':5}
>>> alien_0['x_position'] = 0	
>>> alien_0['y_position'] = 25	
>>> print(alien_0)
{'color':'green','points':5,'x_position': 0,'y_position': 25}

首先定义前面一直在使用的字典，然后打印这个字典，以显示其信息快照。接下来，在这个字典中新增一个键值对，其中的键为'x_position'、值为0。然后重复同样的操作，但使用的键为 'y_position'、值为25。打印修改后的字典。

这个字典的最终版本包含4个键值对，其中原来的两个指定外星人的颜色和分数，而新增的两个指定其位置。

字典会保留定义时的元素排列顺序。如果将字典打印出来或遍历其元素，将发现元素的排列顺序与其添加顺序相同。

从创建一个空字典开始

有时候，在空字典中添加键值对很方便，甚至是必需的。为此，可先使用一对空花括号定义一个空字典，再分行添加各个键值对。

>>> alien_0 = {}
>>> alien_0['color'] = 'green'
>>> alien_0['points'] = 5
>>> alien_0
{'color': 'green', 'points': 5}

如果要使用字典来存储用户提供的数据或者编写能自动生成大量键值对的代码，通常需要先定义一个空字典。

修改字典中的值

要修改字典中的值，可依次指定字典名、用方括号括起来的键和与该键关联的新值。

假设随着游戏的进行，需要将一个外星人从绿色改为黄色：

# 首先定义一个表示外星人alien_0的字典，其中只包含这个外星人的颜色。
>>> alien_0 = {'color': 'green'}
>>> print(f"The alien is {alien_0['color']}.")
The alien is green.

>>> alien_0['color'] = 'yellow' # 将键'color'的值改为'yellow'。
>>> print(f"The alien is now {alien_0['color']}.")
The alien is now yellow.

对一个能够以不同速度移动的外星人进行位置跟踪。为此，存储该外星人的当前速度，并据此确定该外星人应该向右移动多远：

alien_0 = {'x_position': 0, 'y_position': 25, 'speed': 'medium'}
print(f"Original position: {alien_0['x_position']}")

# 向右移动外星人
# 根据当前速度用if语句确定将外星人向右移动多远，并将这个值赋给变量x_increment
if alien_0['speed'] == 'slow':
		x_increment = 1
elif alien_0['speed'] == 'medium':
		x_increment = 2
else:
		x_increment = 3
# 新位置为旧位置加上移动距离，将结果关联到字典中的键x_position
alien_0['x_position'] = alien_0['x_position'] + x_increment
print(f"New position: {alien_0['x_position']}")

>>> 
Original position: 0
New position: 2

首先定义一个外星人，其中包含初始x坐标和y坐标，还有速度 'medium'。我们还打印了x_position 的初始值，旨在让用户知道这个外星人向右移动了多远。

这种技巧很棒，通过修改外星人字典中的值，可改变外星人的行为。

例如，要将这个速度中等的外星人变成速度很快的外星人，可添加如下代码行：alien_0['speed'] = 'fast'

这样，再次运行这些代码，if-elif-else语句将把一个更大的值赋给变量x_increment键值对

删除键值对

对于字典中不再需要的信息，可使用del语句将相应的键值对彻底删除。在使用del语句时，必须指定字典名和要删除的键。

注意：删除的键值对永远消失了。

例如，下面的代码从字典alien_0中删除键'points'及其值：

>>> alien_0 = {'color': 'green', 'points': 5}
>>> print(alien_0)
{'color': 'green', 'points': 5}
>>> del alien_0['points']
>>> print(alien_0)
{'color': 'green'}

由类似的对象组成的字典

在前面的示例中，字典存储的是一个对象（游戏中的一个外星人）的多种信息，但也可以使用字典来存储众多对象的同一种信息。假设你要调查很多人，询问他们喜欢的编程语言，可使用一个字典来存储这种简单调查的结果，如下所示：

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'rust', 'phil': 'python', }

如你所见，我们将一个较大的字典放在了多行中。每个键都是一个被调查者的名字，而每个值都是被调查者喜欢的语言。当确定需要使用多行来定义字典时，先在输入左花括号后按回车键，再在下一行缩进4个空格，指定第一个键值对，并在它后面加上一个逗号。此后再按回车键，文本编辑器将自动缩进后续键值对，且缩进量与第一个键值对相同。

定义好字典后，在最后一个键值对的下一行添加一个右花括号，并且也缩进4个空格，使其与字典中的键对齐。一种不错的做法是，在最后一个键值对后面也加上逗号，为以后添加键值对做好准备。

注意：对于较长的列表和字典，大多数编辑器提供了以类似方式设置格式的功能。对于较长的字典，还有其他一些可行的格式设置方式，因此在你的编辑器或其他源代码中，你可能会看到稍微不同的格式设置方式。

给定被调查者的名字，可使用这个字典轻松地了解他喜欢的语言：

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'rust', 'phil': 'python', }
language = favorite_languages['sarah'].title()
print(f"Sarah's favorite language is {language}.")

# 为了解Sarah喜欢的语言，我们使用如下代码
favorite_languages['sarah'] # 输出Sarah's favorite language is C.

这种语法可用来从字典中获取任何人喜欢的语言。

使用get()来访问值

使用放在方括号内的键从字典中获取感兴趣的值，可能会引发问题：如果指定的键不存在，就将出错。

如果你要求获取外星人的分数，而这个外星人没有分数，这将导致 Python 显示 traceback，指出存在键值错误（KeyError）。

>>> alien_0 = {'color': 'green', 'speed': 'slow'}
>>> print(alien_0['points'])

Traceback (most recent call last): 
	File "alien_no_points.py", line 2, in <module>
		print(alien_0['points'])
					~~~~~~~^^^^^^^^^^
KeyError: 'points'

第10章将详细介绍如何处理类似的错误。就字典而言，为避免出现这样的错误，可使用get()方法在指定的键不存在时返回一个默认值。

get()方法的第一个参数用于指定键，是必不可少的；第二个参数为当指定的键不存在时要返回的值，是可选的：

>>> alien_0 = {'color': 'green', 'speed': 'slow'}
>>> point_value = alien_0.get('points', 'No point value assigned.')
# 如果字典中有键'points',将获得关联的值；如果没有，将获得指定的默认值。
>>> print(point_value)
No point value assigned.

如果指定的键有可能不存在，应考虑使用get()方法，而不要使用方括号表示法。

注意：在调用get()时，如果没有指定第二个参数且指定的键不存在，Python将返回值None，这个特殊的值表示没有相应的值。这并非错误，None只是一个表示所需值不存在的特殊值，第8章将介绍它的其他用途。

遍历字典

一个 Python 字典可能只包含几个键值对，也可能包含数百万个键值对。鉴于字典可能包含大量数据，Python 支持对字典进行遍历。字典可用于以各种方式存储信息，因此有多种遍历方式：既可遍历字典的所有键值对，也可只遍历键或值。

遍历所有键值对

在探索各种遍历方法前，先来看一个新字典，它用于存储有关网站用户的信息。这个字典存储一个用户的用户名、名和姓：
user.py

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(f"\nKey:{key}")
	print(f"Value:{value}")
>>>
Key: username
Value: efermi

Key: first
Value: enrico

Key: last
Value: fermi

要编写遍历字典的for循环，可声明两个变量，分别用于存储键值对中的键和值。这两个变量可以使用任意名称。下面的代码使用了简单的变量名，这完全可行：
for k, v in user_0.items()
for 语句的第二部分包含字典名和方法items()，这个方法返回一个键值对列表。接下来，for循环依次将每个键值对赋给指定的两个变量。在这个示例中，使用这两个变量来打印每个键和与它关联的值。第一个函数调用print()中的"\n"确保在输出每个键值对前插入一个空行。

在6.2.6节的示例 favorite_languages.py中，字典存储的是不同的人的同一种信息。对于类似这样的字典，遍历所有的键值对很合适。如果遍历字典 favorite_languages，将得到其中每个人的姓名和他们喜欢的编程语言。由于该字典中的键都是人名，值都是语言，因此在循环中使用变量 name 和 language，而不是 key 和value。这让人更容易明白循环的作用：
favorite_languages.py

favorite_languages = {
	'jen': 'python',
	'sarah': 'c',
	'edward': 'rust',
	'phil': 'python',
	}
for name, language in favorite_languages.items():
	print(f"{name.title()}'s favorite language is {language.title()}.")

这些代码让Python遍历字典中的每个键值对，并将键赋给变量 name，将值赋给变量 language。这些描述性名称让人能非常轻松地明白函数调用 print() 是做什么的。仅用几行代码，就将全部调查结果显示出来了。即便字典存储了上千万人的调查结果，这种循环也管用。

遍历字典中的所有键

在不需要使用字典中的值是，keys()方法很有用。下面遍历字典 favorite_languages，并将每个被调查者的名字都打印出来：

favorite_languages = {
	'jen': 'python',
	'sarah': 'c',
	'edward': 'rust',
	'phil': 'python',
for name in favorite_languages.keys():
	print(name.title())
}
>>>
Jen
Sarah
Edward
Phil

这个 for 循环让 Python 提取字典 favorite_languages 中的所有键，并将依次将它们赋给变量 name。输出列出了每个被调查的名字。

在遍历字典时，会默认遍历所有的键。因此，如果将上述代码中的for name in favorite_languages.keys():替换为for name in favorite_languages:输出将不变。

如果显式地使用 keys() 方法能让代码更容易理解，就可以选择这样做，但如果你愿意，也可以省略它。

在这种循环中，可使用当前的键来访问与之关联的值。下面来打印两条消息，指出两个朋友喜欢的编程语言。我们像前面一样遍历字典中的名字，但在名字为指定朋友的名字时，打印一条消息，指出其喜欢的语言：

favorite_languages = { 
	--snip--
	}
friends = ['phil', 'sarah']
for name in favorite_languages.keys():
	print(f"Hi {name.title()}.")
	
	if name in friends:
		language = favorite_languages[name].title()
		print(f"\t{name.title()}, I see you love {language}!")
>>>
Hi Jen.
Hi Sarah.
	Sarah, I see you love C!
Hi Edward.
Hi Phil.
	Phil, I see you love Python!

还可以使用 keys() 确定某个人是否接受了调查。下面的代码确定 Erin 是否接受了调查：

favorite_languages = {
	--snip--
	}
if 'erin' not in favorite_languages.keys():
	print("Erin, please take our poll!")
>>>
Erin, please take our poll!

keys()方法并非只能用于遍历：实际上，它会返回一个列表，其中包含字典中的所有键。因此 if 语句只核实 erin 是否在这个列表中。因为她并不在这个列表中，所以打印一条消息，邀请她参加调查。

按特定的顺序遍历字典中的所有键

遍历字典时将按插入元素的顺序返回其中的元素，但是在一些情况下，你可能要按与此不同的顺序遍历字典。

要以特定顺序返回元素，一种方法是在 for 循环中对返回的键进行排序。为此，可使用sorted() 函数来获得按特定顺序排列的键列表的副本：

favorite_languages = {
	'jen': 'python',
	'sarah': 'c',
	'edward': 'rust',
	'phil': 'python',
	}
for name in sorted(favorite_languages.keys()):
	print(f"{name.title()}, thank you for taking the poll.")
>>>
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.

这条 for 语句类似于其他 for 语句，但对方法 dicitionary.keys()的结果调用了 sorted() 函数。这让Python 获取字典中的所有键，并在遍历前对这个列表进行排序。输出表明，按字母顺序显示了所有被调查者的名字。

遍历字典中的所有值

如果你感兴趣的是字典包含的值，可使用 values() 方法。它会返回一个值列表，不包含任何键。如果想获得一个只包含被调查者选择的各种语言，而不包含被调查者名字的列表，可以这样做：

favorite_languages = {
	'jen': 'python',
	'sarah': 'c',
	'edward': 'rust',
	'phil': 'python',
	}
print("The following languages have been mentioned:")
for language in favorite_languages.values():
	print(language.title())
>>>
The following languages have been mentioned:
Python
C
Rust
Python

这种做法提取字典中所有的值，而没有考虑值是否有重复。当涉及的值很少时，也许不是问题，但如果被调查者很多，最终的列表可能包含大量重复项。为剔除重复项，可使用集合（set）。集合中的每个元素都必须是独一无二的：

favorite_languages = {
	--snip--
	}
print("The following languages have been mentioned:")
for language in set(favorite_languages.values()):
	print(language.title())
>>>
The following languages have been mentioned:
Python
C
Rust

通过将包含重复元素的列表传入 set()，可让 Python 找出列表中独一无二的元素，并使用这些元素来创建一个集合。这里使用 set() 来提取 favorite_languages.values() 中不同的语言。结果是一个没有重复元素的列表，其中列出了被调查者提及的所有语言。

随着学习的深入，你会经常发现Python内置的功能可帮助你以希望的方式处理数据。

注意：可以使用一对花括号直接创建集合，并在其中用逗号分隔元素：

>>> languages = {'python', 'rust', 'python', 'c'}
>>> languages
{'rust', 'python', 'c'}

集合和字典很容易混淆，因为它们都是用一对花括号定义的。当花括号内没有键值对时，定义的很可能是集合。不同于列表和字典，集合不会以特定的顺序存储元素。

嵌套

有时候，需要将多个字典存储在列表中或将列表作为值存储在字典中，这称为嵌套。嵌套是一个强大的功能，可以在列表中嵌套字典，在字典中嵌套列表，甚至在字典中嵌套字典。

字典列表

字典 alien_0 包含一个外星人的各种信息，但无法存储第二个外星人的信息，更别说屏幕上全部外星人的信息了。如何管理成群结队的外星人呢？

一种办法是创建一个外星人列表，其中每个外星人都是一个字典，包含有关该外星人的各种信息。例如，下面的代码创建一个包含三个外星人的列表：首先创建三个字典，其中每个字典都表示一个外星人。然后将这些字典都存储到一个名为aliens的列表中。最后遍历这个列表，将每个外星人都打印出来。

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 aline in aliens:
	print(aliens)
>>>
[{'color': 'green', 'points': 5}
 {'color': 'yellow', 'points': 10}
 {'color': 'red', 'points': 15}]

更符合现实的情形是，外星人不止三个，且每个外星人都是用代码自动生成的。在下面的示例中，使用 range() 生成了30个外星人：

# 创建⼀个⽤于存储外星⼈的空列表
aliens = []
# 创建 30 个绿⾊的外星⼈
for alien_number in range(30):# range() 函数返回一个数字序列，设置重复这个循环多少次。
	new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
	aliens.append(new_alien)#每执行一次循环，都创建一个外星人，并追加到列表aliens 末尾。
# 使用切片打印前 5 个外星⼈
for alien in aliens[:5]:
	print(alien)
print("...")
# 打印列表长度，以证明创建了多少外星⼈
print(f"Total number of aliens: {len(aliens)}")
>>>
{'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 (30):
		new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
		aliens.append(new_alien)
for alien in aliens[:3]:
		if alien['color'] == 'green':
		alien['color'] = 'yellow'
		alien['speed'] = 'medium'
		alien['points'] = 10
# 显示前5个外星人
for alien in aliens[:5]:
		print(alien)
print("...")
>>>
{'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'}
...

鉴于要修改前三个外星人，我们遍历一个只包含这些外星人的切片。当前，所有外星人都是绿色的，但情况并非总是如此，因此可以编写一条if 语句来确保只修改绿色外星人。如果外星人是绿色的，就将其颜色改为 'yellow',将其速度改为'medium',并将其分数改为10,如下面的输出所示：

可进一步扩展这个循环，在其中添加一个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

你经常需要在列表中存储大量的字典，而且每个字典都包含特定对象的众多信息。例如，为网站的每个用户创建一个字典（就像6.3.1节的user.py中那样），并将这些字典存储在一个名为users的列表中。在这个列表中，所有字典的结构都相同，因此可遍历这个列表，并以相同的方式处理其中的每个字典。

在字典中存储列表

每当需要在字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表。

例如，如何描述顾客点的比萨呢？如果使用列表，只能存储要添加的比萨配料；但如果使用字典，其中的配料列表就只是用来描述比萨的一个方面。

在下面的示例中，存储了比萨两个方面的信息：外皮类型和配料列表。配料列表是一个与键'toppings'关联的值。要访问该列表，我们使用字典名和键'toppings'，就像访问字典中的其他值一样。这将返回一个配料列表，而不是单个值。

当函数调用print()中的字符串很长，需要分成多行书写时，可以在合适的位置分行，在每行末尾都加上引号，并且对于除第一行外的其他各行，都在行首加上引号并缩进。这样，Python将自动合并括号内的所有字符串。

为了打印配料，编写一个for循环。为了访问配料列表，使用键 'toppings'，这样Python将从字典中提取配料列表。

# 首先创建一个字典，存储顾客所点比萨的信息
pizza = {
'crust': 'thick',
'toppings': ['mushrooms', 'extra cheese'], # 与toppings关联的值是一个列表，其中存储了顾客要求添加的所有配料。
}
# 概述顾客点的比萨
print(f"You ordered a {pizza['crust']}-crust pizza "
		"with the following toppings:")
for topping in pizza['toppings']:
		print(f"\\t{topping}")
>>>
You ordered a thick-crust pizza with the following toppings:
		mushrooms
		extra cheese

在本章前面有关喜欢的编程语言的示例中，如果将每个人的回答都存储在一个列表中，被调查者就可以选择多种喜欢的语言。在这种情况下，当我们遍历字典时，与每个被调查者关联的都是一个语言列表，而不是一种语言。因此，在遍历该字典的for循环中，需要再使用一个for循环来遍历与被调查者关联的语言列表：

favorite_languages = {
'jen': ['python', 'rust'],
'sarah': ['c'],
'edward': ['rust', 'go'],
'phil': ['python', 'haskell'],}

for name, languages in favorite_languages.items():
		print(f"\\n{name.title()}'s favorite languages are:")
		for language in languages:
				print(f"\\t{language.title()}")
>>>

Jen's favorite languages are:
		Python
		Rust

Sarah's favorite languages are:
		C

Edward's favorite languages are:
		Rust
		Go

Phil's favorite languages are:
		Python
		Haskell

在这里，与每个名字关联的值都是一个列表。请注意，有些人喜欢的语言只有一种，而有些人喜欢的不止一种。在遍历字典时，使用变量languages来依次存储字典中的每个值，因为我们知道这些值都是列表。在遍历字典的主循环中，使用另一个for循环来遍历每个人喜欢的语言列表。现在，每个人想列出多少种喜欢的语言都可以。

为了进一步改进这个程序，可在遍历字典的for循环开头添加一条if语句，通过查看len(languages)的值来确定当前的被调查者喜欢的语言是否有多种。

如果他喜欢的语言不止一种，就像以前一样显示输出；如果只有一种，就相应地修改输出的措辞，如显示Sarah's favorite language is C。

注意：列表和字典的嵌套层级不应太多。如果嵌套层级比前面的示例多得多，很可能有更简单的解决方案。

在字典中存储字典

如果有一网站有多个用户，每个用户都有独特的用户名，在字典中将用户名作为键，然后将每个用户的信息存储在一个字典中，并将该字典作为与用户名关联的值。

在下面的程序中，存储每个用户的三项信息：姓、名和居住地。为了访问这些信息，我们遍历所有的用户名，并访问与每个用户名关联的信息字典。

# 定义一个名为users的字典，其中包含两个键：'aeinstein'和'mcurie'。每个键关联的值都是一个包含用户的名、姓和居住地的字典。
users = {
	'aeinstein': {
		'first': 'albert',
		'last': 'einstein',
		'location': 'princeton', 
		},
	'mcurie': {
		'first': 'marie',
		'last': 'curie',
		'location': 'paris', 
		},
	}
# 遍历字典，依次将每个键赋给变量username，依次与当前键关联的字典赋给变量user_info。在循环内部，将用户名打印出来了
for username, user_info in users.items():
# 访问内部的字典user_info，而该字典包含三个键：'first'、'last'和'location'。对每个用户，都使用这些键来生成整洁的姓名和居住地，然后打印有关用户的简要信息。
		print(f"\nUsername: {username}")
		full_name = f"{user_info['first']} {user_info['last']}"
		location = user_info['location']
		print(f"\tFull name: {full_name.title()}")
		print(f"\tLocation: {location.title()}")
>>>

Username: aeinstein
        Full name: Albert Einstein
        Location: Princeton

Username: mcurie
        Full name: Marie Curie
        Location: Paris

注意，表示每个用户的字典都有相同的结构，虽然Python并没有这样的要求，但这使得嵌套的字典处理起来更容易。倘若表示每个用户的字典都包含不同的键，for循环内部的代码将更复杂。