首页 > > 网络编程 > 其它 >

字典

2018-06-17 23:54:23来源：未知阅读 ()

字典

1. 字典的定义

　　在Python中，字典是一种key-value的数据类型，也是唯一的映射类型；字典还是另一种可变容器类型，且可存储任意类型对象，其中也可包括其他容器类型。字典的每个键值(key-value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,语法格式如下：

　　dictionary = {

key1 : value1,

key2 : value2,

......

keyN:valueN,

}

　　映射类型对象里哈希值（键，key）和指向的对象（值，value）是一对多的的关系，通常被认为是可变的哈希表。

2. 字典的特性

　　字典的特性有：

　　（1）字典是无序的。

　　（2）字典的键key必须是唯一的，所以字典中不存在重复数据。

　　（3）键key与值value用冒号“：”分开。

　　（4）项与项用逗号“，”分开。

3. 字典的操作

　　在Python中，由于字典的动态性，我经常需要对其进行键-值对的增、删、改、查，查即访问。

3.1 字典的创建

3.1.1 创建一个空字典

　　在Python中，我们有时需要先创建一个空字典，然后用于存储一些键-值对。创建一个空字典的方式很简单，即让字典等于一个大括号即可。具体语法格式如下所示：

　　dictionary = {}

3.1.2 创建一个有键-值对的字典

　　根据字典的定义中的语法，创建一个以学生学号为key，姓名为value，创建一个字典。

　　例如，以五个学生为例，将每个学生的基本学号和姓名存到字典中，并打印出来。

　　代码：

 1 students ={
 2     'S100001':"Yun Qtian",
 3     'S100002':"Feng Kuang",
 4     'S100003':"Yu Bao",
 5     'S100004':"Dian Lei",
 6     'S100005':"Yu Xiao",
 7 }
 8 print(students)

　　运行结果：

1 {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}

3.2 字典中值的访问

　　在Python中，由于字典是一系列键-值对。每个键都与一个值关联，我们可以使用键来访问其相关联的值，这些值可以是数字、字符串、列表乃至字典等，即可将Python中的任何对象作为字典中的值。

　　因此，在Python中，我们通过以下方式访问字典中的值：

　　字典名[键]

　　例如，我们将学生的学号和姓名存到字典中，然后取出学为S100003的学生的姓名。

　　代码：

1 students ={
2     'S100001':"Yun Qtian",
3     'S100002':"Feng Kuang",
4     'S100003':"Yu Bao",
5     'S100004':"Dian Lei",
6     'S100005':"Yu Xiao",
7 }
8  print(students['S100003'])

　　说明：

　　第8行，由于我们将学号作为学生字典的key，故通过学号即可访问字典中对应的值。此处我们使用学号‘S100003’取出相应的值，并将其打印出来。

　　运行结果：

1 Yu Bao

　　以上访问通过key访问字典的值的方式，前提是我们已经知道该key存在字典中。但是，如果我们查找的key不存在该字典中时，该访问方式就会报错，那么Python为我们提供了另一种通过key查找其在字典中的对应的value。　　

　　例如，我们将学生的学号和姓名存到字典中，然后查找学为S100009的学生是否存在字典中，并打印相关值。

　　代码1：

1 students ={
2     'S100001':"Yun Qtian",
3     'S100002':"Feng Kuang",
4     'S100003':"Yu Bao",
5     'S100004':"Dian Lei",
6     'S100005':"Yu Xiao",
7 }
8 print(students)
9 print(students['S100009'])

　　运行结果1：

1 {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
2 Traceback (most recent call last):
3   File "F:/PyProject/s14/day2/test_dictionary.py", line 9, in <module>
4     print(students['S100009'])
5 KeyError: 'S100009'

　　从以上结果可知，第9行的Key错误，因为字典students中没有这个key。所以Python中，通过key查找其对应的value时，为了避免不必要的错误，可使用get()方法来查找key对应的value。

　　代码2：

 1 students ={
 2     'S100001':"Yun Qtian",
 3     'S100002':"Feng Kuang",
 4     'S100003':"Yu Bao",
 5     'S100004':"Dian Lei",
 6     'S100005':"Yu Xiao",
 7 }
 8 print(students)
 9 print(students['S100003'])
10 print(students.get('S100003'))
11 print(students.get('S100009'))

　　说明：

　　第9、10行，都是通过key （S100003），分别查找其对应的value的值方式，只是第10行使用了get()方法。

　　第11行，使用get()方法查找key(S100009)的值。

　　运行结果2:

1 {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
2 Yu Bao
3 Yu Bao
4 None

　　从以上运行结果可知，当我们确定提供的key已经存在字典中，那么使用哪种访问方式都无所谓，其结果都一样，但是，如果我们不知道key是否存在字典中，那么就用get()方法的方式查找，这样避免出错，没有找到时，Python解释器会返回一个None。

3.3 字典的键-值对增加

　　在Python中，字典是一种动态结构，可随时在其中增加我们需要的键-值对。当我们要往字典中增加键-值对时，可依次指定字典名、用方括号括起来的键和其关联的值。其格式如下：

　　dictionary [kek] = value

例如，我们创建一个空的字典，然后将学生的学号作为键，姓名作为其对应的值，并将其增加到该空字典中。

　　代码：

1 students = {}
2 students['S100001'] = "Yun Qtian"
3 students['S100002'] = "Feng Kuang"
4 students['S100003'] = "Yu Bao"
5 students['S100004'] = "Dian Lei"
6 students['S100005'] = "Yu Xiao"
7 print(students)

　　说明：

　　第1行，定义一个空字典students。

　　第2~6行分别将学号即其对应的学生的姓名增加到空列表students中。

　　第7行，打印增加键-值对后的字典。

　　运行结果：

1 {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}

3.4 字典键-值对的删除

　　在Python中，对于字典中不再需要的信息，可使用del语句将其从字典中删除。使用del语句时，必须指定字典名和删除的键。del 语句删除字典中的键-值对的信息的语法格式为：

　　del dictionary [key]

　　例如，由于学生S100005转学了，我们需要将期从字典students中删。

　　代码：

 1 students ={
 2     'S100001':"Yun Qtian",
 3     'S100002':"Feng Kuang",
 4     'S100003':"Yu Bao",
 5     'S100004':"Dian Lei",
 6     'S100005':"Yu Xiao",
 7 }
 8 print("删除前的字典：",students)
 9 del students['S100005']
10 print("删除后的字典：",students)

　　说明：

　　第9行，使用del语句删除字段students中的学号为S100005的信息。

　　运行结果：

1 删除前的字典： {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
2 删除后的字典： {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei'}

　　从以上的运行结果中，可知，我们删除的键-值对，永久从字典中删除，但不会影响到其他的键-值对。

　　字典的键-值对的删除除以上的del语句外，还有一种pop()方法，其语法格式如下：

　　dictionary.pop(key)

　　例如，用pop实现键-值对的删除。

　　代码：

 1 students ={
 2     'S100001':"Yun Qtian",
 3     'S100002':"Feng Kuang",
 4     'S100003':"Yu Bao",
 5     'S100004':"Dian Lei",
 6     'S100005':"Yu Xiao",
 7 }
 8 print("删除前的字典",students)
 9 print("删除的值：",students.pop('S100002'))
10 print("删除后的字典",students)

　　说明:

　　第9行，使用pop()方法删除学号为S100002的学生信息。

　　运行结果：

1 删除前的字典 {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
2 删除的值： Feng Kuang
3 删除后的字典 {'S100001': 'Yun Qtian', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}

3.5 字典键-值对的修改

　　在Python中，要修改字典中的值，可依次指定字典名、用方括号括起来的键，以及该键对应的新值。其语法格式为：

　　dictionary [key] = value

　　例如，我们将已有字典中学号为S100005的姓名改为“Yu Da”。

　　代码：

 1 students ={
 2     'S100001':"Yun Qtian",
 3     'S100002':"Feng Kuang",
 4     'S100003':"Yu Bao",
 5     'S100004':"Dian Lei",
 6     'S100005':"Yu Xiao",
 7 }
 8 print("修改前的字典：",students)
 9 students['S100005'] = "Yu Da"
10 print("修改后的字典：",students)

　　说明：

　　第9行，将字典students中学号为S100005的姓名改为“Yu Da”。

　　运行结果：

1 修改前的字典： {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
2 修改后的字典： {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Da'}

3.6 字典的合并

　　在Python中，有时为了使用方便，我们可能需要将一个字典合并到另一个字典中。字典的合并可以使用update(）方法，该方法的具体功能是，如果合并的字典的key在原来的字典中存在，那么根据key值更新相应的值，否则在原有的字典中新增新的键-值对。

　　例如，我们创建两个字典，一个字典为students_a，另一个字典为students_b，然后将字典students_2合并到students_1中。

　　代码：

 1 students_a ={
 2     'S100001':"Yun Qtian",
 3     'S100002':"Feng Kuang",
 4     'S100003':"Yu Bao",
 5     'S100004':"Dian Lei",
 6     'S100005':"Yu Xiao",
 7 }
 8 
 9 students_b ={
10     'S100005':"Yun Wu",
11     'S100006':"Hong Cai",
12 }
13 print("合并前的字典students_a：",students_a)
14 print("合并前的字典students_b：",students_b)
15 students_a.update(students_b)
16 print("合并后的字典students_a：",students_a)
17 print("合并后的字典students_b：",students_b)

　　说明：

　　第1~7行，创建了一个字典students_a，该字典中有五个键-值对。

　　第9~12，创建了一个字典students_b，该字典中有两个键-值对。

　　第15行，使用函数update()，将字典students_b合并到字典students_a中。

　　运行结果：

1 合并前的字典students_a： {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
2 合并前的字典students_b： {'S100005': 'Yun Wu', 'S100006': 'Hong Cai'}
3 合并后的字典students_a： {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yun Wu', 'S100006': 'Hong Cai'}
4 合并后的字典students_b： {'S100005': 'Yun Wu', 'S100006': 'Hong Cai'}

　　从以上的运行结果中可知，由于字典students_b中的key为S100005已经存在字典students_a中，则合并后，会将字典students_a中的值更新为合并过来的新值；key为S100006的在字典students_a中没有，故将字典students_b中的S100006及其对应的值增加到字典student_a中。

　　注意，虽然将字典students_b合并到了字典students_a中，但字典students_b仍然存在，还可继续使用。

3.7 字典转换列表

　　在Python中，有时我们需要将一个字典转换为列表，那么可以使用函数items()。

　　例如，将一个已有的学生字典转换为列表。

　　代码：

 1 students ={
 2     'S100001':"Yun Qtian",
 3     'S100002':"Feng Kuang",
 4     'S100003':"Yu Bao",
 5     'S100004':"Dian Lei",
 6     'S100005':"Yu Xiao",
 7 }
 8 print("转换前的字典students：",students)
 9 students_list = students.items()
10 print("转换后的字典students：",students)
11 print("转换后的列表：",students_list)
12 print("----字典转换为列表后，列表的元素如下：----")
13 for student in students_list:
14     print(student)

　　说明：

　　第9行，使用函数items()将字典students转换为一个列表，并赋值给变量students_list。

　　第13~14行，循环打印转换后的列表元素。

　　运行结果：

1 转换前的字典students： {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
2 转换后的字典students： {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
3 转换后的列表： dict_items([('S100001', 'Yun Qtian'), ('S100002', 'Feng Kuang'), ('S100003', 'Yu Bao'), ('S100004', 'Dian Lei'), ('S100005', 'Yu Xiao')])
4 ----字典转换为列表后，列表的元素如下：----
5 ('S100001', 'Yun Qtian')
6 ('S100002', 'Feng Kuang')
7 ('S100003', 'Yu Bao')
8 ('S100004', 'Dian Lei')
9 ('S100005', 'Yu Xiao')

　　从以上的运行结果可知，字典转为为列表后，字典仍然可以继续使用，只是将其键-值对转换为一个列表的元素而已。

3.8 初始化一个字典

　　在Python中，我们有时需要初始化一个字典，那么可使用fromkeys()方法。

　　例如，初始化一个员工字典。

　　代码：

1 emp_dicf = dict.fromkeys(['G100001','G100002','G100003'],{"emp_name","emp_job"})
2 print(emp_dicf)

　　说明：

　　第1行，使用fromkeys()方法初始化一个字典emp_dicf 。

　　运行结果：

1 {'G100001': {'emp_name', 'emp_job'}, 'G100002': {'emp_name', 'emp_job'}, 'G100003': {'emp_name', 'emp_job'}}

　　赋值代码：

1 emp_dict = dict.fromkeys(['G100001','G100002','G100003'],["Yun Qtian",{"emp_name":"Dian  Lei"},"Feng Kuang"])
2 print(emp_dict)
3 emp_dict['G100002'][1]['emp_name'] = "Yu Xiao"
4 print(emp_dict)

　　赋值运行结果：

1 {'G100001': ['Yun Qtian', {'emp_name': 'Dian  Lei'}, 'Feng Kuang'], 'G100002': ['Yun Qtian', {'emp_name': 'Dian  Lei'}, 'Feng Kuang'], 'G100003': ['Yun Qtian', {'emp_name': 'Dian  Lei'}, 'Feng Kuang']}
2 {'G100001': ['Yun Qtian', {'emp_name': 'Yu Xiao'}, 'Feng Kuang'], 'G100002': ['Yun Qtian', {'emp_name': 'Yu Xiao'}, 'Feng Kuang'], 'G100003': ['Yun Qtian', {'emp_name': 'Yu Xiao'}, 'Feng Kuang']}

　　从以上的运行结果可知，所有的key为emp_name的值都被改为了Yu Xiao，这并不是我们想要的结果，我们只是想修改key为G100002的员工对应的姓名，其他的键-值对不变。

　　因此，fromkeys()方法只适合用于初始化字典，并不能用于给具体的键-值对赋值。

4. 字典的遍历

　　在Python中，一个字典可能包含几个键-值对，也可能包含数百万个键-值对。鉴于字典可能包含大量数据，Python支持对字典进行遍历。由于字典可以用于存储个汇总给形式的信息，因此，对字典的遍历方式也有多种：可遍历字典的所有键-值对、键或值等。

4.1 遍历字典中的所有键-值对

　　在Python中，我们可以使用for循环遍历字典中的所有键-值对。

　　例如，我们遍历字典students重点额所有学生的学号和姓名。

　　代码：

 1 students ={
 2     'S100001':"Yun Qtian",
 3     'S100002':"Feng Kuang",
 4     'S100003':"Yu Bao",
 5     'S100004':"Dian Lei",
 6     'S100005':"Yu Xiao",
 7 }
 8 print(students)
 9 print('----第一种遍历方式----')
10 for student in students:
11     print(student,students[student])
12 print('----第二种遍历方式----')
13 for key,value in students.items():
14     print(key,value)

　　说明

　　第10行，用for循环对字典students进行遍历，每次遍历的键-值对存到变量student中。

　　第11行，打印每次循环的键-值对。

　　第13行，用for循环对字典students进行遍历，每次遍历的键和值分别存到变量key和value中。

　　第14行，打印每次循环的键和值。

　　运行结果：

 1 {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
 2 ----第一种遍历方式----
 3 S100001 Yun Qtian
 4 S100002 Feng Kuang
 5 S100003 Yu Bao
 6 S100004 Dian Lei
 7 S100005 Yu Xiao
 8 ----第二种遍历方式----
 9 S100001 Yun Qtian
10 S100002 Feng Kuang
11 S100003 Yu Bao
12 S100004 Dian Lei
13 S100005 Yu Xiao

　　注意：从以上的运行结果可知，两种方式都能遍历字典，但是第一种方式的遍历效率比第二种方式高效，因为第二种方式有一个将字典转换为列表的过程。

4.2 遍历字典中的所有的键

　　在Python中，当我们需要使用字典中的键时，方法keys()很有用，它可以从字典中提取出所有的键。

　　例如，打印字典中所有学生的学号。

　　代码：

 1 students ={
 2     'S100001':"Yun Qtian",
 3     'S100002':"Feng Kuang",
 4     'S100003':"Yu Bao",
 5     'S100004':"Dian Lei",
 6     'S100005':"Yu Xiao",
 7 }
 8 print(students)
 9 print("学生的学号如下：")
10 print("----第一种方式-----")
11 for student_no in students.keys():
12     print(student_no)
13 print("----第二种方式-----")
14 for _student_no in students:
15     print(_student_no)

　　说明：

　　第11行，在for循环中，使用方法keys()读取字典students中的中所有key，并存于变量student_no中。

　　第14行，在for循环中，将每次循环的值存到变量_student_no中。

　　运行结果：

 1 {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
 2 学生的学号如下：
 3 ----第一种方式-----
 4 S100001
 5 S100002
 6 S100003
 7 S100004
 8 S100005
 9 ----第二种方式-----
10 S100001
11 S100002
12 S100003
13 S100004
14 S100005

　　从以上的运行结果，我们可知，在Python中，当我遍历字典时，Python解释器会默认遍历所有的键，因此，两种循环遍历的输出结果都是一致的。只是使用keys()方法可以让代码更容易理解。

4.3 遍历字典中的所有的值

　　在Python中，有时我们只需要输出字典的值，不关注键，此时，我们可以使用方法values()，该方法即可放回一个值列表，而不包含任何键。

　　例如，我们打印字典中的学生的姓名。

　　代码：

 1 students ={
 2     'S100001':"Yun Qtian",
 3     'S100002':"Feng Kuang",
 4     'S100003':"Yu Bao",
 5     'S100004':"Dian Lei",
 6     'S100005':"Yu Xiao",
 7 }
 8 print(students)
 9 print("学生的姓名如下：")
10 print("----第一种方式-----")
11 for student_name in students.values():
12     print(student_name)
13 print("----第二种方式-----")
14 for kek in students.keys():
15     print(students[kek])

　　说明：

　　第11行，在for循环中，调用方法values()从字典中读取字典的值，并存于变量student_name中。

　　第14行，在for循环中，调用方法keys()从字典中读取字典的键，并存于变量key中。

　　第15行，通过每次取到的key访问字典的值。

　　运行结果：

 1 {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
 2 学生的姓名如下：
 3 ----第一种方式-----
 4 Yun Qtian
 5 Feng Kuang
 6 Yu Bao
 7 Dian Lei
 8 Yu Xiao
 9 ----第二种方式-----
10 Yun Qtian
11 Feng Kuang
12 Yu Bao
13 Dian Lei
14 Yu Xiao

5. 嵌套

　　在Python中，有时我们需要将一系列字典存储在列表中，或将列表作为值存储到字典中，这就是所谓的嵌套。嵌套是一项强大的功能，我们可以在列表中嵌套字典、在字典中嵌套列表，也可以在字典中嵌套字典等。

5.1 字典列表

　　字典列表，即由字典组成的列表，或者说在空列表中嵌套字典。

　　例如，我们先创建一个空列表，再分别三个字典，然后将该三个字典嵌套到列表中。

　　代码：

 1 students_list = []
 2 students_1 = {
 3     'student_no':"S100001",
 4     'sex':"M",
 5     'age':"20"
 6 }
 7 students_2 = {
 8     'student_no':"S100002",
 9     'sex':"M",
10     'age':"21"
11 }
12 students_3 = {
13     'student_no':"S100003",
14     'sex':"F",
15     'age':"18"
16 }
17 students_list.append(students_1)
18 students_list.append(students_2)
19 students_list.append(students_3)
20 print(students_list)
21 for  student in students_list:
22     print(student)

　　说明：

　　第1行，创建一个空列表students_list 。

　　第2~6行，创建第一个字典student_1。

　　第7~11行，创建第二个字典student_2。

　　第12~16行，创建第三个字典student_3。

　　第17~19行，分别将创建的三个字典增加到创建的空列表中。

　　第21~22行，循环打印该列表的元素。

　　运行结果：

1 [{'student_no': 'S100001', 'sex': 'M', 'age': '20'}, {'student_no': 'S100002', 'sex': 'M', 'age': '21'}, {'student_no': 'S100003', 'sex': 'F', 'age': '18'}]
2 {'student_no': 'S100001', 'sex': 'M', 'age': '20'}
3 {'student_no': 'S100002', 'sex': 'M', 'age': '21'}
4 {'student_no': 'S100003', 'sex': 'F', 'age': '18'}

5.2 在字典中存储列表

　　在Python中，有时我们需要将列表存于字典，而不是将字典存于列表。

　　例如，我们创建一个空字典，然后分别创建三个列表，并将其存于字典中。

　　代码：

 1 students = {}
 2 student_list1 =["S100001","M","20"]
 3 student_list2 =["S100002","M","21"]
 4 student_list3 =["S100003","F","18"]
 5 students[student_list1[0]] = student_list1
 6 students[student_list2[0]] = student_list2
 7 students[student_list3[0]] = student_list3
 8 print(students)
 9 for value in students.values():
10     print(value)
11     for _students in value:
12         print(_students)

　　说明：

　　第1行，创建一个空字典students。

　　第2~4行，分别创建一个不同的列表。

　　第5~7行，以每个学生的学号为key，列表的值为value分别向空字典中增加键-值对。

　　第8行，打印嵌套后的字典。

　　第9~10行，循环打印字典的值。

　　第11~12行，循环打印被嵌套的列表的每个元素。

　　运行结果：

 1 {'S100001': ['S100001', 'M', '20'], 'S100002': ['S100002', 'M', '21'], 'S100003': ['S100003', 'F', '18']}
 2 ['S100001', 'M', '20']
 3 S100001
 4 M
 5 20
 6 ['S100002', 'M', '21']
 7 S100002
 8 M
 9 21
10 ['S100003', 'F', '18']
11 S100003
12 F
13 18

　　在Python中，列表和字典的嵌套层级不应太多。如果嵌套层级非常多，很可能有更简单的解决方案。

5.3 在字典中存储字典

　　在Python中，我们虽然可以在字典中嵌套字典，但这样也许会让代码很快就复杂起来。

　　例如，我们将每个学生的基本信息作为一个字典，然后再存到一个总的字典中。

　　代码：

 1 students ={
 2     "S100001":{
 3         "sex":"M",
 4         "age":"20",
 5        },
 6     "S100002": {
 7         "sex": "M",
 8         "age": "21",
 9     },
10     "S100003": {
11         "sex": "F",
12         "age": "18",
13     },
14 }
15 print(students)
16 for key,value in students.items():
17     print(key,value["sex"],value["age"])

　　说明：

　　第1~14行，创建一个字典students，其中第2~5行为字典students的一个键-值对，而第3~4行又是键-值对字典的一个键-值对，字典students的其余两个键-值对也类似。

　　第15行，打印字典的键-值对。

　　第16~17行，循环打印字典中的每个键-值对的具体值。

　　运行结果：

1 {'S100001': {'sex': 'M', 'age': '20'}, 'S100002': {'sex': 'M', 'age': '21'}, 'S100003': {'sex': 'F', 'age': '18'}}
2 S100001 M 20
3 S100002 M 21
4 S100003 F 18