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])

>>> 三国--蜀:	 赵云

    三国--蜀:	 关羽

    三国--吴:	 陆逊

    三国--吴:	 甘宁

    三国--魏:	 典韦

    三国--魏:	 张郃

    西晋--司马:	 司马炎

    西晋--司马:	 司马昭

    东晋--谢:	 谢安

    东晋--谢:	 谢玄