Python列表、集合与字典（3）

• 一、列表
• 二、集合
• 三、字典

---

一、列表

1. 列表初识

  列表的使用为处理特定顺序排列的数据提供了便利，列表元素可以是字母、数字或者其他信息，同时所加元素之间不存在任何关系。

  在Python中，用方括号表示列表，并用逗号分隔各个元素，具体如下所示：

names = ['ZhangYi','SuQin','SunBin','PangJuan','LvBu']
nums = [1,2,3,4,5]

  上行代码定义了一个names和nums的列表，列表长度（即列表包含元素数量）均为5个，其中names元素以字符形式（str型）表示，nums元素以数字形式（int型）表示。

2.列表访问

  列表通过index访问，即通过列表下表访问列表元素，需要注意的是Python列表index和C语言一样，都是从0开始而非1开始。

# 输出列表元素和相应元素的下标
names = ['ZhangYi','SuQin','SunBin','PangJuan','LvBu']
print(names[0])
print(names.index('ZhangYi'))
>>> ZhangYi
>>> 0

3.列表操作

 &emsp实际使用中，创建列表是动态的，即我们依据需要对列表进行添加、修改、删除等一系列操作，这样将导致列表发生变化，下面将介绍列表主要的属性或方法的操作。

names = ['ZhangYi','SuQin','SunBin','PangJuan','LvBu']
# 列表元素修改
names[0] = 'GuanYu'
print('1:\t',names)
>>> 1:  ['GuanYu','SuQin','SunBin','PangJuan','LvBu']
# 列表元素增添
names.append('BaiQi')
print('2:\t',names)
>>> 2:  ['GuanYu', 'SuQin', 'SunBin', 'PangJuan', 'LvBu', 'BaiQi']
# 列表元素删除(remove del pop)
names.remove('SunBin')
print('3:\t',names)
>>> 3:  ['GuanYu', 'SuQin', 'PangJuan', 'LvBu', 'BaiQi']
del names[1]
print('4:\t',names)
>>> 4:  ['GuanYu', 'PangJuan', 'LvBu', 'BaiQi']
names.pop(1)
print('\t',names.pop(1))  # 假如未指定下标，则默认删除列表最后一个元素
print('5:\t',names)
>>>     'PangJuan'
>>> 5:  ['GuanYu', 'LvBu', 'BaiQi']

names = ['ZhangYi','SuQin','SunBin','PangJuan','LvBu','ZhangYi']
# 列表元素下标
print('\t',names.index('ZhangYi'))
print('6:\t',names[names.index('ZhangYi')])
>>> 0
>>> 6:  ZhangYi
# 列表元素统计
print('7:\t',names.count('ZhangYi'))
>>> 7:  2
# 列表元素反转
names.reverse()
print('8:\t',names)
>>> 8:  ['ZhangYi', 'LvBu', 'PangJuan', 'SunBin', 'SuQin', 'ZhangYi']
# 列表元素排序
# 排序顺序：特殊字符->数字->字母->汉字
char_ = ['#','12','Hello','$','54','霓虹','飞天']
char_.sort()
print('9:\t',char_)
>>> 9:  ['#', '$', '12', '54', 'Hello', '霓虹', '飞天']
# 列表元素扩展
names.extend(char_)
print('10:\t',names)
print('11:"\t',names+char_)
>>> 10: ['ZhangYi', 'LvBu', 'PangJuan', 'SunBin', 'SuQin', 'ZhangYi', '#', '$', '12', '54', 'Hello', '霓虹', '飞天']
>>> 11: ['ZhangYi', 'LvBu', 'PangJuan', 'SunBin', 'SuQin', 'ZhangYi', '#', '$', '12', '54', 'Hello', '霓虹', '飞天']
# 列表元素插入
names = ['ZhangYi','SuQin','SunBin','PangJuan','LvBu']
names.insert(6,'ZhaoYun')
print('12:\t',names)
>>> 12: ['ZhangYi', 'SuQin', 'SunBin', 'PangJuan', 'LvBu', 'ZhaoYun']
names = ['ZhangYi','SuQin','SunBin','PangJuan','LvBu']
char_ = ['#','12','Hello','$','54','霓虹','飞天']
names.insert(6,char_)
print('13:\t',names)
>>> 13: ['ZhangYi', 'SuQin', 'SunBin', 'PangJuan', 'LvBu', ['#', '12', 'Hello', '$', '54', '霓虹', '飞天']]
# 列表元素清空
names.clear()
print('14:\t',names)
>>> 14: []

  以上是关于列表元素的主要操作，并给出了相应的运算结果，此处只列举常用的列表属性或方法（除copy属性外），其他的在此不再过多介绍。

  下面单独进行列表copy属性的介绍，此处涉及可能有些繁琐，所以大家运行代码时请注意区分相应的元素变化。

  首先是进行基本复制的介绍：

