字典可存储的信息几乎不受限制, 因此遍历字典中的数据将为重点. 本章将学习存储字典列表. 存储列表的字典和存储字典的字典. 字典将为准确的为各种真实物体建模.
6.1 一个简单的字典
下面是一个字典, 存储了有关特定外新人的信息:
- alien_0 = {'color':'green','points':5}
- print(alien_0['color'])
- print(alien_0['points'])
输出:
green
5
字典 alien_0 存储了外星人的颜色和点数. 使用 2 条 print 语句来访问并打印这些消息.
6.2 使用字典
在 python 中, 字典是一系列键 - 值对. 每个键都与一个人值相关联, 你可以使用键来方位与之关联的值. 与键想关联的值可以是数字, 字符串, 列表, 乃至字典. 事实上, 可将任何 python 对象用作字典中的值.
在 python 中, 字典用哪个花括号 {} 中的一系列键 - 值对表示. 例: alien_0 = {'color': 'green', 'points': 5}
键 - 值 对是两个相关联的值. 指定键时, python 将返回与之相关联的值. 键和值之间用冒号分隔, 而键 - 值对之间用逗号分隔. 在字典中, 你想存储多少个键 - 值对都可以.
最简单的字典只有一个键 - 值对. 例: alien_0 = {'color': 'green'}. 这个字典值存储了一项有关的 alien_0 的信息, 具体说是这个外外星人的颜色. 在这个字典中, 字符串'color'是一个键, 与之关联的值为'green'.
6.2.1 访问字典中的值
要获取与键相关联的值, 可依次指定字典名和放放在方括号内的键. 例:(以下返回值 alien_0 与键'color'相关联的值:)
- alien_0={'color':'green'}
- print(alien_0['color'])
输出:
green
字典中可包含任意数量的键 - 值对. 例如, 下面是最初的字典 alien_0, 其中包含两个键 - 值对:
- alien_0 = {'color':'green','point':5}
- new_point = alien_0['point']
- print("You just earned"+str(new_point)+"points!")
输出:
You just earned 5 points!
现在, 先访问外星人 alien_0 的颜色和点数. 如果玩家射杀这个外星人, 就可以使用上述的代码来确定玩家应获得多少个点.
先定义一个字典, 然后再从这个字典中获取与键'point'相关联的值, 并将这个值村村在变量 new_point 中. 接下来, 将这个证书转换为字符串, 并输出一条消息, 指出玩家获得多少点.
6.2.2 添加键 - 值对
字典是一种动态结构, 可随时在其中添加键 - 值对, 可依次指定字典名, 用方括号的键和相关联的值.
例: 在字典 alien_0 中添加 2 项信息: 外星人 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)
输出:
- {'color': 'green', 'points': 5}
- {'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}
我们首先定义了前面一直在使用的字典, 然后输出这个字典, 以显示其信息. 在 alien_0['x_position'] = 0 处, 我们在这字典中新增了一个键 - 值对, 其中键为'x_position', 而值为 0. 后重复这一的操作, 但使用的为'y_position', 输出修改后的字典, 我们将看到新增的键 - 值对.
这个字典的最终输出包含四个键 - 值对, 其中原来 2 额指定外星人颜色和点数, 而新增的 2 个指定位置. 注意: 键 - 值对的排列顺序与添加的顺序不同. python 不关心键 - 值对的添加顺序, 而只关心键和值对之间的关联关系.
6.2.3 先创建一个空字典
在空字典中添加键 - 值对是为了方便, 有时候必须这么做. 为此, 可使用一堆空的花括号定义一个字典, 在分行添加各个键 - 值对. 例:
- alien_0 = {}
- alien_0['color'] = 'green'
- alien_0['point'] = 5
- print(alien_0)
输出:
{'color': 'green', 'point': 5}
这里首先定义空字典 alien_0, 再在其中添加颜色和点数, 得到前述示例的字典.
使用字典来存储用户听得数据或在编写能自动生成大量键 - 值对的代码时, 通常都需要先定义一个空字典.
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']+".")
输出:
- The alien is green.
- The alien is now yellow.
我们首先定义一个表示外星人 alien_0 的字典, 其中只包含外星人的颜色. 接下来, 将与键'color'相关联的值改为'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
- #x 新位置等于老位置加上增量
- alien_0['x-position'] = alien_0['x-position']+ x_increment
- print("new x-position:"+str(alien_0['x-position']))
输出:
- Original x-position: 0
- new x-position: 2
我们首先定义一个外星人, 其中包含初始的 X 坐标和 Y 坐标, 以及速度'medium'. 出于简化考虑, 省略颜色和点数. 还输出了 x_position 的初始值, 让用户明白外星人向右移动多远.
在 if 语句处, 使用一个 if-elif-else 结构来确定外星人向右移动多远, 并将这个值存储在变量 x_increment 中. 如果外星人速度为'slow', 将向右移动 1 个单位, 依次类推. 在确定移动量后, 将其与 x_position 的当前值相加, 再讲结果关联到字典中的键 x_position. 由于这是一个中等速度, 所以其位置向右移动 2 单位.
同理, 修改 alien_0 = fast. 可使用 if-elif-else 结构将更大的赋值给 x_increment.
6.2.5 删除键 - 值对
对于字典不在需要的信息, 可使用 del 语句将相应的键 - 值对彻底删除. 使用 del 语句时, 必须制定字典名和要删除的键. 例:
- alien_0 = {'color':'green','point':5}
- print(alien_0)
- del alien_0['point']
- print(alien_0)
输出:
- {'color': 'green', 'point': 5}
- {'color': 'green'}
在 del 语句的代码行让 python 将键'point'从字典 alien_0 中删除, 同事删除与这件想关联的值. 输出表明, 建'point'及值 5 都已从字典中删除, 但其他键 - 值对未受影响.
注意: 删除的键 - 值对永远消失
6.2.6 由类似对象组成的字典
字典存储的是一个对象 (游戏中的一个外星人) 的多种信息, 但你也可以使用字典来存储众多对象的同一种信息. 例: 假设你要调查很多人, 询问他们最喜欢的编程语言, 可使用一个字典来存储这种简单的结果.
- favorite_languages={'jen':'python',
- 'sarah':'c',
- 'edward':'ruby',
- 'phil':'python',}
如上所示, 我们将一个较大的字典放在多行中. 其中每个键都是一个被调查的名字, 而每个值都是被调查则喜欢的语言, 确定需要使用多行来定义字典时, 再输入左花括号后按回车键, 再在下一行缩进 4 个空格, 指定第一个人键 - 值对, 并在它后加上一个逗号. 再按回车键时, 文本编辑将自动缩进后续键 - 值对, 且缩进量与第一个键 - 值对相同.
定义好字典后, 在最后一个键 - 值对的下一行添加一个右花括号, 并缩进 4 个空格, 使其与字典的键对齐. 另外一种是在最后一个键 - 值对后也加上逗号, 为以后在下一行添加键 - 值对做准备.
注意: 对于较长的列表和字典, 大多数编辑器都有以类似的方式设置格式功能. 对于较长的字典, 还有其他一些可行的格式设置方式, 因此在编辑器或其他源代码中, 可能会看到稍微不同的格式设置.
- favorite_languages = {'jen':'python',
- 'sarah':'c',
- 'edward':'ruby',
- 'phil':'python',}
- print("Sarah's favorite language is "+
- favorite_languages['sarah'].title()+
- ".")
输出:
Sarah's favorite language is C.
以上演示如何将较长的 print 语句分成多行. 单词 print 比大多数字典名都短, 一次输出的第一部分紧跟在左括号后面是合理的.
6.3 遍历字典
鉴于字典可能包含大量的数据, python 支持对字典遍历. 字典遍历有多种方式: 可遍历字典的作用键 - 值对, 键或值.
6.3.1 遍历所有的键 - 值对
- user_0 = {
- 'username':'efermi',
- 'first': 'enrico',
- 'last': 'fermi',
- }
- for key, value in user_0.items(): #使用变量 for k,v in user_0.item(),k,v 为任意变量
- print("\nKey:"+ key)
- print("Value:"+ value)
输出:
- Key: username
- Value: efermi
- Key: first
- Value: enrico
- Key: last
- Value: fermi
如 for 所示, 要编写用于遍历字典的 for 循环, 可声明两个变量, 用于存储键 - 值对中的键和值. 对于这两个变量, 可使用任意名称. 下面的代码使用了简单的变量名, 亦可行.
for 语句的第二部分包含字典名和方法 item(), 它返回一个键 - 值对列表. 接下来, for 循环一次将每个键 - 值对存储到指定的两个变量中. 在前面的示例中, 我们使用这两个变量来输出每个键及其相关联的值. 第一条 print 语句中的 "\n" 确保在输出每个键 - 值对前都插入一个空行. 注: items 方法是将字典中所有的项以列表的形式返回, 列表中的每一项都是以键值对的形式表现的. 但其返回的次序可能不一样.
注意: 几遍遍历字典时, 键 - 值对的返回顺序也与存储顺序不同. python 不关心键 - 值对的存储顺序, 而只跟踪键和值之间的关联关系.
- favorite_languages={
- 'jem': 'python',
- 'sarah': 'c',
- 'edward': 'ruby',
- 'phil': 'python',}
- for name,language in favorite_languages.items():
- print(name.title()+ "'s favorite language is"
- +language.title()+ ".")
输出:
- Jem's favorite language isPython.
- Sarah's favorite language isC.
- Edward's favorite language isRuby.
- Phil's favorite language isPython.
for 循环的代码让 python 遍历字典中的每个键 - 值对, 并将键存储在变量 name 中, 而将值存储在变量 language 中. 后 print 输出语句, 执行要求.
6.3.2 遍历字典中的所有键
在不需要使用字典中的值时, 方法 keys()很有效.
- favorite_languages={
- 'jem': 'python',
- 'sarah': 'c',
- 'edward': 'ruby',
- 'phil': 'python',}
- for name in favorite_languages.keys():
- print(name.title()+ ".")
输出:
- Jem.
- Sarah.
- Edward.
- Phil.
for 循环的代码让 python 提取字典 favorite_languages 中的所有键, 并依次将他们存储到变量 name 中. 输出列出每个被调查者名字.
遍历字典时, 会默认遍历所有键. 因此, 如果价格上述代码中 for name in favorite_languages.keys():y 替换为 for name in favorite_languages:, 输出将不变. 如果显式的使用方法 key()可让代码更容易理解.
- favorite_languages={
- 'jem': '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() +"!")
输出:
- Jem
- Sarah
- Hi Sarah, I see your favorite language is C!
- Edward
- Phil
- Hi Phil, I see your favorite language is Python!
首先创建 friends 列表, 其中包含要通过输出的消息, 指出喜欢语言的朋友. 在循环中, 我们输出每个人的名字, 并检查当前的名字是否在列表 friends 中. 如果在列表中, 就输出一条特殊问候语, 其中包含这位朋友喜欢的语言. 为访问虚幻的语言, 我们使用字典名, 并将变量 name 的当前值作为键. 可实现每个人的名字都会被输出, 只对朋友输出特殊消息.
6.3.3 按顺序遍历字典中的所有键
字典会明确的记录键和值的关联关系, 但获取字典的元素时, 获取顺序是不可预测的. 如果要以特定的顺序返回元素, 一种方法是在 for 循环中对返回的键进行排序, 为此可以使用函数 sorted()来获得特定排列的键列表副本:
- favorite_languages={
- 'jem': 'python',
- 'sarah': 'c',
- 'edward': 'ruby',
- 'phil': 'python',}
- for name in sorted(favorite_languages.keys()):
- print(name.title() + ", thank you for taking the poll.")
输出:
- Edward, thank you for taking the poll.
- Jem, thank you for taking the poll.
- Phil, thank you for taking the poll.
- Sarah, thank you for taking the poll.
这条 for 语句类似于其他 for 语句, 但对方法 dictionary.keys()的结果调用函数 sorted(). 这让 python 列出字典中所有的键, 并遍历前对这个列表进行排序.
6.3.4 遍历字典中所有的值
如果感兴趣的主要是字典中包含的值, 可以使用方法 value(), 它返回一个列表, 而不包含任何键, 例:
- favorite_languages={
- 'jem': 'python',
- 'sarah': 'c',
- 'edward': 'ruby',
- '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
- Ruby
- Python
这条 for 语句提取字典中国的每个值, 并将他们依次存储到变量 language 中, 通过输出这些值, 其中包含被调查者选择的各种语言. 该种方法提取字典中所有的值, 而没有考虑是否重复.
为剔除重复, 可使用稽核(set). 集合类似于列表, 单每个元素都必须是独一无二的:
- favorite_languages={
- 'jem': 'python',
- 'sarah': 'c',
- 'edward': 'ruby',
- 'phil': 'python',}
- print("The following languages have been mentioned:")
- for language in set(favorite_languages.values()): #set 为剔除重复
- print(language.title())
通过对包含重复元素的列表调用 set(), 可让 python 找出列表中独一无二的元素, 并使用这些元素来创建一个集合. 在 for 函数处, 我们使用 set()来提取 favorite_languages.value()中不同的语言.
6.4 嵌套
将一系列字典存储在列表中, 或将列表作为值存储在字典中, 称之为嵌套. 可以在列表中嵌套字典, 在字典中嵌套列表甚至在字典中嵌套字典.
6.4.1 字典列表
字典 alien_0 保暖哈一个外新人的各种信息, 但无法存储第二个外星人信息. 如何管理成群结队的外星人, 一种办法是穿甲一个外星人列表, 其中每个外星人都是一个字典, 包含有关该外星人的各种信息. 例:
- alien_0 = {'color':'green', 'point': 5}
- alien_1 = {'color':'yellow', 'point': 10}
- alien_2 = {'color':'red', 'point': 15}
- aliens = [alien_0, alien_1, alien_2]
- for alien in aliens:
- print(alien)
输出:
- {'color': 'green', 'point': 5}
- {'color': 'yellow', 'point': 10}
- {'color': 'red', 'point': 15}
首先创建 3 个字典, 其中每个字典都表示一个外星人. aliens 列表处, 将这字典都放到列表中, 最后遍历这列表, 并将每个外星人都输出.
更符合现实情形是, 外星人不止 3 个, 且每个外星人都是使用代码自动生成的. 下列示例中, 我们使用 range()生成 30 个外星人:
- # 创建一个用于存储外星人的空列表
- aliens = []
- # 创建 30 个绿色外星人
- for alien_number in range(30):
- new_alien = {'color':'green', 'points':'5', 'speed':'slow'}
- aliens.append(new_alien)
- # 显示前 5 个外星人
- for alien in aliens[:5]:
- print(aliens)
- print("...")
- print("Total number of alines:"+str(len(aliens)))
我们首先创建一个空列表, 用于存储厦门创建的所有外星人. 在第一个 for 循环处, range()返回一系列数字, 其唯一的用途是告诉 python 我们需要重复着循环多少次. 每次执行这个循环时, 都创建一个外星人 new_alien. 并将其附加到 aliens 末尾. 在 for alien in alien[:5]:, 使用一个切片来输出钱 5 个外星人; 最后, 输出这个列表的长度, 证明实际创建了 30 个外星人.
这些外星人都是相同的, 但在 python 看来, 每个外星人都是独立的, 让我们能够独立的修改每个外星人.
随着游戏的进行, 外星人的速度回加快, 必要时, 可以使用 for 循环和 if 语句来修改某些外星人的颜色. 例如
- aliens = []
- 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['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', 等.
6.4.2 在字典中存储列表
以下示例中, 存储 pizza 的两方面信息: 外皮类型和配料列表. 其中配料列表时一个月键'toppings'相关联的值. 要访问该列表, 我们使用字典名和键'toppings', 就像访问字典中的其他值一样. 将返回一个配料列表, 而不是单个值:
- # 存储所点 pizza 的信息
- pizza = {
- 'crust':'thick',
- 'toppings':['mushrooms','extra cheese'],
- }
- # 概述所点 pizza
- print("You ordered a" + pizza['crust'] + "-curst pizza" +
- "with the following toppings:")
- for topping in pizza['toppings']:
- print("\t"+topping)
输出:
- You ordered a thick-curst pizza with the following toppings:
- mushrooms
- extra cheese
首先创建一个字典, 其中存储有缘客户所点 pizza 的信息. 在这个字典中, 一个键是'toppings', 与之相关联的值是一个列表, 其中存储顾客所要求添加配料, 即概述配料. 为输出配料, 我们用一个 for 循环,. 为访问配料列表, 我们使用键'topppings'.
每当需要在字典中将一个键关联到多个值时候, 都可以在字典中嵌套一个列表. 因此, 在遍历还字典的 for 循环中, 我们需要再使用一个 for 循环来遍历与被调查者相关联的语言列表.
- 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())
输出:
- Jen's favorite languages are
- Python
- Ruby
- Sarah's favorite languages are
- C
- Edward's favorite languages are
- Ruby
- Go
- Phil's favorite languages are
- Python
- Haskell
如上所示, 与每个名字相关联的值都是以一个列表. 注意, 有些人喜欢一种, 有些人喜欢多种. 使用第一个 for 循环遍历字典时, 我们使用变量 languages 来存储字典中的每个值, 因为我们知道这些值都是列表. 在遍历字典的主循环中, 再次使用一个 for 循环来遍历每个人喜欢的列表.
可进一步改进这个程序, 可在遍历字典的 for 循环开头添加一条 if 语句, 通过查看 len(languages)的值来确定当前的被调查者喜欢的语言是否有多种. 如果他喜欢的语言有多种, 可以箱以前一样显示输出; 如果只有一种, 就修改相应的输出措辞.
注意: 列表和字典的嵌套层级不应太多.
6.4.3 在字典中存储字典
在字典中, 嵌套字典, 代码可能很快复杂起来. 例:
- users = {
- 'aeinstein': {
- 'first': 'albert',
- 'last': 'einstin',
- '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())
输出:
- Username: aeinstein
- Full name: Albert Einstin
- Location: Princeton
- Username: mcurie
- Full name: Marie Curie
- Location: Paris
我们首先定义一个 users 的字典, 其中包含两个键: 用户名'aeinstein'和'mcurie'; 与每个键相关联的值都是一个字典, 其中包含用户的名, 姓居住地. 在 for 循环, 遍历字典 users, 让 python 依次将每个键存储在变量 username 中, 并依次与当前键相关联的字典存储在变量 user_info 中. 在主循环内部 print("\nUsername:" + usename), 我们先输出用户名.
在 Full_name = user_info['first'] + "" + user_info['last']处, 我们开始访问内部字典. 变量 user_info 包含用户信息字典, 而该字典包含三个键:'first',''last','location'; 然后输出有关用户的简要信息.
注意: 表示每位用户字典的结构都相同, 这样使得嵌套处理起来更容易. 如果表示每位用户字典都包含不同键, for 循环内部的代码将更复杂.
来源: http://www.bubuko.com/infodetail-2720161.html