【Python】Python基础内容笔记整理4：字典、对于字典的相关操作、字典与列表的嵌套

免费的清晰思维导图见上传资源压缩包，也不需要积分。

目录

1 基础概念

2 基础操作

2.1 创建字典

2.1.1 直接创建字典（包含键-值对）

2.1.1.1 普通字典

2.1.1.2 由相似对象组成的字典

2.1.2 创建空字典（创建后再添加键-值对）

2.2 访问字典中的值

2.3 添加键-值对

2.4 修改字典中的值

2.5 删除键-值对

3 遍历字典

3.1 遍历所有的键-值对：方法items()

3.2 遍历字典中的所有键

3.2.1 遍历字典中的所有键：方法keys()

3.2.2 按顺序遍历字典中所有的键：函数sorted()和方法keys()

3.3 遍历字典中的所有值

3.3.1 遍历字典中的所有值：方法values()

3.3.2 得到不重复的值：函数set()和方法values()

4 嵌套：列表与字典

4.1 列表中嵌套字典（字典列表）

4.2 在字典中存储列表

4.3 在字典中存储字典

5 课后习题

---

1 基础概念

（1）字典是一系列键-值对。

（2）可以使用键来访问与之相关联的值。

（3）与键相关联的值可以是数字、字符串、列表、字典，可将任何Python对象用作字典中的值。

字典可以存储的信息量几乎不受限制。

（4）字典使用花括号{ }表示，键和值之间使用冒号 ：分隔，而键-值对之间用逗号 ， 分隔。

（5）键-值对是两个相关联的值，指定键时，Python将返回相关联的值。

2 基础操作

2.1 创建字典

2.1.1 直接创建字典（包含键-值对）

字典可以存储一个对象的多种信息，也可以用来存储众多对象的同一种信息。示例如下：

2.1.1.1 普通字典

dictionary_name = {key_01:value_01,key_02:value_02,…}

2.1.1.2 由相似对象组成的字典

该字典存储众多对象的同一种信息（即键是不同的对象，但值是同一类信息）。

例如，你要统计班里每个人最喜欢的编程语言，就可以使用字典来存储这种简单调查的结果，代码示例如下：

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.

**注：确定需要使用多行来定义字典时，应注意如下几点：

（1）在输入左花括号后按回车键，再在下一行缩进四个空格，指定第一个键-值对，并在它后面加上一个逗号。此后你再次按回车键时，文本编辑器将自动缩进后续键-值对，且缩进量与第一个键-值对相同。

 （2）定义好字典后，在最后一个键-值对的下一行添加右花括号，并缩进四个空格，使之与字典中的键对齐。

（3）在最后一个键-值对后面也加上逗号，便于以后在下一行添加键-值对。

2.1.2 创建空字典（创建后再添加键-值对）

使用字典来存储用户提供的数据或在编写能自动生成大量键-值对时，通常要先定义一个空字典，然后再添加键-值对。

dictionary_name = {}

dictionary_name[key_01] = value_01
dictionary_name[key_02] = value_02

2.2 访问字典中的值

（1）指定字典名和放在方括号[ ]中的键。

（2）值为文本带单引号' '，值为数字不带单引号。

（3）输出数字时需要用str()转换为字符串，再与字符串一起输出。

dictionary_name = {key_01:value_01,key_02:value_02}
print(dictionary_name[key_01])

2.3 添加键-值对

（1）字典是动态结构，可以随时添加键值对。

（2）指定字典名、用方括号括起来的键和相关联的值。

（3）键-值对的排列顺序与添加顺序不同，Python只关心键和值之间的关联关系，不关心键-值对的添加顺序。

（4）可以创建空字典再向其中添加键值对，使用字典来存储用户提供的数据或在编写能自动生成大量键-值对的代码时，通常都要先定义一个空字典。

dictionary_name[key] = value

2.4 修改字典中的值

指定字典名、用方括号括起的键名以及与该键相关联的新值。

