一、列表
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: ',names)
>>> 1: ['GuanYu','SuQin','SunBin','PangJuan','LvBu']
# 列表元素增添
names.append('BaiQi')
print('2: ',names)
>>> 2: ['GuanYu', 'SuQin', 'SunBin', 'PangJuan', 'LvBu', 'BaiQi']
# 列表元素删除(remove del pop)
names.remove('SunBin')
print('3: ',names)
>>> 3: ['GuanYu', 'SuQin', 'PangJuan', 'LvBu', 'BaiQi']
del names[1]
print('4: ',names)
>>> 4: ['GuanYu', 'PangJuan', 'LvBu', 'BaiQi']
names.pop(1)
print(' ',names.pop(1)) # 假如未指定下标，则默认删除列表最后一个元素
print('5: ',names)
>>> 'PangJuan'
>>> 5: ['GuanYu', 'LvBu', 'BaiQi']
names = ['ZhangYi','SuQin','SunBin','PangJuan','LvBu','ZhangYi']
# 列表元素下标
print(' ',names.index('ZhangYi'))
print('6: ',names[names.index('ZhangYi')])
>>> 0
>>> 6: ZhangYi
# 列表元素统计
print('7: ',names.count('ZhangYi'))
>>> 7: 2
# 列表元素反转
names.reverse()
print('8: ',names)
>>> 8: ['ZhangYi', 'LvBu', 'PangJuan', 'SunBin', 'SuQin', 'ZhangYi']
# 列表元素排序
# 排序顺序：特殊字符->数字->字母->汉字
char_ = ['#','12','Hello','$','54','霓虹','飞天']
char_.sort()
print('9: ',char_)
>>> 9: ['#', '$', '12', '54', 'Hello', '霓虹', '飞天']
# 列表元素扩展
names.extend(char_)
print('10: ',names)
print('11:" ',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: ',names)
>>> 12: ['ZhangYi', 'SuQin', 'SunBin', 'PangJuan', 'LvBu', 'ZhaoYun']
names = ['ZhangYi','SuQin','SunBin','PangJuan','LvBu']
char_ = ['#','12','Hello','$','54','霓虹','飞天']
names.insert(6,char_)
print('13: ',names)
>>> 13: ['ZhangYi', 'SuQin', 'SunBin', 'PangJuan', 'LvBu', ['#', '12', 'Hello', '$', '54', '霓虹', '飞天']]
# 列表元素清空
names.clear()
print('14: ',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: ',str_c)
>>> orig: ['ZhangFei', 'SunBin', 'PangTong', ['孙膑', '庞涓'], 'LiBai']
# 以下orig简称为原本，copy版本简称为复制本
# 使用.copy()方法
# (1) 浅层（外层）列表原本元素修改,观察复制本中相应元素
str_c_1 = copy.copy(str_c)
str_c[1] = '孙膑'
print('cp_1: ',str_c_1)
print('orig: ',str_c)
>>> cp_1: ['ZhangFei', 'SunBin', 'PangTong', ['孙膑', '庞涓'], 'LiBai']
>>> orig: ['ZhangFei', '孙膑', 'PangTong', ['孙膑', '庞涓'], 'LiBai']
# ***********************************************************************
# (1) 原本浅层列表元素变化后，复制本并未产生变化！相应修改复制本中的元素，相应原本中的元素也不会发生变化（此处不再验证，有兴趣可以自行验证）
# ***********************************************************************
# 接续上次运行结果进行元素修改
# 使用.copy()方法
# (2) 深层（嵌套层）列表复制本元素修改,观察原本中相应元素
str_c_1[3][0] = 'SunBin'
print('cp_1: ',str_c_1)
print('orig: ',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: ',str_c_2)
print('orig: ',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: ',str_c_2)
print('orig: ',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: ',names)
>>> 1: ['ZhangYi', 'SuQin', 'SunBin', 'PangJuan', 'LvBu']
print('2: ',names[1:4]) # names[1-3]
>>> 2: ['SuQin', 'SunBin', 'PangJuan']
print('3: ',names[-1]) # names[4]
>>> 3: LvBu
print('4: ',names[-1:-3]) # names[]
>>> 4: []
print('5: ',names[-3:-1]) # names[2-3]
>>> 5: ['SunBin', 'PangJuan']
print('6: ',names[-2:-1]) # names[3]
>>> 6: ['PangJuan']
print('7: ',names[-1:]) # names[4]
>>> 7: ['LvBu']
print('8: ',names[-1:0]) # names[]
>>> 8: []
print('9: ',names[:3]) # names[0-2]
>>> 9: ['ZhangYi', 'SuQin', 'SunBin']
print('10 ',names[0:-1]) # names[0-3]
>>> 10: ['ZhangYi', 'SuQin', 'SunBin', 'PangJuan']
print('11: ',names[0:-1:2]) # names[0,2]
>>> 11: ['ZhangYi', 'SunBin']
print('12: ',names[::2]) # names[0,2,4]
>>> 12: ['ZhangYi', 'SunBin', 'LvBu']
print('13: ',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: {}
{}
{}'.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: {}
{}'.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: ',list_1.intersection(list_2))
>>> 1: {1, 2}
print('2: ',list_1.intersection(list_3))
>>> 2: {1, 2}
print('3: ',list_1 & list_3)
>>> 3: {1, 2}
# 并集
print('4: ',list_1.union(list_3))
>>> 4: {1, 2, 3, 4, 5}
print('5: ',list_1 | list_3)
>>> 5: {1, 2, 3, 4, 5}
# 差集
print('6: ',list_1.difference(list_3))
>>> 6: {3, 4, 5}
print('7: ',list_1 - list_3)
>>> 7: {3, 4, 5}
# 子集
print('8: ',list_1.issubset(list_2))
>>> 8: False
print('9: ',list_3.issubset(list_1))
>>> 9: True
# 父集
print('10: ',list_1.issuperset(list_2))
>>> 10: False
print('11: ',list_1.issuperset(list_3))
>>> 11: True
# 子父集符号判断
print('12: ',list_3 in list_1)
>>> 12: False
print('13: ',list_3 not in list_1)
>>> 13: True
print('14: ',list_3 <= list_1)
>>> 14: True
print('15: ',list_3 >= list_1)
>>> 15: False
# 对称差集
print('16: ',list_1.symmetric_difference(list_3))
>>> 16: {3, 4, 5}
print('17: ',list_1 ^ list_3)
>>> 17: {3, 4, 5}
# 判断交集
print('18: ',list_1.isdisjoint(list_2))
>>> 18: False
集合的逻辑关系基本就是上述这些，除了上述关系外，集合还有一些常用的操作方法：
list_1 = set([1,2,3,4,5])
# 集合元素添加
# 单项添加
list_1.add(212)
print('1: ',list_1)
>>> 1: {1, 2, 3, 4, 5, 212}
# 多项添加
list_1.update([200,201,202])
print('2: ',list_1)
>>> 2: {1, 2, 3, 4, 5, 200, 201, 202, 212}
# 集合元素删除
list_1.remove(212)
print('3: ',list_1)
>>> 3: {1, 2, 3, 4, 5, 200, 201, 202}
list_1.pop()
print('4: ',list_1)
>>> 4: {2, 3, 4, 5, 200, 201, 202}
# discard()删除时假如集合中没有该元素，不报错，返回None，
# 假如存在，则删除，相对应的，remove则在没有该元素时，会报错
list_1.discard(5)
print('5: ',list_1)
>>> 5: {2, 3, 4, 200, 201, 202}
# 集合长度
print('6: ',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: ',info)
info.pop('Shu')
print('pop: ',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(' ',info_pop)
print('popitem: ',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 + ': ',info[i])
>>> Shu: ZhaoYun
Wu: ['LuXun', 'TaiShici']
Wei: DianWei
# itmes()遍历
for key,value in info.items():
print(key + ': ',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 + ': ',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 + ': ',info_show[i])
>>> 三国--蜀: 赵云
三国--蜀: 关羽
三国--吴: 陆逊
三国--吴: 甘宁
三国--魏: 典韦
三国--魏: 张郃
西晋--司马: 司马炎
西晋--司马: 司马昭
东晋--谢: 谢安
东晋--谢: 谢玄