其中也可包括其他容器类型,1.创建空字典
字典
以键值对方式存在的无序数据的组合就是字典
在Python中,由于字典是一系列键-值对。每个键都与一个值关联,我们可以使用键来访问其相关联的值,这些值可以是数字、字符串、列表乃至字典等,即可将Python中的任何对象作为字典中的值。
序列函数
len() 计算字典中元素的长度
max() 获取字典中最大的键
min() 获取字典中最大的值
dict() 创建空字典或者将其他类型转化字典
5.2 在字典中存储列表
一般数据库系统中经常使用的字典的设计
字典的序列操作
字典值可以进行一种序列操作:成员检测
值 in 字典
检测一个值是否在字典的键中
值 not in 字典
检测一个值是否不再字典的键中
第2~6行,创建第一个字典student_1。
例如:
字典专用函数
clear() 清空字典
格式:字典.clear()
返回值:None
注意:直接改变原有字典
copy() 复制字典
格式:字典.copy()
返回值:新的字典
fromkeys() 使用指定的序列(列表)作为键创建字典
格式:字典.fromkeys(序列,值)
返回值:字典
get() 根据键获取指定的值
格式:字典.get(键[,默认值])
返回值:值
注意:如果键不存在,则使用默认值,如果没有默认值则返回None
items() 将字典的键值转化成类似元组的形式方便遍历
格式:字典.items()
返回值:类似元组的类型
keys()将字典的所有键组成一个序列
格式:字典.keys()
返回值:序列
values() 将字典的所有值组成一个序列
格式:字典.values()
返回值:序列
pop() 移除字典中指定的元素
格式:字典.pop(键[,默认值])
返回值:被移除的键对应的值
注意:如果键不存在,则报错,如果键不存在,默认值设置,则返回默认值
popitem() 移除字典中的键值对
格式:字典.popitem()
返回值:键值对组成的元组
注意:弹一个原字典就少一个,字典为空就不可以弹出,会报错
setdefault() 添加一个元素
格式:字典.setdefault(键,值)
返回值:None
注意:添加是键存在则不进行任何操作,键不存在则添加,添加是不写值,默认None值
update() 修改字典的中值
格式: 字典.update(键=值)
返回值:None
注意:此处的键作为关键字参数使用,不可以添加''
格式: 字典.update({键:值})
返回值:None
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'}
字典内涵/字典推导式
1.普通的字典内涵
变量= {key:value for key,value in 字典.items()}
2.带有判断条件的字典内涵
变量= {key:value for key,value in 字典.items() if 条件表达式}
3,多个循环的字典内涵
变量 = {i+x:j+y for i,j in 字典1.items for x,y in 字典2.items()}
4.带有判断条件的多个循环的字典内涵
变量 = {i+x:j+y for i,j in 字典1.items for x,y in 字典2.items() if 条件表达式}
赋值代码:
或者:
字典的基本操作
访问字典的元素:
变量[键]
添加字典的元素
变量[新键] = 值
修改字典元素
变量[键] = 新值
删除字典元素
del 变量[键]
第5~7行,以每个学生的学号为key,列表的值为value分别向空字典中增加键-值对。
创建字典
1.创建空字典
变量 = {} 或者 变量 = dict()
2.创建多个元素的字典:
方法1:
变量 = {键:值,键:值....}
方法2:
变量 = dict({键:值,键:值....})
方法3:
变量 = dict(键=值,键=值...)
注意:该方式键作为形参名使用不可以添加引号,必须符合变量规则
方法4:
变量 = dict([(键,值),(键,值)...])
变量 = dict([[键,值],[键,值]...])
变量 = dict(((键,值),(键,值)...))
方法5:
变量 = dict(zip((键,键...),(值,值...)))
以上访问通过key访问字典的值的方式,前提是我们已经知道该key存在字典中。但是,如果我们查找的key不存在该字典中时,该访问方式就会报错,那么Python为我们提供了另一种通过key查找其在字典中的对应的value。
字典的遍历
1.键的遍历
for 变量i in 字典:
使用i遍历所有的键,有键就可以通过变量访问其值
2.键值遍历
for 变量i,变量j in 字典.items():
使用变量i遍历所有键,通过变量j遍历所有值
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')
字典(Dictionary)
字典的操作
在Python中,我们有时需要先创建一个空字典,然后用于存储一些键-值对。创建一个空字典的方式很简单,即让字典等于一个大括号即可。具体语法格式如下所示:
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)
字段名
|
类型
|
说明
|
编号
|
Char(16)
|
间断增量(Not Null,PK)
|
分类名称
|
Varchar(64)
|
用来进行过滤选取字典表相关域
|
内容
|
Varchar(255)
|
|
上级编号
|
Char(16)
|
取Dictionary的编号(FK),用来进行等级设计。使之成为树型结构。
|
商品信息购买表OrderInfo
从以上的运行结果可知,字典转为为列表后,字典仍然可以继续使用,只是将其键-值对转换为一个列表的元素而已。
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'])
说明:
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']}
dictionary [key] = value
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 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])
key1 : value1,
第13~14行,循环打印转换后的列表元素。
del dictionary [key]
(2)字典的键key必须是唯一的,所以字典中不存在重复数据。
第1行,创建一个空列表students_list 。
说明:
字典的特性有:
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'}
说明:
......
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
第15行,使用函数update(),将字典students_b合并到字典students_a中。
运行结果:
}
第9行,将字典students中学号为S100005的姓名改为“Yu Da”。
例如,用pop实现键-值对的删除。
第7行,打印增加键-值对后的字典。
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)
说明:
运行结果2:
key2 : value2,
第9行,使用函数items()将字典students转换为一个列表,并赋值给变量students_list。
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'])
第8行,打印嵌套后的字典。
说明
3.3 字典的键-值对增加
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)
在Python中,我们可以使用for循环遍历字典中的所有键-值对。
第11~12行,循环打印被嵌套的列表的每个元素。
说明:
例如,我们将每个学生的基本信息作为一个字典,然后再存到一个总的字典中。
3.6 字典的合并
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)
3.1.1 创建一个空字典
第12~16行,创建第三个字典student_3。
4. 字典的遍历
第11行,在for循环中,使用方法keys()读取字典students中的中所有key,并存于变量student_no中。
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)
3.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 del students['S100005']
10 print("删除后的字典:",students)
说明:
代码:
第1行,使用fromkeys()方法初始化一个字典emp_dicf 。
4.1 遍历字典中的所有键-值对
第7~11行,创建第二个字典student_2。
在Python中,有时为了使用方便,我们可能需要将一个字典合并到另一个字典中。字典的合并可以使用update()方法,该方法的具体功能是,如果合并的字典的key在原来的字典中存在,那么根据key值更新相应的值,否则在原有的字典中新增新的键-值对。
运行结果:
第14行,在for循环中,将每次循环的值存到变量_student_no中。
例如,我们创建一个空字典,然后分别创建三个列表,并将其存于字典中。
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'}
1 {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
代码:
1 {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
2 Yu Bao
3 Yu Bao
4 None
代码:
在Python中,列表和字典的嵌套层级不应太多。如果嵌套层级非常多,很可能有更简单的解决方案。
注意:从以上的运行结果可知,两种方式都能遍历字典,但是第一种方式的遍历效率比第二种方式高效,因为第二种方式有一个将字典转换为列表的过程。
第2~4行,分别创建一个不同的列表。
第9行,使用pop()方法删除学号为S100002的学生信息。
keyN:valueN,
例如,将一个已有的学生字典转换为列表。
运行结果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 students['S100005'] = "Yu Da"
10 print("修改后的字典:",students)
在Python中,当我们需要使用字典中的键时,方法keys()很有用,它可以从字典中提取出所有的键。
dictionary = {}
第1行,定义一个空字典students。
从以上的运行结果可知,所有的key为emp_name的值都被改为了Yu Xiao,这并不是我们想要的结果,我们只是想修改key为G100002的员工对应的姓名,其他的键-值对不变。
第10行,用for循环对字典students进行遍历,每次遍历的键-值对存到变量student中。
第9行,使用del语句删除字段students中的学号为S100005的信息。
运行结果:
第11行,在for循环中,调用方法values()从字典中读取字典的值,并存于变量student_name中。
1 {'G100001': {'emp_name', 'emp_job'}, 'G100002': {'emp_name', 'emp_job'}, 'G100003': {'emp_name', 'emp_job'}}
运行结果:
第1行,创建一个空字典students。
在Python中,字典是一种动态结构,可随时在其中增加我们需要的键-值对。当我们要往字典中增加键-值对时,可依次指定字典名、用方括号括起来的键和其关联的值。其格式如下:
1 Yu Bao
在Python中,要修改字典中的值,可依次指定字典名、用方括号括起来的键,以及该键对应的新值。其语法格式为:
在Python中,由于字典的动态性,我经常需要对其进行键-值对的增、删、改、查,查即访问。
第9~10行,循环打印字典的值。
说明:
因此,在Python中,我们通过以下方式访问字典中的值:
代码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:",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)
3.7 字典转换列表
3.1.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.pop('S100002'))
10 print("删除后的字典",students)
从以上结果可知,第9行的Key错误,因为字典students中没有这个key。所以Python中,通过key查找其对应的value时,为了避免不必要的错误,可使用get()方法来查找key对应的value。
代码:
第15行,通过每次取到的key访问字典的值。
代码2:
例如,我们创建一个空的字典,然后将学生的学号作为键,姓名作为其对应的值,并将其增加到该空字典中。
说明:
代码:
5.1 字典列表
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
第11行,使用get()方法查找key(S100009)的值。
说明:
代码:
例如,我们将学生的学号和姓名存到字典中,然后取出学为S100003的学生的姓名。
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
第21~22行,循环打印该列表的元素。
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)
dictionary [kek] = value
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"])
字典名[键]
运行结果:
例如,我们创建两个字典,一个字典为students_a,另一个字典为students_b,然后将字典students_2合并到students_1中。
运行结果:
因此,fromkeys()方法只适合用于初始化字典,并不能用于给具体的键-值对赋值。
www.9159.com , 第1~14行,创建一个字典students,其中第2~5行为字典students的一个键-值对,而第3~4行又是键-值对字典的一个键-值对,字典students的其余两个键-值对也类似。
代码:
字典列表,即由字典组成的列表,或者说在空列表中嵌套字典。
第14行,打印每次循环的键和值。
赋值运行结果:
第15行,打印字典的键-值对。
dictionary.pop(key)
1. 字典的定义
4.2 遍历字典中的所有的键
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
从以上的运行结果中可知,由于字典students_b中的key为S100005已经存在字典students_a中,则合并后,会将字典students_a中的值更新为合并过来的新值;key为S100006的在字典students_a中没有,故将字典students_b中的S100006及其对应的值增加到字典student_a中。
3.8 初始化一个字典
运行结果:
例如,我们打印字典中的学生的姓名。
代码:
例如,打印字典中所有学生的学号。
从以上运行结果可知,当我们确定提供的key已经存在字典中,那么使用哪种访问方式都无所谓,其结果都一样,但是,如果我们不知道key是否存在字典中,那么就用get()方法的方式查找,这样避免出错,没有找到时,Python解释器会返回一个None。
3.4 字典键-值对的删除
例如,我们将已有字典中学号为S100005的姓名改为“Yu Da”。
从以上的运行结果,我们可知,在Python中,当我遍历字典时,Python解释器会默认遍历所有的键,因此,两种循环遍历的输出结果都是一致的。只是使用keys()方法可以让代码更容易理解。
第8行,由于我们将学号作为学生字典的key,故通过学号即可访问字典中对应的值。此处我们使用学号‘S100003’取出相应的值,并将其打印出来。
运行结果:
在Python中,一个字典可能包含几个键-值对,也可能包含数百万个键-值对。鉴于字典可能包含大量数据,Python支持对字典进行遍历。由于字典可以用于存储个汇总给形式的信息,因此,对字典的遍历方式也有多种:可遍历字典的所有键-值对、键或值等。
在Python中,有时我们需要将列表存于字典,而不是将字典存于列表。
例如,以五个学生为例,将每个学生的基本学号和姓名存到字典中,并打印出来。
代码:
2. 字典的特性
第17~19行,分别将创建的三个字典增加到创建的空列表中。
映射类型对象里哈希值(键,key)和指向的对象(值,value)是一对多的的关系,通常被认为是可变的哈希表。
第13行,用for循环对字典students进行遍历,每次遍历的键和值分别存到变量key和value中。
在Python中,对于字典中不再需要的信息,可使用del语句将其从字典中删除。使用del语句时,必须指定字典名和删除的键。del 语句删除字典中的键-值对的信息的语法格式为:
3.1 字典的创建
第9、10行,都是通过key (S100003),分别查找其对应的value的值方式,只是第10行使用了get()方法。
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'))
例如,由于学生S100005转学了,我们需要将期从字典students中删。
例如,我们先创建一个空列表,再分别三个字典,然后将该三个字典嵌套到列表中。
3. 字典的操作
到此为止,Python的字典学习就完成了。
例如,我们将学生的学号和姓名存到字典中,然后查找学为S100009的学生是否存在字典中,并打印相关值。
代码:
说明:
说明:
第2~6行分别将学号即其对应的学生的姓名增加到空列表students中。
运行结果:
第9~12,创建了一个字典students_b,该字典中有两个键-值对。
注意,虽然将字典students_b合并到了字典students_a中,但字典students_b仍然存在,还可继续使用。
运行结果:
(3)键key与值value用冒号“:”分开。
在Python中,我们有时需要初始化一个字典,那么可使用fromkeys()方法。
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
5.3 在字典中存储字典
1 {'S100001': 'Yun Qtian', 'S100002': 'Feng Kuang', 'S100003': 'Yu Bao', 'S100004': 'Dian Lei', 'S100005': 'Yu Xiao'}
说明:
在Python中,有时我们需要将一系列字典存储在列表中,或将列表作为值存储到字典中,这就是所谓的嵌套。嵌套是一项强大的功能,我们可以在列表中嵌套字典、在字典中嵌套列表,也可以在字典中嵌套字典等。
代码:
在Python中,有时我们只需要输出字典的值,不关注键,此时,我们可以使用方法values(),该方法即可放回一个值列表,而不包含任何键。
运行结果:
4.3 遍历字典中的所有的值
第11行,打印每次循环的键-值对。
在Python中,有时我们需要将一个字典转换为列表,那么可以使用函数items()。
1 emp_dicf = dict.fromkeys(['G100001','G100002','G100003'],{"emp_name","emp_job"})
2 print(emp_dicf)
在Python中,我们虽然可以在字典中嵌套字典,但这样也许会让代码很快就复杂起来。
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'}
第1~7行,创建了一个字典students_a,该字典中有五个键-值对。
第16~17行,循环打印字典中的每个键-值对的具体值。
例如,我们遍历字典students重点额所有学生的学号和姓名。
dictionary = {
代码:
在Python中,字典是一种key-value的数据类型,也是唯一的映射类型;字典还是另一种可变容器类型,且可存储任意类型对象,其中也可包括其他容器类型。字典的每个键值(key-value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 ,语法格式如下:
(1)字典是无序的。
3.5 字典键-值对的修改
从以上的运行结果中,可知,我们删除的键-值对,永久从字典中删除,但不会影响到其他的键-值对。
代码:
说明:
字典
第14行,在for循环中,调用方法keys()从字典中读取字典的键,并存于变量key中。
5. 嵌套
根据字典的定义中的语法,创建一个以学生学号为key,姓名为value,创建一个字典。
说明:
(4)项与项用逗号“,”分开。
例如,初始化一个员工字典。
运行结果:
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'}
运行结果:
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'
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)
字典的键-值对的删除除以上的del语句外,还有一种pop()方法,其语法格式如下:
本文由9159.com发布于www.9159.com,转载请注明出处:其中也可包括其他容器类型,1.创建空字典
关键词:
下一篇:没有了