dictionary_name[key] = new_value

2.5 删除键-值对

（1）del语句将相应键值对彻底删除（永久性删除）。

（2）del语句需要指定字典名、要删除的键。

#使用del语句删除的键值对将永远消失（永久性删除）
del dictionary_name[key]

3 遍历字典

字典可用于以各种方式存储信息，因此遍历字典有多种方式：遍历字典的所有键-值对、键或值。

3.1 遍历所有的键-值对：方法items()

（1）适用于：字典存储不同键的同种类信息（值）。

（2）使用for循环遍历字典，声明两个变量，一个用于存储键-值对中的键和值，对于这两个变量可以使用任何名称。例如key,value或者k,v都可以，起名要注意让人容易明白循环的作用。

for key,value in dictionary_name.items():
    do something

items()：

方法items() 把字典中每对 key 和 value （键-值对）组成一个元组，并把这些元组放在列表中返回。此处for循环依次将每个键值对存储到指定的两个变量中。

**注：遍历字典时，键-值对的返回顺序也与存储顺序不同。Python不关心键-值对的存储顺序，只跟踪键和值之间的关联关系。 

3.2 遍历字典中的所有键

3.2.1 遍历字典中的所有键：方法keys()

（1）适用于：不需要使用字典中的值。

（2）使用for循环遍历字典，声明一个变量即可，存储键值对中的键，对于这个变量可以使用任何名称。

#使用方法keys()可以使循环的目的更一目了然
for key in dictionary_name.keys():
    do something

#但不使用方法keys()也可以，遍历字典时，Python会默认遍历所有的键，因此，如果省略keys()输出也将不变
for key in dictionary_name:
    do something

keys() :

方法keys()以列表的形式返回一个字典所有的键。

**方法keys()并非只能用于遍历，其返回一个包含字典中所有键的列表，除了遍历字典得到所有键以外，还可以合适某个键是否在这个列表（字典）当中。

#若某元素是字典的键
if element_name in dictionary_name.keys():
    do something

#若某元素不是字典的键
if element_name not in dictionary_name.keys():
    do something

3.2.2 按顺序遍历字典中所有的键：函数sorted()和方法keys()

（1）适用于：需要获取字典元素的顺序时。

（2）使用for循环对返回的键进行排序，可以使用函数sorted（）来获得按特定顺序排列的键列表表的副本。

for key in sorted(dictionary_name.keys()):
    do something

sorted()：

函数sorted()是按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序。

sorted(list_name)是按字母顺序排序元素，sorted(list_name,reverse=True)是按字母倒序排列元素。 

3.3 遍历字典中的所有值

3.3.1 遍历字典中的所有值：方法values()

（1）适用于：需要只获取字典的值时。

（2）使用for循环遍历字典，声明一个变量即可，存储键值对中的值，对于这个变量可以使用任何名称。

for value in dictionary_name.values():
    do something

 values()：

方法values()是以列表的形式返回字典中的所有值。

3.3.2 得到不重复的值：函数set()和方法values()

for value in set(dictionary_name.values()):
    do something

**注：使用方法values()遍历值只是提取字典中的所有值，而没有考虑是否重复。如果涉及的值很多，且可能有许多重复项时，可以使用集合set()来剔除重复项。

集合set：

集合类似于列表，但每个元素都必须时独一无二的。

通过对包含重复元素的列表调用set()，可让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合。

set()：

函数set()会创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

set([iterable])：iterable可迭代对象，即列表、元组、字典、字符串和集合。

·什么是迭代算法？

算法设计与分析--迭代算法_吃饱了想撑死的博客-CSDN博客

4 嵌套：列表与字典

将一系列字典存储在列表里，或将列表作为值存储在字典中，称为嵌套。

可以在（1）列表中嵌套字典（2）在字典中嵌套列表（3）在字典中嵌套字典

4.1 列表中嵌套字典（字典列表）

适用于：①列表中包含大量字典②所有字典结构都相同③可以使用相同的方式处理其中的每个字典。