# copy()方法复制
names = ['ZhangYi','SuQin','SunBin','PangJuan','LvBu']
print(names.copy())
>>> ['ZhangYi', 'SuQin', 'SunBin', 'PangJuan', 'LvBu']
# 数量复制
print(names*5)
>>> ['ZhangYi', 'SuQin', 'SunBin', 'PangJuan', 'LvBu', 'ZhangYi', 'SuQin', 'SunBin', 'PangJuan', 'LvBu']

  接下来重点介绍下列表复制中的浅复制和深复制：

# 导入copy模块
import copy

str_c = ['ZhangFei','SunBin','PangTong',['孙膑','庞涓'],'LiBai']
print('orig:\t',str_c)
>>> orig:   ['ZhangFei', 'SunBin', 'PangTong', ['孙膑', '庞涓'], 'LiBai']
# 以下orig简称为原本，copy版本简称为复制本 
# 使用.copy()方法
# (1) 浅层（外层）列表原本元素修改,观察复制本中相应元素
str_c_1 = copy.copy(str_c)
str_c[1] = '孙膑'
print('cp_1:\t',str_c_1)
print('orig:\t',str_c)
>>> cp_1:   ['ZhangFei', 'SunBin', 'PangTong', ['孙膑', '庞涓'], 'LiBai']
>>> orig:   ['ZhangFei', '孙膑', 'PangTong', ['孙膑', '庞涓'], 'LiBai']
# ***********************************************************************
# (1) 原本浅层列表元素变化后，复制本并未产生变化！相应修改复制本中的元素，相应原本中的元素也不会发生变化（此处不再验证，有兴趣可以自行验证）
# ***********************************************************************

# 接续上次运行结果进行元素修改
# 使用.copy()方法
# (2) 深层（嵌套层）列表复制本元素修改,观察原本中相应元素
str_c_1[3][0] = 'SunBin'
print('cp_1:\t',str_c_1)
print('orig:\t',str_c)
>>> cp_1:   ['ZhangFei', 'SunBin', 'PangTong', ['SunBin', '庞涓'], 'LiBai']
>>> orig:   ['ZhangFei', '孙膑', 'PangTong', ['SunBin', '庞涓'], 'LiBai']
# ***********************************************************************
# (2) 复制本深层列表元素变化后，原本相应元素也产生变化！相应修改原本中的元素，相应复制本中的元素也不会发生变化（此处不再验证，有兴趣可以自行验证）
# ***********************************************************************

# 接续上次运行结果进行元素修改
# 使用.deepcopy()方法
# (3) 浅层（外层）列表原本元素修改,观察复制本中相应元素
str_c_2 = copy.deepcopy(str_c)
str_c[1] = 'SunBin'
print('cp_2:\t',str_c_2)
print('orig:\t',str_c)
>>> cp_2:   ['ZhangFei', '孙膑', 'PangTong', ['SunBin', '庞涓'], 'LiBai']
>>> orig:   ['ZhangFei', 'SunBin', 'PangTong', ['SunBin', '庞涓'], 'LiBai']
# ***********************************************************************
# (3) 原本浅层列表元素变化后，复制本相应元素未产生变化！相应修改复制本中的元素，相应原本中的元素也不会发生变化（此处不再验证，有兴趣可以自行验证）
# ***********************************************************************

