在本章中，你将学习让你能够将相关信息关联起来的Python字典，以及如何访问和修改字典中的信息。字典可存储的信息量几乎不受限制，因此我们需要知道如何遍历字典中的数据，以及如何存储字典中的列表、列表的字典和字典的字典。
理解字典后，你将能够更准确地为各种真实物体建模。可以创建一个表示人的字典，然后在其中存储你想存储的任何信息：包括姓名、年龄、地址，以及可以描述这个人的任何其他方面。还能在字典中存储任意两种相关的信息，如一系列单词及其含义、一系列人名及其喜欢的数、一系列山脉及其海拔等。
第六章 字典
6.1 一个简单的字典
#定义一个字典
friend = {'Stock':32,'Smith':19,'Alice':23};
#打印字典元素
print(friend['Alice']);
print(friend['Smith']);
print(friend['Stock']);
#输出结果：
23
19
32
与大多数编程概念一样，要熟练使用字典，也需要一段时间的练习。使用字典一段时间后，你就会明白为何它们能够高效地模拟现实世界中的情形。
6.2 使用字典
在Python中，字典是一系列键—值对。每个键都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。
在Python中，字典用放在花括号（{}）中的一系列键值对表示。
键值对包含两个相互关联的值。当你指定键时，Python将返回与之关联的值。键和值之间用冒号分隔，而键值对之间用逗号分隔。在字典中，想存储多少个键值对都是可以的。
6.2.1 访问字典中的元素
要获取与键关联的值，可指定字典名并把键放在后面的方括号内。
#定义一个字典
friend = {'Stock':32,'Smith':19,'Alice':23};
#打印字典元素
print(friend['Alice']);
print(friend['Smith']);
print(friend['Stock']);
#输出结果：
23
19
32
定义一个字典friend，里面包含三对键值对【‘Stock’:32，‘Smith’:19，‘Alice’:23】，打印【print(friend[‘Alice’])，print(friend[‘Smith’])，print(friend[‘Stock’])】分别得到对应的键值对【23，19，32】。
上述的代码首先定义了一个字典，然后从这个字典中获取与键’Stock’、'Smith’以及’Alice’关联的值【23、19、32】。
6.2.2 添加键值对
字典是一个动态结构，可随时在其中添加键值对。要添加键值对，可以依次指定字典名、用方括号括起来的键和该键关联的值。
#定义一个字典
friend = {'Stock':32,'Smith':19,'Alice':23};
#打印字典元素
print(friend['Alice']);
print(friend['Smith']);
print(friend['Stock']);
#输出键值对
print(friend);
#添加键值对
friend['Frik'] = 20;
friend['Alick'] = 19;
#将添加的键值对与旧的键值对打印出来
print(friend)
#输出结果：
#打印字典元素
23
19
32
#输出键值对
{'Stock': 32, 'Smith': 19, 'Alice': 23}
#将添加的键值对与旧的键值对打印出来
{'Stock': 32, 'Smith': 19, 'Alice': 23, 'Frik': 20, 'Alick': 19}
字典会保留定义时的元素排列顺序。如果将字典打印出来或遍历其元素，将发现元素的排列顺序与其添加的顺序是相同的。
6.2.3 从创建一个空字典开始
有时候，创建一个空的字典，然后再在空的字典中添加键值对很方便甚至非常的有必要。为此，我们可以先使用一对花括号定义一个空的字典，再分行添加各个键值对。
#定义一个空的键值对
friends = {};
friends['小王'] = 19;
friends['老王'] = 32;
friends['Alice'] = 18;
friends['小赵'] = 25;
friends['雨儿'] = 27;
print(friends);
#将定义好的字典，经过添加数据后，打印出来
{'小王': 19, '老王': 32, 'Alice': 18, '小赵': 25, '雨儿': 27}
如果要使用字典来存储用户提供的数据或者编写能自动生成大量键值对的代码，通常需要先定义一个空的字典。
6.2.4 修改字典中的值
要修改字典中的值，可依次指定字典名、用方括号括起来的键和与该键关联的新值。
#修改键值
print(f"雨儿的年龄不是{friends['雨儿']}岁。");
friends['雨儿'] = '25';
print(f"雨儿的年龄应该是{friends['雨儿']}岁。");
#输出结果：
雨儿的年龄不是27岁。
雨儿的年龄应该是25岁。
一个有趣的例子：
对一个能够以不同速度移动的外星人进行位置跟踪。为此，存储该外星人的当前速度，并据此确定该外星人应该向右移动多远。
#定义一个字典
alien = {'x_position' : 0, 'y_position' : 25, 'speed' : 'medium'};
print(f"Original position : {alien['x_position']}.")
#向右移动外星人
#根据当前速度，确定将外星人向右移动多远
if alien['speed'] == 'slow':
x_increment = 1;
elif alien['speed'] == 'medium':
x_increment = 2;
else:#表示外星人移动速度非常快
x_increment = 3;
#将外星人以前的位置加上移动的距离，就是外星人现在的位置
alien['x_position'] = alien['x_position'] + x_increment;
print(f"New position: {alien['x_position']}.")
#输出结果：
Original position : 0.
New position: 2.
我们首先定义了一个外星人，其中包含初始的x坐标和y坐标，还有速度’medium’。我们还打印了x_position的初始值，旨在让用户知道这个外星人向右移动了多远。
在上面的程序中，使用了一个if-elif-else结构来确定外星人应向右移动多远，并将这个值存储在变量x_increment中。如果外星人的速度为’slow’，它将向右移动一个单位；如果速度为’medium’，将向右移动两个单位；如果为’fast’，将向右移动三个单位。确定移动量后，将其与x_position的当前值相加，再将结果关联到字典中的键x_position。由于这是一个速度中等的外星人，因此其位置将向右移动两个单位。
6.2.5 删除键值对
对于字典中不再需要的信息，可使用【del】语句将相应的键值对彻底删除。在使用del语句时，必须指定字典名和要删除的键。
#定义一个字典
friend = {'Stock':32,'Smith':19,'Alice':23};
#打印这个字典
print(friend);
#要删除字典friend中的'Alice'以及它的值。
del friend['Alice'];
#输出剩下的字典，看是否将'Alice'以及其值删除
print(friend);
#输出结果
#打印这个字典
{'Stock': 32, 'Smith': 19, 'Alice': 23}
#输出剩下的字典，看是否将'Alice'以及其值删除
{'Stock': 32, 'Smith': 19}
使用del语句，Python将从字典friend中删除’Alice’以及该键对应的值’23’。由输出可知，del语句后面的键值对被删除。
注意：使用del语句，将彻底且永远删除字典中的键值对。
6.2.6 由类似的对象组成的字典
由前面的实例可知，字典中存储的是一个对象的多种信息，但可以使用字典来存储众多对象的同一种信息。
假设，我们周围很多人喜欢编程，用一个字典来将这些人喜欢的编程语言存储起来。
#定义一个字典
favorite_language = {'老王' : 'SQL',
'小李' : 'Python',
'小赵' : 'Java',
'小巴' : 'HTML',
'杨总' : 'C++',
};
print(favorite_language);
#输出结果：
{'老王': 'SQL', '小李': 'Python', '小赵': 'Java', '小巴': 'HTML', '杨总': 'C++'}
我们将一个较大的字典放在了多行中。其中每个键都是一个被调查者的名字，而每个值都是被调查者喜欢的语言。确定需要使用多行来定义字典时，在输入左花括号后按回车键，再在下一行缩进多个空格，指定第一个键—值对，并在它后面加上一个逗号。此后你再次按回车键时，文本编辑器将自动缩进后续键—值对，且缩进量与第一个键—值对相同。
定义好字典后，在最后一个键—值对的下一行添加一个右花括号，并缩进多个空格，使其与字典中的键对齐。另外一种不错的做法是在最后一个键—值对后面也加上逗号，为以后在下一行添加键—值对做好准备。注意 对于较长的列表和字典，大多数编辑器都有以类似方式设置其格式的功能。
对于较长的列表和字典，大多数编辑器都有以类似方式设置其格式的功能。对于较长的字典，还有其他一些可行的格式设置方式，因此在你的编辑器或其他源代码中，你可能会看到稍微不同的格式设置方式。
6.2.7 使用get()来访问值
使用放在方括号内的键从字典中获取感兴趣的值，可能会引发问题：如果指定的键不存在，就会出错。
#定义一个字典
favorite_language = {'老王' : 'SQL',
'小李' : 'Python',
'小赵' : 'Java',
'小巴' : 'HTML',
'杨总' : 'C++',
};
print(favorite_language);
print(favorite_language['王总']);
输出结果：
{'老王': 'SQL', '小李': 'Python', '小赵': 'Java', '小巴': 'HTML', '杨总': 'C++'}
#报错的内容
Traceback (most recent call last):
File "f:\DataAnalysis\Python\VS_Code\Number_one_Basic_Knowledge\six.py", line 64, in <module>
print(favorite_language['王总']);
~~~~~~~~~~~~~~~~~^^^^^^^^
KeyError: '王总'
这将导致Python现实traceback，指出存在键值错误（KeyError）。
就字典而言，为避免出现这样的错误，可使用get()方法在指定的键不存在时返回一个默认值。get()方法的第一个参数用于指定键，是必不可少的；第二个参数为当指定的键不存在时要返回的值，是可选的：
#定义一个字典
favorite_language = {'老王' : 'SQL',
'小李' : 'Python',
'小赵' : 'Java',
'小巴' : 'HTML',
'杨总' : 'C++',
};
print(favorite_language);
#print(favorite_language['王总']);
#Traceback (most recent call last):
# File "f:\DataAnalysis\Python\VS_Code\Number_one_Basic_Knowledge\six.py", line 64, in <module>
# print(favorite_language['王总']);
# ~~~~~~~~~~~~~~~~~^^^^^^^^
#KeyError: '王总'
print(favorite_language.get('王总', '在字典中不存在这个人。'));
#输出结果：
{'老王': 'SQL', '小李': 'Python', '小赵': 'Java', '小巴': 'HTML', '杨总': 'C++'}
在字典中不存在这个人。
如果指定的键有可能不存在，应该考虑使用get()方法，而不是使用方括号表示法。
注意：在调用get()时，如果没有指定第二个参数且指定的键不存在，Python将返回None，这个特殊的值表示没有相应的值。这并非错误，None只是一个表示所需值不存在的特殊值。
6.3 遍历字典
一个Python字典可能只包含几个键值对，也可能包含数百万个键值对。鉴于字典可能包含大量数据，Python支持对字典进行遍历。字典用于以各种方式存储信息，因此有多种遍历方式：即可遍历字典的所有键值对，也可遍历键或值。
6.3.1 遍历所有的键值对
在探索各种遍历方法时，先看一个字典，它用于存储有关用户喜欢的编程语言信息，这个字典存储一个用户的用户名以及各自喜欢的编程语言：
#定义一个字典
favorite_language = {'老王' : 'SQL',
'小李' : 'Python',
'小赵' : 'Java',
'小巴' : 'HTML',
'杨总' : 'C++',
'老李' : 'JavaScipt',
};
#输出字典
print(favorite_language);
#遍历字典favorite_language
for key,value in favorite_language.items():
print(f"\nkey : {key}");
print(f"value : {value}\n");
print("字典打印完成！")
要编写遍历字典的for循环，可声明两个变量，分别用于存储键值对中的键和值。这两个变量可以使用任意名称。如下：
for key,value in favorite_language.items():
for语句的第二部分包含字典名和方法items()，这个方法返回一个键值对列表。接下来，for循环依次将每个键值对赋给指定的两个变量。在这个实例中，使用两个变量来打印每个键所对于的值。其中第一个函数调用print()中的’\n’确保在输出每个键值对前插入一行空格；而后一个是确保每一个键值对输出后，插入一个空格：
#输出字典
{'老王': 'SQL', '小李': 'Python', '小赵': 'Java', '小巴': 'HTML', '杨总': 'C++', '老李': 'JavaScipt'}
#遍历字典favorite_language
key : 老王
value : SQL
key : 小李
value : Python
key : 小赵
value : Java
key : 小巴
value : HTML
key : 杨总
value : C++
key : 老李
value : JavaScipt
字典打印完成！
也可以这样来输入：如果遍历字典favorite_language，将得到其中每个人的姓名以及各自喜欢的编程语言。因为字典favorite_language中的键都是人名以及编程语言，因此在循环中使用变量name以及language而不是key和value，能让初学者甚至资深编程者更容易看到其中的意义，如下：
for name,languang in favorite_language.items():
print(f"{name}最喜欢且擅长的语言是{languang}。\n")
print("字典打印完成！")
#输出结果
老王最喜欢且擅长的语言是SQL。
小李最喜欢且擅长的语言是Python。
小赵最喜欢且擅长的语言是Java。
小巴最喜欢且擅长的语言是HTML。
杨总最喜欢且擅长的语言是C++。
老李最喜欢且擅长的语言是JavaScipt。
字典打印完成！
上面的代码，让Python遍历字典中的每个键值对，并将键赋给变量name，将值赋给language。上面的描述性名称让人能够非常轻松地明白函数调用print()是做什么的。
6.3.2 遍历字典中的所有键
在不需要使用字典中的值时，keys()方法很有用。因为key()方法，可以将字典中的所有键都打出来。
favorite_language = {'老王' : 'SQL',
'小李' : 'Python',
'小赵' : 'Java',
'小巴' : 'HTML',
'杨总' : 'C++',
'老李' : 'JavaScipt',
};
for name in favorite_language.keys():
print(name)
这个for循环让Python提取字典favorite_language中的所有键，并依次将他们赋给变量name。输出列出每个人的名字。
#输出结果：
老王
小李
小赵
小巴
杨总
老李
在遍历字典时，会默认遍历所有的键。因此将上述的代码更改为以下，输出的结果也是不变的：
for name in favorite_language:
如果显示使用keys()方法，能让代码更容易理解，这里可以按个人的编程习惯来。
#定义一个字典
favorite_languages = {
'alice' : 'Java',
'stock' : 'Php',
'老王' : 'C++',
'小李' : 'C#',
'小赵' : 'Python',
'小杨' : 'SQL',
}
#定义一个列表
my_friends = ['alice' , '小赵' , 'Smith'];
#要求，将你的朋友喜欢的编程语言打印出到控制台
for name in favorite_languages.keys():
print(f"Hello, {name}.");
if name in my_friends:
print(f"Hello, {name}，我知道你喜欢{favorite_languages[name].title()}。")
print('这真是一件令人高兴的事情。\n');
#输出结果
Hello, alice.
Hello, alice，我知道你喜欢Java。
Hello, stock.
Hello, 老王.
Hello, 小李.
Hello, 小赵.
Hello, 小赵，我知道你喜欢Python。
Hello, 小杨.
这真是一件令人高兴的事情。
在上面的例子中，我们首先创建一个字典favorite_languages，将用户以及用户喜欢的编程语言都存到字典里面；然后再创建一个列表my_friends，将自己的朋友存到这个列表里面。使用for循环来遍历字典favorite_languages，然后再循环内使用条件测试语句进行判断，如果朋友存在列表my_friends中就继续执行下一部分，如果没有则不执行。
keys()方法并非只能用于遍历：实际上，它会返回一个列表，其中包含字典中的所有键。
if 'Frick' not in my_friends:
print("Frick, please try again！")
6.3.3 按特定的顺序遍历字典中的所有键
遍历字典时将按插入元素的顺序返回其中的元素，但是在一些情况下，你可能要按与此不同的顺序遍历字典。要以特定的顺序返回元素，一种办法是在for循环中对返回的键进行排序。因此，还可能使用到sorted()函数来获得按特定顺序顺序排列的键的副本：
#定义一个字典
favorite_languages = {
'alice' : 'Java',
'stock' : 'Php',
'老王' : 'C++',
'小李' : 'C#',
'小赵' : 'Python',
'小杨' : 'SQL',
}
for name in sorted(favorite_languages.keys()):
print(f"Hello, {name.title()}，非常感谢你和我们分享你喜欢的编程经历。")
上面的for循环，就是最普通的循环，但对方法favorite_languages.keys()的结果调用sorted()函数。这让Python获得字典中的所有键，并在遍历前对这个列表进行排序。结果如下：
Hello, Alice，非常感谢你和我们分享你喜欢的编程经历。
Hello, Stock，非常感谢你和我们分享你喜欢的编程经历。
Hello, 小李，非常感谢你和我们分享你喜欢的编程经历。
Hello, 小杨，非常感谢你和我们分享你喜欢的编程经历。
Hello, 小赵，非常感谢你和我们分享你喜欢的编程经历。
Hello, 老王，非常感谢你和我们分享你喜欢的编程经历。
6.3.4 遍历字典中的所有值
如果要得到字典中的所有值，而不是键，则可以使用values()方法，它返回一个值列表，不包含任何键。
#定义一个字典
favorite_languages = {
'alice' : 'Java',
'stock' : 'Php',
'老王' : 'C++',
'小李' : 'C#',
'小赵' : 'Python',
'小杨' : 'SQL',
}
for language in favorite_languages.values():
print(language);
Java
Php
C++
C#
Python
SQL
这条for语句提取字典中的每一个值，并将他们依次赋给变量language。然后输出到控制台，就可以得到字典中的字典值。
如果字典中，含有重复的值，有时候需要去重，则需要将重复项给剔除掉，我们可以使用集合（set）。因为集合中的元素独一无二。
#定义一个字典
favorite_languages = {
'alice' : 'Java',
'stock' : 'Php',
'老王' : 'C++',
'小李' : 'C#',
'小赵' : 'Python',
'小杨' : 'SQL',
'小王' : 'Python',
'Smith' : 'Java',
}
for i in set(favorite_languages.values()):#使用集合set去重
print(i);
print('获取值完毕！！！');
#输出
C++
SQL
Java
Python
C#
Php
获取值完毕！！！
通过将包含重复元素的列表传入set()，可让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合。这里【set(favorite_languages.values())】的意思是：使用set()来提取favorite_languages.values()中不同的语言。由打印的结果可知，没有任何重复的值。
注意：可以使用一对花括号直接创建集合，并在其中用逗号分隔元素：
#定义一个集合
languages = {'Python' , 'Java' , 'C++' , 'C#' , 'JavaScipt'};
print(languages);
集合和字典相比较而言，容易让人混淆，因为它们都是使用一对花括号进行定义的。当花括号内没有键值对时，定义的就可能是集合。不同于列表和字典，集合不会以特定的顺序存储元素。
6.4 嵌套
有时候，需要将多个字典存储在列表中或将列表作为值存储在字典中，这种形式就成为嵌套。可以在列表中嵌套字典，在字典中嵌套列表，甚至在字典中嵌套字典。
6.4.1 字典列表
字典alien_0包含一个外星人的各种信息，但无法存储第二个外星人的信息，那就更不能存储其他外星人的信息了。那么如何管理这些外星人呢？目前的方法就是创建一个外星人列表，其中每个外星人都是一个字典，包含外星人的各种信息。如下：
#创建3个字典
alien_0 = {'color' : 'indigo' , 'high' : '165'};
alien_1 = {'color' : 'light indigo' , 'high' : '175'};
alien_2 = {'color' : 'green' , 'high' : '170'};
alien_3 = {'color' : ' light green' , 'high' : '173'};
#定义一个列表来存储外星人字典
aliens = [alien_0 , alien_1 , alien_2 , alien_3];
#遍历外星人
for alien in aliens:
print(alien);
print('\n外星人集合完毕！！！')
输出结果：
#遍历外星人
{'color': 'indigo', 'high': '165'}
{'color': 'light indigo', 'high': '175'}
{'color': 'green', 'high': '170'}
{'color': ' light green', 'high': '173'}
外星人集合完毕！！！
更符合实际的是，外星人成千上万，下面我们用range来随机生成30个外星人。
#用range来随机生成30个外星人
#创建一个空的列表，用于存储外星人
aliens = [];
#随机生成30个绿色的外星人
for alien in range(1,90,3):
new_alien = {'color' : 'green' , 'point' : 6 , 'speed' : 'fast'};
aliens.append(new_alien);
#显示前10个外星人
for alien in aliens[: 10]:
print(alien);
#标识换行
print('\n==================\n');
#显示生成了多少个外星人
print(f"总共生成了外星人：{len(aliens)}。");
#显示前10个外星人
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
#标识换行
==================
#显示生成了多少个外星人
总共生成了外星人：30。
在上面的实例中，首先创建一个空的列表，用于存储接下来使用for循环随机生成的30个外星人。在for循环中，使用range()函数返回一个数字列表【指定范围1到90，步长为3】，告诉Python要重复循环多少次。每次执行这个循环时，都创建一个外星人，并将这个外星人追加到列表aliens末尾，然后使用切片器来显示前十个外星人。最后打印列表的长度，以证明创建了30个外星人。
这些外星人都具有相同的特征，但在Python看来，这三十个外星人是独立的，这也能让我们能够独立修改每个外星人。
在实际的程序编写中，外星人的形态特征并不是单一的，而是多变的，也就是游戏中的升级打怪。这种情况下，我们就可以使用for循环和if语句来修改外星人的颜色，速度等。例如：需要修改前三个外星人的颜色为黄色、速度中等且值为10分，可这样做：
#创建一个空的列表，用于存储外星人
aliens = [];
#随机生成30个绿色的外星人
for alien in range(1,90,3):
new_alien = {'color' : 'green' , 'point' : 6 , 'speed' : 'fast'};
aliens.append(new_alien);
#修改外星人的颜色
for alien in aliens[:5]:
if alien['color'] == 'green':
alien['color'] = 'yellow';
alien['point'] = '10';
alien['speed'] = 'medium';
#显示前10个外星人
for alien in aliens[: 10]:
print(alien);
#显示前10个外星人
{'color': 'yellow', 'point': '10', 'speed': 'medium'}
{'color': 'yellow', 'point': '10', 'speed': 'medium'}
{'color': 'yellow', 'point': '10', 'speed': 'medium'}
{'color': 'yellow', 'point': '10', 'speed': 'medium'}
{'color': 'yellow', 'point': '10', 'speed': 'medium'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
进一步拓展：
#创建一个空的列表，用于存储外星人
aliens = [];
#随机生成30个绿色的外星人
for alien in range(1,90,3):
new_alien = {'color' : 'green' , 'point' : 6 , 'speed' : 'fast'};
aliens.append(new_alien);
#修改外星人的颜色
for alien in aliens[:5]:
if alien['color'] == 'green':
alien['color'] = 'yellow';
alien['point'] = '10';
alien['speed'] = 'medium';
#进一步拓展，将使用elif来输出颜色为yellow，速度为medium，得分为25
elif alien['color'] == 'yellow':
alien['color'] = 'red';
alien['point'] = '25';
alien['speed'] = 'fast';
#显示前10个外星人
for alien in aliens[: 10]:
print(alien);
#标识换行
print('\n==================\n');
#显示生成了多少个外星人
print(f"总共生成了外星人：{len(aliens)}。");
输出结果
#显示前10个外星人
{'color': 'yellow', 'point': '10', 'speed': 'medium'}
{'color': 'yellow', 'point': '10', 'speed': 'medium'}
{'color': 'yellow', 'point': '10', 'speed': 'medium'}
{'color': 'yellow', 'point': '10', 'speed': 'medium'}
{'color': 'yellow', 'point': '10', 'speed': 'medium'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
{'color': 'green', 'point': 6, 'speed': 'fast'}
由上面输出的结果可知，因为在列表alien里面就没有颜色为yellow的外星人，所以就不执行elif后面的语句。
6.4.2 在字典中存储列表
有时候，我们需要将列表存储到字典中，而不是将字典存储到列表中。
#定义一个字典，且该字典中包含列表
friend_language = {
'smith' : ['Python' , 'Java' , 'SQL'],
};
print(f" 敬爱的朋友{friend_language['name'].title()}，你喜欢的编程语言是：")
for language in friend_language['language']:
print(f" {language}");
print("这就是我朋友以及他们喜欢的编程语言。");
输出结果：
敬爱的朋友Smith，你喜欢的编程语言是：
Python
Java
SQL
这就是我朋友以及他们喜欢的编程语言。
首先，创建一个字典，该字典中存储一个列表，该列表存储了该用户喜欢的编程语言，使用一个print函数来打印这个用户，然后再使用for循环来打印该用户喜欢的编程语言。
#定义一个字典，且该字典中包含列表
friend_language = {
'smith' : ['Python' , 'Java' , 'SQL'],
'stock' : ['JavaScript' , 'Python' , 'C++'],
'老王' : ['C++' , 'Python' , 'C++'],
};
for name,languages in friend_language.items():
print(f"我敬爱的朋友{name.title()}，你喜欢的编程语言是：");
for language in languages:
print(f"{language.title()}");
print('\n')
print("这就是我朋友以及他们喜欢的编程语言。");
输出结果：
我敬爱的朋友Smith，你喜欢的编程语言是：
Python
Java
Sql
我敬爱的朋友Stock，你喜欢的编程语言是：
Javascript
Python
C++
我敬爱的朋友老王，你喜欢的编程语言是：
C++
Python
C++
这就是我朋友以及他们喜欢的编程语言。
在上面的例子中，每一个键关联的值都是一个列表。在遍历字典的时候，使用变量language来存储字典中的每一个值。然后在第二层循环来遍历列表中的元素。
特殊注意：列表和字典的嵌套层级不应该太多，太多，容易让人混淆。
6.4.3 在字典中存储字典
可以在字典中存储字典，但是这样会让代码相比较而言，比较复杂。
#字典中存储字典
users = {
'小赵' : {'phone' : '19987410231',
'emil' : '[email protected]',
'location' : '云南昆明'
},
'Smith' : {'phone' : '19987410541',
'emil' : '[email protected]',
'location' : '云南曲靖'
},
'Alice' : {'phone' : '19987410941',
'emil' : '[email protected]',
'location' : 'America'
},
}
#遍历键值对中的所有键值
for username,userinforation in users.items():
print(f"username : {username}");
print(f"\tuser_information : {userinforation['phone']}");
print(f"\tuser_information : {userinforation['emil']}");
print(f"\tuser_information : {userinforation['location']}");
print("\nOK!!!")
输出结果：
#遍历键值对中的所有键值
username : 小赵
user_information : 19987410231
user_information : 1443521@qq.com
user_information : 云南昆明
username : Smith
user_information : 19987410541
user_information : 1443821@qq.com
user_information : 云南曲靖
username : Alice
user_information : 19987410941
user_information : 1443827@qq.com
user_information : America
OK!!!
首先定义一个字典，名为users的字典，其中这个名为users的字典包含三个键，分别为 ‘小赵’ 、 ‘Smith’ 以及 ‘Alice’；将各自键对应的值用列表存储起来，列表存储三个键对应的手机号、邮箱以及地理位置。我们遍历整个字典users，定义一个变量username来存储字典users中的键，并将对应的键值赋给变量user_information，在循环内就将键值对打印出来，如上：
6.5 小结
- 如何定义字典；
- 如何在字典中存储信息；
- 如何访问和修改字典中的信息；
- 如何遍历字典中的所有信息；
- 嵌套（字典嵌套字典，字典嵌套列表）；
以上的内容，是本人自学Python，写的笔记，如有错误，请留言哦！！！本人会在第一时间及时更正。如果你觉得有用，请关注我，一起学习Python，一起高薪！！