#这段不好用统一的代码解释，打一段书上的示例aliens.py

#任意创建三个不同的外星人，并添加进列表aliens中
#此处创建的所有字典结构相同
alien_0 = {'color':'green','points':5,'speed':'slow'}
alien_1 = {'color':'yellow','points':10,'speed':'medium'}
alien_2 = {'color':'red','points':15,'speed':'slow'}
aliens = [alien_0,alien_1,alien_2]

#使用for循环自动创建7个外星人，并添加进列表aliens中
#此处range()的作用：执行多少次循环，这里执行了7次
for aliens_number in range(7):
    new_alien = {'color':'pink','points':20,'speed':'fast'}
    aliens.append(new_alien)

#输出当前列表
#因为这里是列表中嵌套了很多字典，所以我们需要使用for循环才能看到列表中字典的具体信息
print("The Original List:")
for alien in aliens:
    print(alien)

#修改外星人参数
#该列表中很多外星人具有相同的特征，但在Python看来，每个外星人都是独立的，这能让用户独立的修改每个外星人
for alien in aliens[:3]:
    if alien['color'] == 'green':
        alien['color'] = 'pink'
        alien['points'] = 20
        alien['speed'] = 'fast'
    elif alien['color'] =='yellow':
        alien['color'] = 'green'
        alien['points'] = 5
        alien['speed'] = 'slow'
    else:
        alien['color'] = 'yellow'
        alien['points'] = 10
        alien['speed'] = 'medium'

#输出当前列表
print("The Modified List:")
for alien in aliens:
    print(alien)


>>The Original List:
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'yellow', 'points': 10, 'speed': 'medium'}
{'color': 'red', 'points': 15, 'speed': 'slow'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
The Modified List:
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'yellow', 'points': 10, 'speed': 'medium'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}
{'color': 'pink', 'points': 20, 'speed': 'fast'}

进程已结束，退出代码为 0

其中需要学习的内容有：

（1）range（）：可以返回一系列数字，用在for循环中主要用于定义循环会运行多少次。

#该循环会运行n次
for element in range(n):
    print(".")

还可以搭配一个len()函数最后验证一下循环了几次。

#输出循环了多少次
print("Total number of circulation:" + str(len(list)))

（2）字典列表中的字典都具有相同特征，但Python认为每个字典都是独立的，所以可以独立修改每个字典。

（3）可以使用if-elif-else结构修改字典内容。

（4）实际应用：为网站每个用户创建一个字典，来存储每个用户的个人信息，并将这些字典存户在一个名为users的列表中。

4.2 在字典中存储列表

适用于：该字典中一个键需要关联多个值，使用字典存储列表可为需要存储的对象添加多个相关描述。

dictionary = {
    key_01:[value_01],
    key_02:[value_02,value_03],
    }

#访问所有列表
for key,values in dictionary.items():
    #若列表中只有一项
    if len(values) == 1:
        print(' '.join(values))  
        '''需要大写的话函数join后面也可以再使用一个方法，例如'seq'.join(values).title() '''
    #若列表中有多项
    else:
        for value in values:
            print(value)

#访问某个列表，例如第二个列表key_02
for value in dictionary[key_02]:
    print(value)

·嵌套的框架往往太长了，为了更好理解，这里放出一个示例：

favorite_languages = {
    'jen':['python','ruby'],
    'sarah':['c'],
    'edward':['ruby','go'],
    'phil':['python','haskell'],
    }
#访问所有列表
for name,languages in favorite_languages.items():
    #若列表中只有一项
    if len(languages) == 1:
        print(name.title() + "'s favorite language is " + ' '.join(languages).title())
    else:
        print(name.title() + "'s favorite language are:")
        for language in languages:
            print("\t" + language.title())
#访问某个列表
print("Edward's favorite language are:")
for language in favorite_languages['edward']:
    print(language.title())