# 接续上次运行结果进行元素修改
# 使用.deepcopy()方法
# (4) 深层（嵌套层）列表复制本元素修改,观察原本中相应元素
str_c_2[3][0] = '孙膑'
print('cp_2:\t',str_c_2)
print('orig:\t',str_c)
>>> cp_2:   ['ZhangFei', '孙膑', 'PangTong', ['孙膑', '庞涓'], 'LiBai']
>>> orig:   ['ZhangFei', 'SunBin', 'PangTong', ['SunBin', '庞涓'], 'LiBai']
# ***********************************************************************
# (4) 复制本深层列表元素变化后，原本相应元素未产生变化！相应修改原本本中的元素，相应复制本中的元素也不会发生变化（此处不再验证，有兴趣可以自行验证）
# ***********************************************************************

  在复制过程中存在浅复制(shallow copy)和深复制(deepcopy)，这两种复制的区别主要体现在对列表深层结构的复制，在浅层复制上两者相同。通过上述试验，我们能够具体总结出：

• 当原本只存在一层结构（浅层结构）时，两种复制方法不存在什么差别，即不论复制本变化还是原本变化，都不影响对方内容；
• 当原本具有嵌套结构（深层结构）时，在浅层结构复制上，两种复制方法变化机制和单一结构复制时的情况相同；
• 当进行原本深层结构复制时，利用浅复制时，无论原本或时复制本哪一方发生变化，对方对应的元素都将产生同样的更改，而利用深复制时，在深层结构元素变化后，例如原本发生变化，则复制本相应元素不变化，相应的复制本变化，原本相应元素不变化。

  浅复制主要由以下集中形式，同时需要注意的是，利用浅复制和深复制时，需导入copy模块：

import copy
a = copy.copy(b)
a = b[:]
a = list(b)

  列表除了上述方法和属性外，还有一项很重要的内容就是切片功能，利用列表切片可能很方便的控制元素的输出。

names = ['ZhangYi','SuQin','SunBin','PangJuan','LvBu']
print('1:\t',names)
>>> 1:  ['ZhangYi', 'SuQin', 'SunBin', 'PangJuan', 'LvBu']
print('2:\t',names[1:4])      # names[1-3]
>>> 2:   ['SuQin', 'SunBin', 'PangJuan']
print('3:\t',names[-1])       # names[4]
>>> 3:   LvBu
print('4:\t',names[-1:-3])    # names[]
>>> 4:   []
print('5:\t',names[-3:-1])    # names[2-3]
>>> 5:   ['SunBin', 'PangJuan']
print('6:\t',names[-2:-1])    # names[3]
>>> 6:   ['PangJuan']
print('7:\t',names[-1:])      # names[4]
>>> 7:   ['LvBu']
print('8:\t',names[-1:0])     # names[]
>>> 8:   []
print('9:\t',names[:3])       # names[0-2]
>>> 9:   ['ZhangYi', 'SuQin', 'SunBin']
print('10\t',names[0:-1])     # names[0-3]
>>> 10:  ['ZhangYi', 'SuQin', 'SunBin', 'PangJuan']
print('11:\t',names[0:-1:2])  # names[0,2]
>>> 11:  ['ZhangYi', 'SunBin']
print('12:\t',names[::2])     # names[0,2,4]
>>> 12:  ['ZhangYi', 'SunBin', 'LvBu']
print('13:\t',names[:])       # names[0-4]
>>> 13:  ['ZhangYi', 'SuQin', 'SunBin', 'PangJuan', 'LvBu']

  上述对列表的主要用法都进行了介绍，主要归结有以下规律：

