Python编程：从入门到实践(第六章)_python中不能返回“键对值”的是

一个简单的字典：

alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color'])
print(alien_0['points'])
1
2
3

green
5
1
2

在Python中， 字典 是一系列键—值对 。 每个键 都与一个值相关联， 你可以使用键来访问与之相关联的值。 与键相关联的值可以是数字、 字符串、 列表乃至字典。 事实上， 可将任何Python对象用作字典中的值
字典用放在花括号{} 中的一系列键—值对表示

alien_0 = {'color': 'green', 'points': 5}
1

键—值 对是两个相关联的值。 指定键时， Python将返回与之相关联的值。 键和值之间用冒号分隔， 而键—值对之间用逗号分隔。 在字典中， 你想存储多少个键—值对都可以。最简单的字典只有一个键—值对， 如下述修改后的字典alien_0 所示：
alien_0 = {‘color’: ‘green’}
这个字典只存储了一项有关alien_0 的信息， 具体地说是这个外星人的颜色。 在这个字典中， 字符串’color’ 是一个键， 与之相关联的值为’green’ 。

alien_0 = {'color': 'green', 'points': 5}//定义一个字典
❶ new_points = alien_0['points']
❷ print("You just earned " + str(new_points) + " points!")
1
2
3

添加键—值对

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

{'color': 'green', 'points': 5}
{'color': 'green', 'points': 5, 'y_position': 25, 'x_position': 0}
1
2

注意， 键—值对的排列顺序与添加顺序不同。 Python不关心键—值对
的添加顺序， 而只关心键和值之间的关联关系
创建一个空字典

alien_0 = {}
alien_0['color'] = 'green'
alien_0['points'] = 5
print(alien_0)
1
2
3
4

{'color': 'green', 'points': 5}
1

修改字典中的值

alien_0 = {'color': 'green'}
print("The alien is " + alien_0['color'] + ".")
alien_0['color'] = 'yellow'
print("The alien is now " + alien_0['color'] + ".")
1
2
3
4

字典名：alien_0 ，【】里面是键，

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']))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Original x-position: 0
New x-position: 2
1
2

删除键—值对

alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
del alien_0['points']
print(alien_0)
1
2
3
4

让Python将键’points’ 从字典alien_0 中删除， 同时删除与这个键相关联的值。 输出表明， 键’points’ 及其值5 已从字典中删除， 但其他键—值对未受影响

favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',//多了一个冒号
}
1
2
3
4
5
6

我们将一个较大的字典放在了多行中。 其中每个键都是一个被调查者的名字， 而每个值都是被调查者喜欢的语言。 确定需要使用多行来定义字典时， 在输入左花括号后按回车键， 再在下一行缩进四个空格， 指定第一个键—值对， 并在它后面加上一个逗号。 此后你再次按回车键时， 文本编辑器将自动缩进后续键—值对， 且缩进量与第一个键—值对相同。
定义好字典后， 在最后一个键—值对的下一行添加一个右花括号， 并缩进四个空格， 使其与字典中的键对齐。 另外一种不错的做法是在最后一个键—值对后面也加上逗号， 为以后在下一行添加键—值对做好准备。

遍历所有的键—值对

ser_0 = {
'username': 'efermi',
'first': 'enrico',
'last': 'fermi',
}
 for key, value in user_0.items():
   print("\nKey: " + key)
   print("Value: " + value)
1
2
3
4
5
6
7
8

要编写用于遍历字典的for 循环， 可声明两个变量， 用于存储键—值对中的键和值。 对于这两个变量， 可使用任何名称。 下面的代码使用了简单的变量名， 这完全可以：

for 语句的第二部分包含字典名和方法items() ， 它返回一个键—值对列表。 接下来， for 循环依次将每个键—值对存储到指定的两个变量中。 在前面的示例中， 我们使用这两个变量来打印每个键 及其相关联的值 。 第一条print 语句中的"\n" 确保在输出每个键—值对前都插入一个空行：

Key: last
Value: fermi
Key: first
Value: enrico
Key: username
Value: efermi
1
2
3
4
5
6

注意， 即便遍历字典时， 键—值对的返回顺序也与存储顺序不同。 Python不关心键—值对的存储顺序， 而只跟踪键和值之间的关联关系。
遍历字典中的所有键

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
 for name in favorite_languages.keys():
   print(name.title())
1
2
3
4
5
6
7
8

处的代码行让Python提取字典favorite_languages 中的所有键， 并依次将它们存储到变量name 中。 输出列出了每个被调查者的名字：