*这里可以在遍历字典的for循环开头加if-else语句，搭配len()函数查看列表长度，若长度为1执行操作1，若长度为2执行操作2……

其中用到的join函数上一节已经讲过了，这里再提一下：

'sep'.join(seq)

sep：分隔符。可以为空，也可以是冒号(:)、空格( )等等
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串

返回值：返回一个以分隔符sep连接各个元素后生成的字符串

详解Python中的join()函数的用法_python中的join函数_风景不在对岸wj的博客-CSDN博客

4.3 在字典中存储字典

适用于：一个字典中每个键、值都是独特的，但最好表示每个个体的字典结构都相同，能够使得嵌套的字典处理起来相对更加容易。

#定义嵌套
dictionary = {
    dic_01:{
        key_01:value_01,
        key_02:value_02,
        key_03:value_03,
        …
        },
    dic_02:{
        key_01:value_04,
        key_02:value_05,
        key_03:value_06,
        …
        },
    }
#访问嵌套，dic为嵌套内字典名称，value_info是嵌套内的字典
for dic,value_info in dictionary.items():
    #字典名称dic返回到的是一个键的名称，可以直接输出
    print(dic)
    #字典value_info返回到的是一个字典，需要访问其内容时需要由指定键访问值
    print(value_info[key_01],value_info[key_02],value_info[key_03],…)

·示例：由多个网站用户，每个都有独特的用户名，可以在字典中将用户名作为键，然后将每位用户的信息都存储在一个字典中，并将该字典作为用户名相关联的值。

#对于每位用户都存储了三项信息：名、姓和居住地，为访问这些信息，遍历所有的用户名，并访问每个用户名相关联的信息字典
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())


>>
Username:aeinstein
	Full name: Albert Einstein
	Location: Princeton

Username:mcurie
	Full name: Marie Curie
	Location: Paris

5 课后习题

题目都打在注释里了。

#课本例题6.1 简单字典
print("\n课本例题6.1")
#alien.py
alien_0 = {'color':'green','point':5}
#访问字典中的值
print(alien_0['color'])
print(alien_0['point'])

#课本例题6.2 使用字典
print("\n课本例题6.2")
#访问字典中的值
alien_0 = {'color':'green'}
print(alien_0['color'])
#向字典中添加值
alien_0 = {'color':'green','point':5}
new_points = alien_0['point']
print("You just earned " + str(new_points) + " points!")
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
#创建空字典，再添加键值对
alien_0 = {}
alien_0['color'] = 'green'
alien_0['points'] = 5
print(alien_0)
#修改字典中的值
alien_0 = {'color':'green'}
print("The alien is " + alien_0['color'] + ".")
alien_0['color'] = 'yellow'
print("The alien is now " + alien_0['color'] + ".")

#追踪外星人位置的例题：对一个能够以不同速度移动的外星人的位置进行跟踪。为此，我们将存储外星人的当前速度，并据此确定该外星人将向右移动多远
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(speed medium):" + str(alien_0['x_position']))
#将外星人的速度改变为fast
alien_0['speed'] = 'fast'
if alien_0['speed'] == 'slow':
    x_increment = 1
elif alien_0['speed'] == 'medium':
    x_increment = 2
elif alien_0['speed'] == 'fast':
    x_increment = 3
alien_0['x_position'] = alien_0['x_position'] + x_increment
print("New x-position(speed fast):" + str(alien_0['x_position']))

#删除键值对
alien_0 = {'color':'green','points':5}
print(alien_0)

del alien_0['points']
print(alien_0)

#由相似对象组成的字典
favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
    }
print("Sarah's favorite language is " +
      favorite_languages['sarah'].title() +
      ".")

#课后习题6-1 人：使用一个字典来存储一个熟人的信息，包括名、姓、年龄和居住的城市
#该字典应包含键first_name、last_name、age和city
#将存储在该字典中的每项信息都打印出来
print("\n课后习题6-1")
personal_info = {
    'first_name':'Qi',
    'last_name':'Qu',
    'age':22,
    'city':'Beijing',
    }