• names[a​:c:​i​] —— 对于列表names，在切片处理中，a表示切片元素起始下标，c为切片元素终止下标，i为切片切取步长，切取顺序按照 names[a], names[a+i], names[a+2*i]……进行，其中names[c]为检索的最大上限，即边界，可以用集合中的开区间概念理解，即无法取到，只能取到names[c]之前的元素，另外 i 不写情况下，默认取1。
• names[-1] —— 表示列表names列表的最后一个元素，相对应的names[-2]表示倒数第二个元素。
• names[:]——表示列表中的所有元素。

4.列表的循环

  上述操作主要针对列表元素进行处理专项处理，当列表元素数量较多，且需要对每个元素进行同质化操作时，列表所有元素挨个处理就显得本笨拙了，因此列表循环在此刻就显得十分有用。

  在使用过程中过程中，有两种循环方式用的比较常见：

names = ['ZhangYi','SuQin','SunBin','PangJuan','LvBu']
# 列表items循环，即列表元素循环
for name in names:
    print(name)
>>> ZhangYi
    SuQin
    SunBin
    PangJuan
    LvBu
# 列表index循环，即列表下标循环
for index in range(len(names)):
    print(names[index])
>>> ZhangYi
    SuQin
    SunBin
    PangJuan
    LvBu

  以上主要是针对浅层列表的循环继续讲解，至于深层列表，可以利用循环嵌套进行处理，在此不再多做赘述。另外再介绍下enumerate，它能够同时返回列表元素的index和items，方便循环处理：

names = ['ZhangYi','SuQin','SunBin','PangJuan','LvBu']
for index,items in enumerate(names):
    print(index,items)
>>> 0 ZhangYi
    1 SuQin
    2 SunBin
    3 PangJuan
    4 LvBu

  列表主要内容基本就是上述这些，最后再讲解点元组（tuple）类型，元组类型形式很简单，就是元组元素用小括号括起来，与列表相比，元组只能进行元素下标和元素计数两种方法的处理，其他方法对元组元素不适用，因为元组与列表不同，一旦创建便不可更改。

names = ('ZhangFei','MaChao','GuanYu','ZhangFei')
# 元组元素循环
for name in names:
    print(name)
>>> ZhangFei
    MaChao
    GuanYu
    ZhangFei
# 元组列表循环
for i in range(len(names)):
    print(names[i])
>>> ZhangFei
    MaChao
    GuanYu
    ZhangFei
# 元组元素计数
print(names.count('ZhangFei'))
>>> 2

---

二、集合

1.集合初识

  Python中的集合在意义上同数学上的集合意义相同，即集合元素具有唯一性，无序性。在Python中，集合定义不像 tuple()、list[]、dict{} 可以直接通过括号进行定类，在定义集合类型时可以利用函数 set() 进行定义，而集合输出时则以大括号进行表示，具体如下所示：

set_0 = set('Hello')
set_1 = set(['Hello'])
set_2 = set({'Hello'})
print('0:\t{}\n{}\n{}'.format(set_0,set_1,set_2))
>>> 0:  {'l', 'H', 'e', 'o'} 
        {'Hello'} 
        {'Hello'}
set_3 = set(['1','2','3','4'])
set_4 = set({'1','2','3','4'})
print('1:\t{}\n{}'.format(set_3,set_4))
>>> 1:  {'2', '3', '1', '4'}
        {'2', '3', '1', '4'}

  通过上述代码可以看出，利用集合表示字符串时：

• 使用小括号表示单个字符串时，集合将以每个字符作为集合元素表示；
• 使用中括号和大括号表示单个字符串时，集合将以整个字符串作为一个元素表示；
• 表示多个元素时，必须使用中括号或者大括号表示；

2.集合访问

  集合不能像元组、列表那些可以通过指定下标访问元素，因此集合访问元素只能通过对元素进行遍历：

set_ = set(['1','2','3','4'])
for index,items in enumerate(set_):
    print(index,'*'+items+'*')
>>> 0 *1*
    1 *3*
    2 *2*
    3 *4*

3.集合操作

  数学意义上的集合有许多关系，在Python中，可以利用一些函数或者关系将这些关系表示出来：

