Class-6 字典

Posted 2020-12-28 mack-yang

字典可存储的信息几乎不受限制，因此遍历字典中的数据将为重点。本章将学习存储字典列表。存储列表的字典和存储字典的字典。字典将为准确的为各种真实物体建模。

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("
Key: "+ key)
    print("Value: "+ value)
输出：

Key: username
Value: efermi

Key: first
Value: enrico

Key: last
Value: fermi

如for所示，要编写用于遍历字典的for循环，可声明两个变量，用于存储键-值对中的键和值。对于这两个变量，可使用任意名称。下面的代码使用了简单的变量名，亦可行。

for 语句的第二部分包含字典名和方法item()，它返回一个键-值对列表。接下来，for循环一次将每个键-值对存储到指定的两个变量中。在前面的示例中，我们使用这两个变量来输出每个键及其相关联的值。第一条print语句中的“ ”确保在输出每个键-值对前都插入一个空行。注：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("	"+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("
"+ name.title()+ "‘s favorite languages are")
    for language in languages:  #注意缩进
        print("	"+ 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("
Username: "+username)
    full_name = user_info[‘first‘] +" " +user_info[‘last‘]
    location = user_info[‘location‘]
    
    print("	Full name： "+full_name.title())
    print("	Location: "+ 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(“ Username:” + usename),我们先输出用户名。

在Full_name = user_info[‘first‘] + “ ” + user_info[‘last‘]处，我们开始访问内部字典。变量user_info包含用户信息字典，而该字典包含三个键：‘first’、‘’last‘、’location‘；然后输出有关用户的简要信息。

注意：表示每位用户字典的结构都相同，这样使得嵌套处理起来更容易。如果表示每位用户字典都包含不同键，for循环内部的代码将更复杂。