print("My friend is called " +
      personal_info['last_name'] +
      personal_info['first_name'] +
      "," +
      str(personal_info['age']) +
      " years old,and lives in " +
      personal_info['city'] +
      ".")

#课后习题6-2 喜欢的数字：使用一个字典来存储一些人喜欢的数字
#请想出5个人的名字，并将这些名字用作字典中的键
#想出每个人喜欢的一个数字，并将这些数字作为值存储在字典中
#打印每个人的名字和喜欢的数字
print("\n课后习题6-2")
favorite_numbers = {
    'jen':1,
    'sarah':2,
    'edward':3,
    'phil':4,
    'sylvia':5,
    }
#普通的方法就是一个一个打印输出
print("Jen's favorite number is " + str(favorite_numbers['jen']) + ".")
print("Sarah's favorite number is " + str(favorite_numbers['sarah']) + ".")
print("Edward's favorite number is " + str(favorite_numbers['edward']) + ".")
print("Phil's favorite number is " + str(favorite_numbers['phil']) + ".")
print("Sylvia's favorite number is " + str(favorite_numbers['sylvia']) + ".")
#也可以使用遍历的方法去输出，因为例题这里还没有讲到遍历，就先使用一个简单输出，再附加一个遍历输出
for key,value in favorite_numbers.items():
    print(key.title() + "'s favorite number is " + str(value) + ".")

#课后习题6-3 词汇表：Python字典可用于模拟现实生活中的字典，但为了避免混淆，我们将后者称为词汇表
print("\n课后习题6-3")
#想出你在前面学过的5个编程词汇，将它们用作词汇表中的键，并将它们的含义作为值存储在词汇表中
vocabulary = {
    'String' : '字符串',
    'List' : '列表',
    'Number' : '数字',
    'Tuple' : '元组',
    'Dictionary' : '字典',
    }
#以简洁的方式打印每个词汇及其含义
#普通的方式参考习题6-4，那样写要打的字太多了，我就用循环直接输出了
for key,value in vocabulary.items():
    print(key + " means " + value + ".")
#为此，你可以先打印词汇，在它后面加上一个冒号，再打印词汇的含义
    print(key + ":" + value + ".")
#也可再一行打印词汇，再使用换行符(\n)插入一个空行，然后在下一行以缩进的方式打印词汇的含义
    print(key + ":\n\t" + value + ".")

#课本例题6-3 遍历字典
print("\n课本例题6-3")
#遍历所有的键值对
user_0 = {
    'username' : 'efermi',
    'first' : 'enrico',
    'last' : 'fermi',
    }
for key,value in user_0.items():
    print("Key:" + key)
    print("Value:" + value)

favorite_languages = {
    'jen' : 'python',
    'sarah' : 'c',
    'edward' : 'ruby',
    'phil' : 'python',
    }
for name,language in favorite_languages.items():
    print(name.title() + "'s favorite language is " +
          language.title() + ".")
#遍历字典中的所有键
for name in favorite_languages.keys():
    print(name.title())
for name in favorite_languages:
    print(name.title())