Jen
Sarah
Phil
Edward
1
2
3
4

遍历字典时， 会默认遍历所有的键， 因此， 如果将上述代码中的for name in favorite_languages.keys(): 替换为for name in favorite_languages: ， 输出
将不变。
如果显式地使用方法keys() 可让代码更容易理解， 你可以选择这样做， 但如果你愿意， 也可省略它。
按顺序遍历字典中的所有键
字典总是明确地记录键和值之间的关联关系， 但获取字典的元素时， 获取顺序是不可预测的。 这不是问题， 因为通常你想要的只是获取与键相关联的正确的值。要以特定的顺序返回元素， 一种办法是在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.")
1
2
3
4
5
6
7
8

遍历字典中的所有值

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())
1
2
3
4
5
6
7
8
9

The following languages have been mentioned:
Python
CP
ython
Ruby
1
2
3
4
5

这种做法提取字典中所有的值， 而没有考虑是否重复。 涉及的值很少时， 这也许不是问题， 但如果被调查者很多， 最终的列表可能包含大量的重复项。 为剔除重复项， 可使用集合（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())
1
2
3
4
5
6
7
8
9

The following languages have been mentioned:
Python
CRu
by
1
2
3
4

嵌套

字典列表

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)
1
2
3
4
5
6

{'color': 'green', 'points': 5}
{'color': 'yellow', 'points': 10}
{'color': 'red', 'points': 15}
1
2
3

# 创建一个用于存储外星人的空列表
aliens = []
# 创建30个绿色的外星人
for alien_number in range (0,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  就是改变aliens 里的值 
 alien['speed'] = 'medium'
 alien['points'] = 10
# 显示前五个外星人
for alien in aliens[0:5]:
print(alien)
print("...")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

{'speed': 'medium', 'color': 'yellow', 'points': 10}
{'speed': 'medium', 'color': 'yellow', 'points': 10}
{'speed': 'medium', 'color': 'yellow', 'points': 10}
{'speed': 'slow', 'color': 'green', 'points': 5}
{'speed': 'slow', 'color': 'green', 'points': 5}
...
1
2
3
4
5
6

在字典中存储列表

# 存储所点比萨的信息
❶ pizza = {
'crust': 'thick',
'toppings': ['mushrooms', 'extra cheese'],
}
# 概述所点的比萨
❷ print("You ordered a " + pizza['crust'] + "-crust pizza " +
"with the following toppings:")
❸ for topping in pizza['toppings']:
//注意这个pizza['toppings']相当于列表
print("\t" + topping)
1
2
3
4
5
6
7
8
9
10
11

You ordered a thick-crust pizza with the following toppings:
mushrooms
extra cheese
1
2
3

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

favorite_languages = {
'jen': ['python', 'ruby'],
'sarah': ['c'],
'edward': ['ruby', 'go'],
'phil': ['python', 'haskell'],
}
❷ for name, languages in favorite_languages.items():
print("\n" + name.title() + "'s favorite languages are:")
❸ for language in languages:
print("\t" + language.title())
1
2
3
4
5
6
7
8
9
10

正如你看到的， 现在与每个名字相关联的值都是一个列表（见❶） 。 请注意， 有些人喜欢的语言只有一种， 而有些人有多种。 遍历字典时（见❷） ， 我们使用了变量languages
来依次存储字典中的每个值， 因为我们知道这些值都是列表。 在遍历字典的主循环中， 我们又使用了一个for 循环来遍历每个人喜欢的语言列表（见❸） 。 现在， 每个人想列出
多少种喜欢的语言都可以：

Jen's favorite languages are:
Python
Ruby
Sarah's favorite languages are:
C
Phil's favorite languages are:
Python
Haskell
Edward's favorite languages are:
Ruby
Go
1
2
3
4
5
6
7
8
9
10
11

在字典中存储字典

users = {
'aeinstein': {
'first': 'albert',
'last': 'einstein',
'location': 'princeton',
},
'mcurie': {
'first': 'marie',
'last': 'curie',
'location': 'paris',
},
}
❶ for username, user_info in users.items():
❷ print("\nUsername: " + username)
❸ full_name = user_info['first'] + " " + user_info['last']
location = user_info['location']
❹ print("\tFull name: " + full_name.title())
print("\tLocation: " + location.title())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Username: aeinstein
Full name: Albert Einstein
Location: Princeton
Username: mcurie
Full name: Marie Curie
Location: Paris
1
2
3
4
5
6