# 交集
list_1 = set([1,2,3,4,5])
list_2 = set([1,2,8,9,12])
list_3 = set([1,2])
print('1:\t',list_1.intersection(list_2))
>>> 1:  {1, 2}
print('2:\t',list_1.intersection(list_3))
>>> 2:  {1, 2}
print('3:\t',list_1 & list_3)
>>> 3:  {1, 2}
# 并集
print('4:\t',list_1.union(list_3))
>>> 4:  {1, 2, 3, 4, 5}
print('5:\t',list_1 | list_3)
>>> 5:  {1, 2, 3, 4, 5}
# 差集
print('6:\t',list_1.difference(list_3))
>>> 6:  {3, 4, 5}
print('7:\t',list_1 - list_3)
>>> 7:  {3, 4, 5}
# 子集
print('8:\t',list_1.issubset(list_2))
>>> 8:  False
print('9:\t',list_3.issubset(list_1))
>>> 9:  True
# 父集
print('10:\t',list_1.issuperset(list_2))
>>> 10: False
print('11:\t',list_1.issuperset(list_3))
>>> 11: True
# 子父集符号判断
print('12:\t',list_3 in list_1)
>>> 12: False
print('13:\t',list_3 not in list_1)
>>> 13: True
print('14:\t',list_3 <= list_1)
>>> 14: True
print('15:\t',list_3 >= list_1)
>>> 15: False
# 对称差集
print('16:\t',list_1.symmetric_difference(list_3))
>>> 16: {3, 4, 5}
print('17:\t',list_1 ^ list_3)
>>> 17: {3, 4, 5}
# 判断交集
print('18:\t',list_1.isdisjoint(list_2))
>>> 18: False

  集合的逻辑关系基本就是上述这些，除了上述关系外，集合还有一些常用的操作方法：

list_1 = set([1,2,3,4,5])
# 集合元素添加
# 单项添加
list_1.add(212)
print('1:\t',list_1)
>>> 1:  {1, 2, 3, 4, 5, 212}
# 多项添加
list_1.update([200,201,202])
print('2:\t',list_1)
>>> 2:  {1, 2, 3, 4, 5, 200, 201, 202, 212}
# 集合元素删除
list_1.remove(212)
print('3:\t',list_1)
>>> 3:  {1, 2, 3, 4, 5, 200, 201, 202}
list_1.pop()
print('4:\t',list_1)
>>> 4:  {2, 3, 4, 5, 200, 201, 202}
# discard()删除时假如集合中没有该元素，不报错，返回None，
# 假如存在，则删除，相对应的，remove则在没有该元素时，会报错
list_1.discard(5)
print('5:\t',list_1)
>>> 5:  {2, 3, 4, 200, 201, 202}
# 集合长度
print('6:\t',len(list_1))
>>> 6:  6

---

三、字典

1.字典初识

  Python中，字典就是一系列的键-值对。每个键与一个值相关联，通过键的使用可以访问该键所对应的值，而值可以是Python中的任何对象，如数字、字符串、列表甚至是字典等。

MaChao = {'Country':'Shu','Gender':'Male'}

  如上所示，Python字典使用{ }包含元素，即字典一系列键-值对就放在字典打括号内，键和值使用冒号分隔，而键-值对之间使用都好分隔，字典内能够存储无限个键-值对。

2.字典访问

  字典和列表两种结构间共有着一种一一对应关系，即列表每个下标对应相应的元素，而字典通过键对应对应相应的值，列表通过下标访问元素，字典则需要利用值所对应的键进行访问。

info = {
    'Shu':'ZhaoYun',
    'Wu':['LuXun','TaiShici'],
    'Wei':'DianWei'
}
print(info['Wu'])
print(info['Shu'])

>>> ['LuXun', 'TaiShici']
>>> ZhaoYun

3.字典操作

  字典的值操作也很简单，找到所需修改值所对应的键，然后进行查找即可操作。