favorite_languages = {
    'jen' : '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() + "!")
    if 'erin' not in favorite_languages.keys():
        print("Erin,please take our poll!")
#按顺序遍历字典中的所有键
for name in sorted(favorite_languages.keys()):
    print(name.title() + ",thank you for taking the poll.")
#遍历字典中的所有值
print("The following languages have been mentioned:")
for language in favorite_languages.values():
    print(language.title())
#剔除重复项
for language in set(favorite_languages.values()):
    print(language.title())

#课后习题6-4 词汇表2：基于习题6-3，将其中一系列Print语句替换为一个遍历字典中的键和值的循环
#确定该循环无误后，再在词汇表中添加5个Python术语
#当你再次运行这个程序时，这些新术语及其含义将自动包含在输出中
print("\n课后习题6-4")
vocabulary = {
    'String' : '字符串',
    'List' : '列表',
    'Number' : '数字',
    'Tuple' : '元组',
    'Dictionary' : '字典',
    }
for name,mean in vocabulary.items():
    print(name + ":" + mean + ".")
vocabulary['Set'] = '集合'
vocabulary['Bool'] = '布尔类型'
for name,mean in vocabulary.items():
    print(name + ":" + mean + ".")

#课后习题6-5 河流：创建一个字典，在其中存储三条大河流及其流经的国家
#其中一个键-值对可能是'nile':'egypt'
print("\n课后习题6-5")
rivers = {
    'nile':'egypt',
    'amazon':'brazil',
    'yangtze':'china',
    }
#使用循环为每条河流打印一条消息，如"The Nile runs through Egypt."
for river,area in rivers.items():
    print("The " + river.title() + " runs through " + area.title() + ".")
#使用循环将该字典中的每条河流的名字都打印出来
for river in rivers.keys():
    print(river.title())
#使用循环将字典包含的每个国家都打印出来
for area in rivers.values():
    print(area.title())

#课后习题6-6 调查：在课本例题6.3中编写的程序favorite_languages.py中执行以下操作
print("\n课后习题6-6")
favorite_languages = {
    'jen' : 'python',
    'sarah' : 'c',
    'edward' : 'ruby',
    'phil' : 'python',
    }
#创建一个应该会接受调查的人员名单，其中有些人已经包含在字典中，而其他人未包含在字典中
investigators = ['jen','amy','sarah']
#遍历这个人员名单，对于已参与调查的人，打印一条消息表示感谢
#对于还未参与调查的人，打印一条消息邀请他参与调查
for name in favorite_languages.keys():
    if name in investigators:
        print(name.title() + ",Thank you for participating in this survey!")
    else:
        print(name.title() + ",Please participate in the survey!")

#课本例题6.4 嵌套：列表与字典
print("\n课本例题6.4")
#字典列表
#aliens.py
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)
#自动创建多个外星人
#创建一个用于存储外星人的空列表
aliens = []
#创建30个绿色的外星人
for alien_number in range(30):
    new_alien = {'color':'green','points':5,'speed':'slow'}
    aliens.append(new_alien)
#显示前面五个外星人
for alien in aliens[:5]:
    print(alien)
print("……")
#显示创建了多少外星人
print("Total number of aliens:" + str(len(aliens)))
#修改部分外星人参数
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("……")

#在字典中存储列表
#pizza.py
#存储所点pizza的信息
pizza = {
    'crust':'thick',
    'toppings':['mushrooms','extra cheese'],
    }
#概述所点披萨
print("You ordered a " + pizza['crust'] + "-crust pizza " +
      "with the following toppings:")
for topping in pizza['toppings']:
    print("\t" + topping)
#favorite_languages.py
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())
#优化
favorite_languages = {
    'jen':['python','ruby'],
    'sarah':['c'],
    'edward':['ruby','go'],
    'phil':['python','haskell'],
    }
#访问所有列表
for name,languages in favorite_languages.items():
    #若列表中只有一项
    if len(languages) == 1:
        print(name.title() + "'s favorite language is " + ' '.join(languages).title())
    else:
        print(name.title() + "'s favorite language are:")
        for language in languages:
            print("\t" + language.title())
#访问某个列表
print("Edward's favorite language are:")
for language in favorite_languages['edward']:
    print(language.title())

#在字典中存储字典
#many_users.py
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())

#课后习题6-7 人：基于习题6-1的程序，再城建两个表示人的字典，然后将这三个字典都存储在一个名为people的列表中
#遍历这个列表，将其中每个人的所有信息都打印出来
print("\n课后习题6-7")
user_01 = {
    'first_name':'Qi',
    'last_name':'Qu',
    'age':22,
    'city':'Beijing',
    }
user_02 = {
    'first_name':'Jennie',
    'last_name':'Liu',
    'age':23,
    'city':'Xian'
    }
user_03 = {
    'first_name':'Sylvia',
    'last_name':'Wan',
    'age':23,
    'city':'Shanghai'
    }
people = [user_01,user_02,user_03]
for user in people:
    full_name = user['first_name'] +" " + user['last_name']
    print("Full name:" + full_name.title())
    print("\tAge:" + str(user['age']))
    print("\tCity:" + user['city'])

#课后习题6-8 宠物：创建多个字典，对于每个字典，都是用一个宠物名称来给它命名
#在每个字典中，包含宠物的类型及主人的名字
#将这些字典存储在一个名为pets的列表中，再遍历该列表，并将宠物的所有信息都打印出来
print("\n课后习题6-8")
Ding = {
    'variety':'dog',
    'host':'Jennie',
    }
Ro = {
    'variety':'British short cat',
    'host':'Sylvia',
    }
Nine = {
    'variety':'Chinese pastoral cat',
    'host':'Benny',
    }
pets = [Ding,Ro,Nine]
for pet in pets:
    print("\tVariety: " + pet['variety'])
    print("\tHost: " + pet['host'])

#课后习题6-9 喜欢的地方：创建一个名为favorite_places的字典
#在这个字典中，将三个人的名字用作键；对于其中的每个人，都存储他喜欢的1~3个地方
#遍历这个字典，将其中每个人的名字及其喜欢的地方打印出来
print("\n课后习题6-9")
favorite_places = {
    'Jennie':['Xian','Beijing'],
    'Sylvia':['Shanghai'],
    'Benny':['Beijing','Shanghai','Guangzhou'],
    }
for name,places in favorite_places.items():
        if len(places) == 1:
            print(name + "'s favorite place is " + ' '.join(places) + ".")
        else:
            print(name + "'s favorite place are ")
            for place in places:
                print("\t" + place)
            #其实都用join函数输出会非常简单，而且不需要任何的换行制表，更整齐，这里做出示例：
            print(name + "'s favorite place are " + ','.join(places) + ".")

#课后习题6-10 喜欢的数字：基于习题6-2，让每个人都可以由多个喜欢的数字，然后将每个人的名字及喜欢的数字打印出来
print("\n课后习题6-10")
favorite_numbers = {
    'jen':[1,2],
    'sarah':[2],
    'edward':[3,4,5],
    'phil':[4,5],
    'sylvia':[5],
    }
for name,numbers in favorite_numbers.items():
    if len(numbers) == 1:
        #使用列表解析式将数字列表转换为字符串列表
        numbers_new = [str(i) for i in numbers]
        #使用join函数将字符串列表转换为字符串
        print(name + "'s favorite number is " + ' '.join(numbers_new) + ".")
    else:
        #与if处同理
        numbers_new = [str(i) for i in numbers]
        print(name + "'s favorite number are " + ','.join(numbers_new) + ".")

#课后习题6-11 城市：创建一个名为cities的字典，其中将三个城市名用作键
#对于每个城市，都创建一个字典，并在其中包含该城市所属的国家、人口约数以及一个有关该城市的事实
#在表示每座城市的字典中，应包含country、population和fact等键
#将每座城市的名字以及有关它们的信息都打印出来
print("\n课后习题6-11")
cities={
    'Xian':{
        'Country':'China',
        'Population':13163000,
        'Fact':'None',
        },
    'New York':{
        'Country':'America',
        'Population':8510000,
        'Fact':'None',
        },
    'Manchester':{
        'Country':'England',
        'Population':514400,
        'Fact': 'None',
        },
    }
for city,city_info in cities.items():
    print(city + ":")
    print("\tCountry: " + city_info['Country'])
    print("\tPopulation: " + str(city_info['Population']))
    print("\tFact: " + city_info['Fact'])
for city,city_info in cities.items():
    print(city + ":")
    for key,value in city_info.items():
        print("\t" + key + ":" + str(value))

 参考书籍：Python编程从入门到实践（书籍） - 知乎