# 字典元素替换
info = {
    'Shu':'ZhaoYun',
    'Wu':['LuXun','TaiShici'],
    'Wei':'DianWei'
}
info['Shu'] = 'GuanYu'
print(info)

>>> {'Shu': 'GuanYu', 'Wu': ['LuXun', 'TaiShici'], 'Wei': 'DianWei'}
# 字典元素删除
del info['Wei']
print('del:\t',info)
info.pop('Shu')
print('pop:\t',info)
>>> del:    {'Shu': 'GuanYu', 'Wu': ['LuXun', 'TaiShici']}
>>> pop:    {'Wu': ['LuXun', 'TaiShici']}
# popitem()随机返回并删除字典中的一堆键—值
info = {
    'Shu':'ZhaoYun',
    'Wu':['LuXun','TaiShici'],
    'Wei':'DianWei'
}
info_pop = info.popitem()
print('\t',info_pop)
print('popitem:\t',info)
>>> ('Wei', 'DianWei')
    popitem:    {'Shu': 'GuanYu', 'Wu': ['LuXun', 'TaiShici']}
# 字典元素查找
info = {
    'Shu':'ZhaoYun',
    'Wu':['LuXun','TaiShici'],
    'Wei':'DianWei'
}
print(info.get('Shu'))
print('Shu' in info)  # info.has_key('Shu') in py2.x
>>> ZhaoYun
    True
# 字典元素更新-update()
# 字典更新时，假如新字典中有和原字典相同的键，则
# 新字典中该键的内容将完全替代原字典中该键所对应的值
# 假如没有相同的键，则直接在原字典后进行新的添加
b = {
    'Shu':'GuanYu',
    'Song':'LiuYu'
}
info.update(b)
print(info)
print(info.items())
>>> {'Shu': 'GuanYu', 'Wu': ['LuXun', 'TaiShici'], 'Wei': 'DianWei', 'Song':     'LiuYu'}
    dict_items([('Shu', 'GuanYu'), ('Wu', ['LuXun', 'TaiShici']), ('Wei',         'DianWei'), ('Song', 'LiuYu')])
# 字典元素更新-setdefault()
# setdefault()假如查找在字典里查找到，则返回查找到的值，
# 假如没有则创建新值，新值信息是setdefault()后面的信息
infos = {
    '三国':
    {'Shu':['ZhaoYun','GuanYu'],
    'Wu':['LuXun','TaiShici'],
    'Wei':['DianWei','ZhangHe']
},
    '西晋':{
        'Sima':['SimaZhao','SimaYan']
    },
    '东晋':{
        'Xie':['Xiean','Xiexuan']
    }
}

infos['东晋']['Xie'][0] = '谢安'
print(infos)
>>> {'三国': {'Shu': ['ZhaoYun', 'GuanYu'], 'Wu': ['LuXun', 'TaiShici'],          'Wei': ['DianWei', 'ZhangHe']}, '西晋': {'Sima': ['SimaZhao',                  'SimaYan']}, '东晋': {'Xie': ['谢安', 'Xiexuan']}}

infos.setdefault('东晋',{'Wang':['WangDao','WangRong']})
>>> {'Xie': ['Xiean', 'Xiexuan']}
infos.setdefault('宋朝',{'Liu':['LiuYu']})
>>> {'Liu': ['LiuYu']}
print(infos)
>>> {'三国': {'Shu': ['ZhaoYun', 'GuanYu'], 'Wu': ['LuXun', 'TaiShici'],          'Wei': ['DianWei', 'ZhangHe']}, '西晋': {'Sima': ['SimaZhao','SimaYan']},      '东晋': {'Xie': ['Xiean', 'Xiexuan']}, '宋朝': {'Liu': ['LiuYu']}}  
# 字典元素更新-fromkeys()
# fromkeys()在每个键（前面参数中的每个元素都是一个独立的键）
# 后面都添加后面参数内的全部元素作为值,假如修改其中的一个值，
# 则字典中同样位置的元素都将发生改变
ele = dict.fromkeys([6,7,8],[1,{'Shu':'ZhangFei'},4])
print(ele)
>>> {6: [1, {'Shu': 'ZhangFei'}, 4], 7: [1, {'Shu': 'ZhangFei'}, 4], 8: [1,       {'Shu': 'ZhangFei'}, 4]}

ele[7][1]['Shu'] = 'HuangZhong'
print(ele)
>>> {6: [1, {'Shu': 'HuangZhong'}, 4], 7: [1, {'Shu': 'HuangZhong'}, 4], 8:       [1, {'Shu': 'HuangZhong'}, 4]}

4.字典循环

  字典结构相对来说比较复杂，因此在遍历时，会和其他结构稍微有些不同。

（1）遍历字典中的所有的键-值对

  遍历键值对的遍历有两种方法，一种是常规的遍历，另一种时运用字典特定的属性方法遍历：

info = {
    'Shu':'ZhaoYun',
    'Wu':['LuXun','TaiShici'],
    'Wei':'DianWei'
}
# 常规遍历方法
for i in info:
    print(i + ':\t',info[i])
>>> Shu:    ZhaoYun
    Wu:     ['LuXun', 'TaiShici']
    Wei:    DianWei
# itmes()遍历
for key,value in info.items():
    print(key + ':\t',value)
>>> Shu:    ZhaoYun
    Wu:     ['LuXun', 'TaiShici']
    Wei:    DianWei

  需要注意的是，当数据量较小时，应用上述两种方法都行，但是当数据量比较大时，使用items()会比较耗费CPU，而相比之下，第一种常规的遍历方法更适合处理数量比较大时的情况。

（2）遍历字典中的键/值

  前面有了对整个键-值对的遍历，再对键进行遍历就比较容易了：

info = {
    'Shu':'ZhaoYun',
    'Wu':['LuXun','TaiShici'],
    'Wei':'DianWei'
}
# 遍历字典中的键
for key in info.keys():
    print(key)
>>> Shu
    Wu
    Wei
# 遍历字典中的值
for value in info.values():
    print(value)
>>> ZhaoYun
>>> ['LuXun', 'TaiShici']
>>> DianWei

（3）遍历字典中的所有值

  最后对字典嵌套循环进行简要的介绍。
  很多情况下，字典并不是如我们上述所写的这么简单，有时我们会遇到在字典中有多重嵌套的情况，而同时我们又需要将整个字典的所有值给打印出来，而面对多重嵌套，我们常常会抓耳挠腮，实际上，打印这些值，根本方法还是利用循环，下面将以一个两重嵌套的字典进行所有制的打印说明，之后再遇到更多重的嵌套，原理都是一样的，跳出代码，掌握核心观念，方可灵活运用。

infos = {
    '三国':
    {'蜀':['赵云','关羽'],
     '吴':['陆逊','甘宁'],
     '魏':['典韦','张郃']
},
    '西晋':{'司马':['司马炎','司马昭']
    },
    '东晋':{
        '谢':['谢安','谢玄']
    }
}
# 以列表形式显示值
for info in infos:
    for info_inner in infos[info]:
        print(info_inner + ':\t',infos[info][info_inner])
>>> 蜀:   ['赵云', '关羽']
    吴:   ['陆逊', '甘宁']
    魏:   ['典韦', '张郃']
    司马:  ['司马炎', '司马昭']
    谢:   ['谢安', '谢玄']
# 以单个元素显示值
for info in infos:
    for info_inner in infos[info]:
        info_show = infos[info][info_inner]
        for i in range(len(info_show)):
            print(info + '--' + info_inner + ':\t',info_show[i])
>>> 三国--蜀:   赵云
    三国--蜀:   关羽
    三国--吴:   陆逊
    三国--吴:   甘宁
    三国--魏:   典韦
    三国--魏:   张郃
    西晋--司马:  司马炎
    西晋--司马:  司马昭
    东晋--谢:   谢安
    东晋--谢:   谢玄