内容正文:
项目六 组合数据类型
Contents
列表List的用法
元组Tuple的用法
掌握集合Set的用法
字典Dictionary的用法
可变类型与不可变类型
PART 01
Python中的类型分为两种:可变类型和不可变类型。
可变类型,即可以对该类型对象中保存的元素值做修改,如列表、字典都是可变类型。
不可变类型,即该类型对象所保存的元素值不允许修改,只能通过给对象整体赋值来修改对象所保存的数据。但此时实际上就是创建了一个新的不可变类型的对象、而不是修改原对象的值,如数字、字符串、元组都是不可变类型。
可变类型与不可变类型
4
可变类型与不可变类型
【任务描述】
了解可变类型与不可变类型
【关键步骤】
了解可变类型与不可变类型
示例01
代码缩进 4个空格
正文缩进1.27厘米
5
1 n1,n2=1,1 #定义两个整型变量n1和n2,都赋值为1
2 print('第 2行n1和n2的内存地址分别为:', id(n1), id(n2))
3 n2=3 #将n2重新赋值为3
4 print('第 4行n1和n2的内存地址分别为:', id(n1), id(n2))
5 n1=3 #将n1重新赋值为3
6 print('第 6行n1和n2的内存地址分别为:', id(n1), id(n2))
7 s1,s2='Python','Python' #定义两个字符串变量s1和s2,都赋值为'Python'
8 print('第 8行s1和s2的内存地址分别为:', id(s1), id(s2))
9 s2='C++' #将s2重新赋值为'C++'
10 print('第10行s1和s2的内存地址分别为:', id(s1), id(s2))
11 s1='C++' #将s1重新赋值为'C++'
12 print('第12行s1和s2的内存地址分别为:', id(s1), id(s2))
13 t1,t2=(1,2,3),(1,2,3) #定义两个元组变量t1和t2,都赋值为(1,2,3)
14 print('第14行t1和t2的内存地址分别为:', id(t1), id(t2))
15 t2=(1,2,3) #t2被重新赋值为(1,2,3)
16 print('第16行t1和t2的内存地址分别为:', id(t1), id(t2))
17 ls1,ls2=[1,2,3],[1,2,3] #定义两个列表变量ls1和ls2,都赋值为[1,2,3]
18 print('第18行ls1和ls2的内存地址分别为:', id(ls1), id(ls2))
19 ls2[1]=5 #将列表ls2中下标为1的元素值重新赋值为5
20 print('第20行ls1和ls2的内存地址分别为:', id(ls1), id(ls2))
21 ls2=[1,2,3] #ls2被重新赋值为[1,2,3]
22 print('第22行ls1和ls2的内存地址分别为:', id(ls1), id(ls2))
可变类型与不可变类型
示例01
代码缩进 4个空格
正文缩进1.27厘米
6
第 2行n1和n2的内存地址分别为: 140724681233440 140724681233440
第 4行n1和n2的内存地址分别为: 140724681233440 140724681233504
第 6行n1和n2的内存地址分别为: 140724681233504 140724681233504
第 8行s1和s2的内存地址分别为: 2484401162312 2484401162312
第10行s1和s2的内存地址分别为: 2484401162312 2484402647480
第12行s1和s2的内存地址分别为: 2484402647480 2484402647480
第14行t1和t2的内存地址分别为: 2484401955176 2484401955392
第16行t1和t2的内存地址分别为: 2484401955176 2484401955464
第18行ls1和ls2的内存地址分别为: 2484400710216 2484400710280
第20行ls1和ls2的内存地址分别为: 2484400710216 2484400710280
第22行ls1和ls2的内存地址分别为: 2484400710216 2484401200264
程序执行完毕后,将在屏幕上输出如下结果:
可变类型与不可变类型
示例01
代码缩进 4个空格
正文缩进1.27厘米
7
列表List
PART 02
列表就是用一对中括号括起来的多个元素的有序集合,各元素之间用逗号分隔。
如果一个列表中不包含任何元素(即只有一对中括号),则该列表就是一个空列表。
创建列表
代码缩进 4个空格
正文缩进1.27厘米
9
列表List
【任务描述】
了解列表的常用操作
【关键步骤】
了解列表的常用操作
示例02
代码缩进 4个空格
正文缩进1.27厘米
10
ls1=[1,'one','一'] #创建列表对象并将其赋给变量ls1,其包含3个元素
ls2=[] #创建列表对象并将其赋给变量ls2,其不包含任何元素、因此是一个空列表
print('ls1的值为:',ls1)
print('ls2的值为:',ls2)
创建列表示例:
ls1的值为: [1, 'one', '一']
ls2的值为: []
程序执行完毕后,将在屏幕上输出如下结果:
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
11
ls=list((1,'one','一')) #使用list方法根据元组创建列表对象,并赋给ls变量
print('ls的值为:',ls)
print('ls的第一个元素和最后一个元素的值分别为:',ls[0],ls[-1])
print('ls的前两个元素的值为:',ls[0:-1])
除了使用一对中括号创建列表对象的这种方式外,还可以利用Python的内置方法list根据一个元组创建一个列表对象。
ls的值为: [1, 'one', '一']
ls的第一个元素和最后一个元素的值分别为: 1 一
ls的前两个元素的值为: [1, 'one']
程序执行完毕后,将在屏幕上输出如下结果:
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
12
ls1=[1,2,3] #创建列表对象并赋给变量ls1
ls2=['Python','C++'] #创建列表对象并赋给变量ls2
ls3=ls1+ls2 #通过拼接运算“+”将ls1和ls2连接生成一个新的列表对象并赋给ls3
print('ls1和ls2的值分别为:',ls1,ls2)
print('ls3的值为:',ls3)
通过拼接运算可以将多个列表连接在一起,生成一个新的列表。
ls1和ls2的值分别为: [1, 2, 3] ['Python', 'C++']
ls3的值为: [1, 2, 3, 'Python', 'C++']
程序执行完毕后,将在屏幕上输出如下结果:
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
13
Python中,通过赋值运算实际上是将两个变量指向同一个对象,而不是将一个变量的值赋给另一个变量。
两个变量指向同一个对象后,我们通过一个变量修改对象中元素的值,那么通过另一个变量访问对象时,访问到的对象中的元素值也是修改后的值。
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
14
ls1=[1,2,3] #创建列表对象并赋给变量ls1
ls2=ls1 #通过赋值运算ls2和ls1指向同一个对象
print('ls1和ls2的值分别为:',ls1,ls2)
print('ls1和ls2的内存地址分别为:',id(ls1),id(ls2))
ls1[1]=5 #将ls1中下标为1的元素值修改为5
print('ls1和ls2的值分别为:',ls1,ls2)
复制列表元素示例:
ls1和ls2的值分别为: [1, 2, 3] [1, 2, 3]
ls1和ls2的内存地址分别为: 1977218523720 1977218523720
ls1和ls2的值分别为: [1, 5, 3] [1, 5, 3]
程序执行完毕后,将在屏幕上输出如下结果:
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
15
ls1=[1,2,3] #创建列表对象并赋给变量ls1
ls2=ls1[:] #通过ls1[:]将ls1的所有元素截取生成新对象并赋给ls2
print('ls1和ls2的值分别为:',ls1,ls2)
print('ls1和ls2的内存地址分别为:',id(ls1),id(ls2))
ls1[1]=5 #将ls1中下标为1的元素值修改为5
print('ls1和ls2的值分别为:',ls1,ls2)
采用元素截取的方法,根据一个已有列表对象复制出另一个新的列表对象,后面对两个对象的操作完全独立
ls1和ls2的值分别为: [1, 2, 3] [1, 2, 3]
ls1和ls2的内存地址分别为: 2021463056968 2021463057032
ls1和ls2的值分别为: [1, 5, 3] [1, 2, 3]
程序执行完毕后,将在屏幕上输出如下结果:
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
16
ls1=[1,[2,3]] #创建列表对象并赋给变量ls1
ls2=ls1[:] #通过ls1[:]将ls1的所有元素截取生成新对象并赋给ls2
print('ls1和ls2的值分别为:',ls1,ls2)
print('ls1和ls2的内存地址分别为:',id(ls1),id(ls2))
print('ls1[1]和ls2[1]的内存地址分别为:',id(ls1[1]),id(ls2[1]))
ls1[1][0]=5 #将ls1下标为1的列表元素(即ls[1])中下标为0的元素值修改为5
print('ls1和ls2的值分别为:',ls1,ls2)
如果一个列表中包含列表类型的元素,会出现两个列表中的部分元素指向同一个对象的问题。
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
17
ls1和ls2的值分别为: [1, [2, 3]] [1, [2, 3]]
ls1和ls2的内存地址分别为: 1416753996424 1416754486344
ls1[1]和ls2[1]的内存地址分别为: 1416753996360 1416753996360
ls1和ls2的值分别为: [1, [5, 3]] [1, [5, 3]]
程序执行完毕后,将在屏幕上输出如下结果:
示例02
import copy #导入copy模块
ls1=[1,[2,3]] #创建列表对象并赋给变量ls1
ls2=copy.deepcopy(ls1) #通过调用deepcopy函数复制ls1生成新对象并赋给ls2
print('ls1和ls2的值分别为:',ls1,ls2)
print('ls1和ls2的内存地址分别为:',id(ls1),id(ls2))
print('ls1[1]和ls2[1]的内存地址分别为:',id(ls1[1]),id(ls2[1]))
ls1[1][0]=5 #将ls1下标为1的列表元素(即ls[1])中下标为0的元素值修改为5
print('ls1和ls2的值分别为:',ls1,ls2)
为了真正实现列表的复制操作,可以使用Python在copy模块中提供的deepcopy函数。
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
19
ls1和ls2的值分别为: [1, [2, 3]] [1, [2, 3]]
ls1和ls2的内存地址分别为: 1942483404104 1942484025224
ls1[1]和ls2[1]的内存地址分别为: 1942483405896 1942484062280
ls1和ls2的值分别为: [1, [5, 3]] [1, [2, 3]]
程序执行完毕后,将在屏幕上输出如下结果:
示例02
ls.index(x)
通过列表中的index方法可以根据指定值查找第一个匹配的列表元素的位置。格式:
ls值为3的元素第一次出现的位置为: 1
程序执行完毕后,将在屏幕上输出如下结果:
其中,ls是要进行元素查找操作的列表对象,x是要查找的元素值,返回值是ls中第一个值为x的元素的位置。例如:
ls=[1,3,5,3] #使用list方法根据元组创建列表对象,并赋给ls变量
print('ls值为3的元素第一次出现的位置为:',ls.index(3))
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
21
ls.insert(index, x)
通过列表中的insert方法可以将一个元素插入到列表的指定位置。格式:
如果要在列表的最后添加新元素,则还可以直接使用列表的append方法,append方法的语法格式为:
ls.append(x)
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
22
ls=[1,2,3] #创建列表对象并赋给ls
ls.insert(0, 'Python') #在ls列表下标为0的位置插入新元素'Python'
print(ls) #输出ls
ls.insert(2, True) #在ls列表下标为2的位置插入新元素True
print(ls) #输出ls
ls.append([5,10]) #在ls列表最后添加新元素[5,10]
print(ls) #输出ls
示例:
['Python', 1, 2, 3]
['Python', 1, True, 2, 3]
['Python', 1, True, 2, 3, [5, 10]]
程序执行完毕后,将在屏幕上输出如下结果:
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
23
ls=[0,1,2,3,4,5,6,7,8,9] #创建列表对象并赋给ls
del ls[8] #使用del将ls中下标为8的元素删除
print(ls) #输出ls
ls[1:6]=[] #将ls中下标为1至5的元素删除
print(ls) #输出ls
使用del 语句可以删除某个变量或列表中的某个元素。如果要删除列表中的连续多个元素,也可以截取列表中的连续多个元素并将其赋为空列表。
[0, 1, 2, 3, 4, 5, 6, 7, 9]
[0, 6, 7, 9]
程序执行完毕后,将在屏幕上输出如下结果:
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
24
max(ls)
使用max方法可以获取一个列表中最大元素的值,max方法的语法格式如下:
ls中的最大元素值为: 56
程序执行完毕后,将在屏幕上输出如下结果:
ls=[23,56,12,37,28] #创建列表对象并赋给ls
print('ls中的最大元素值为:',max(ls)) #输出ls中最大元素的值
其中,ls是要获取最大元素值的列表。例如,对于下面的代码:
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
25
min(ls)
使用min方法可以获取一个列表中最小元素的值,min方法的语法格式如下:
ls中的最小元素值为: 12
程序执行完毕后,将在屏幕上输出如下结果:
ls=[23,56,12,37,28] #创建列表对象并赋给ls
print('ls中的最小元素值为:',min(ls)) #输出ls中最小元素的值
其中,ls是要获取最小元素值的列表。例如,对于下面的代码:
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
26
ls.count(x)
使用列表中的count方法可以统计某个值在列表中出现的次数,count方法的语法格式如下:
ls中值为37的元素个数为: 2
ls中值为28的元素个数为: 1
ls中值为56的元素个数为: 0
程序执行完毕后,将在屏幕上输出如下结果:
ls=[23,37,12,37,28] #创建列表对象并赋给ls
print('ls中值为37的元素个数为:',ls.count(37))
print('ls中值为28的元素个数为:',ls.count(28))
print('ls中值为56的元素个数为:',ls.count(56))
其作用是统计值x在列表ls中出现的次数。例如,对于下面的代码:
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
27
len(ls)
使用len方法可以获取一个列表中包含的元素数量(即列表长度),len方法的语法格式如下:
ls的列表长度为: 5
程序执行完毕后,将在屏幕上输出如下结果:
ls=[23,56,12,37,28] #创建列表对象并赋给ls
print('ls的列表长度为:',len(ls)) #输出ls中元素的数量
其中,ls是要计算长度的列表。例如,对于下面的代码:
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
28
ls.sort(key=None, reverse=False)
使用列表中的sort方法可以对列表中的元素按照指定规则进行排序,sort方法的语法格式如下:
其中,ls是待排序的列表;key接收一个函数,通过该函数获取用于排序时比较大小的数据;reverse指定是将列表中的元素按升序(False,默认值)还是按降序(True)排列。
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
29
1 class Student: #定义学生类
2 def __init__(self,sno,name): #定义构造方法
3 self.sno=sno #将self对象的sno属性赋为形参sno的值
4 self.name=name #将self对象的name属性赋为形参name的值
5 def __str__(self): #定义内置方法__str__
6 return '学号:'+self.sno+',姓名:'+self.name
7 if __name__=='__main__':
8 ls1=[23,56,12,37,28] #创建列表对象并赋给变量ls1
9 ls1.sort() #将ls1中的元素按升序排序
10 print('ls1升序排序后的结果:',ls1)
11 ls1.sort(reverse=True) #将ls1中的元素按降序排序
12 print('ls1降序排序后的结果:',ls1)
13 ls2=[Student('1810101','李晓明'), Student('1810100','马红'), Student('1810102','张刚')] #创建包含3 个Student类对象的列表并赋给变量ls2
14 ls2.sort(key=lambda stu:stu.sno) #按学号升序排序
15 print('ls2按学号升序排序后的结果:')
16 for stu in ls2: #遍历ls2中的每名学生并输出
17 print(stu)
18 ls2.sort(key=lambda stu:stu.sno, reverse=True) #按学号降序排序
19 print('ls2按学号降序排序后的结果:')
20 for stu in ls2: #遍历ls2中的每名学生并输出
21 print(stu)
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
30
ls1升序排序后的结果: [12, 23, 28, 37, 56]
ls1降序排序后的结果: [56, 37, 28, 23, 12]
ls2按学号升序排序后的结果:
学号:1810100,姓名:马红
学号:1810101,姓名:李晓明
学号:1810102,姓名:张刚
ls2按学号降序排序后的结果:
学号:1810102,姓名:张刚
学号:1810101,姓名:李晓明
学号:1810100,姓名:马红
程序执行完毕后,将在屏幕上输出如下结果:
列表List
示例02
代码缩进 4个空格
正文缩进1.27厘米
31
元组Tuple
PART 03
32
元组Tuple
【任务描述】
了解元组的常用操作
【关键步骤】
了解元组的常用操作
示例03
代码缩进 4个空格
正文缩进1.27厘米
33
t1=(1,'one','一') #创建元组对象并将其赋给变量t1,其包含3个元素
t2=() #创建元组对象并将其赋给变量t2,其不包含任何元素、因此是一个空元组
print('t1的值为:',t1)
print('t2的值为:',t2)
元组就是用一对小括号括起来的多个元素的有序集合,各元素之间用逗号分隔。不包含任何元素的是一个空元组。
t1的值为: (1, 'one', '一')
t2的值为: ()
程序执行完毕后,将在屏幕上输出如下结果:
元组Tuple
示例03
代码缩进 4个空格
正文缩进1.27厘米
34
t=tuple([1,'one','一']) #使用tuple方法根据列表创建元组对象,并赋给t变量
print('t的值为:',t)
print('t的第一个元素和最后一个元素的值分别为:',t[0],t[-1])
print('t的前两个元素的值为:',t[0:-1])
除使用一对小括号创建列表对象的这种方式外,还可以利用Python的内置方法tuple根据一个列表创建一个元组对象。
t的值为: (1, 'one', '一')
t的第一个元素和最后一个元素的值分别为: 1 一
t的前两个元素的值为: (1, 'one')
程序执行完毕后,将在屏幕上输出如下结果:
元组Tuple
示例03
代码缩进 4个空格
正文缩进1.27厘米
35
t1=(15) #不加逗号,则t1是一个整型变量
t2=(15,) #加逗号,则t2是一个元组
print('t1的类型为:',type(t1))
print('t2的类型为:',type(t2))
如果创建的元组中只包含单个元素,则需要在这唯一的一个元素后面添加逗号,
t1的类型为: <class 'int'>
t2的类型为: <class 'tuple'>
程序执行完毕后,将在屏幕上输出如下结果:
元组Tuple
示例03
代码缩进 4个空格
正文缩进1.27厘米
36
t1=(1,2,3) #创建元组对象并赋给变量t1
t2=('Python','C++') #创建元组对象并赋给变量t2
t3=t1+t2 #通过拼接运算“+”将t1和t2连接生成一个新的列表对象并赋给t3
print('t1和t2的值分别为:',t1,t2)
print('t3的值为:',t3)
虽然元组中的元素值不允许修改,但通过拼接运算可以两个元组连接、生成一个新元组。
t1和t2的值分别为: (1, 2, 3) ('Python', 'C++')
t3的值为: (1, 2, 3, 'Python', 'C++')
程序执行完毕后,将在屏幕上输出如下结果:
元组Tuple
示例03
代码缩进 4个空格
正文缩进1.27厘米
37
max(t)
使用max方法可以获取一个元组中最大元素的值,max方法的语法格式如下:
t中的最大元素值为: 56
程序执行完毕后,将在屏幕上输出如下结果:
t=(23,56,12,37,28) #创建元组对象并赋给t
print('t中的最大元素值为:',max(t)) #输出t中最大元素的值
其中,t是要获取最大元素值的元组。例如,对于下面的代码:
元组Tuple
示例03
代码缩进 4个空格
正文缩进1.27厘米
38
min(t)
使用min方法可以获取一个元组中最小元素的值,min方法的语法格式如下:
t中的最小元素值为: 12
程序执行完毕后,将在屏幕上输出如下结果:
t=(23,56,12,37,28) #创建元组对象并赋给t
print(‘t中的最小元素值为:’,min(t)) #输出t中最小元素的值
其中,t是要获取最小元素值的元组。例如,对于下面的代码:
元组Tuple
示例03
代码缩进 4个空格
正文缩进1.27厘米
39
元组中的元素值不允许修改,因此,元组不支持sort等需要修改元素值的方法。
元组Tuple
示例03
代码缩进 4个空格
正文缩进1.27厘米
40
集合Set
PART 04
41
Python中的集合(set)由若干无序的元素组成,每个元素都是唯一的(即集合中不能包含重复值的元素)且必须是可哈希类型的数据。
可以使用一对大括号{}或set函数创建集合,如果要创建空集合则只能使用set函数。
创建集合
42
集合Set
【任务描述】
了解集合及其特性
了解集合常用操作
【关键步骤】
了解集合及其特性
了解集合常用操作
示例01
代码缩进 4个空格
正文缩进1.27厘米
43
s=set([23,37,12,37,28]) #创建集合对象并赋给s
print('s的值为:',s) #输出s
集合中不能包含有重复值的元素。如果创建集合或向集合中插入元素时,指定的元素具有重复值,则集合会自动过滤掉重复值的元素、使得每种取值的元素只保留一个。
s的值为: {28, 12, 37, 23}
程序执行完毕后,将在屏幕上输出如下结果:
集合Set
示例01
代码缩进 4个空格
正文缩进1.27厘米
44
s.add(x)
集合中提供了两种插入元素的方法,分别是add和update。add方法的语法格式为:
s.update(x)
其作用是把x作为一个新的元素插入到集合s中,其中x必须是一个可哈希对象。
update方法的语法格式为:
其作用是把x拆分成多个元素后再将这多个元素插入到集合中,其中x必须是一个可迭代对象。
集合Set
示例01
代码缩进 4个空格
正文缩进1.27厘米
45
1 s1=set([1,2]) #创建集合对象并赋给变量s1
2 s2=set([1,2]) #创建集合对象并赋给变量s2
3 s1.add('Python') #使用add方法向s1中插入元素'Python'
4 s2.update('Python') #使用update方法将'Python'拆分成多个元素再插入到s2中
5 print('s1的值为:',s1)
6 print('s2的值为:',s2)
7 #s1.add([4,5]) #取消前面的注释则会报错
8 s2.update([4,5]) #使用update方法将[4,5]拆分成多个元素再插入到s2中
9 print('s1的值为:',s1)
10 print('s2的值为:',s2)
11 s1.add(3) #使用add方法向s1中插入元素3
12 #s2.update(3) #取消前面的注释则会报错
add方法和update方法使用示例
集合Set
示例01
代码缩进 4个空格
正文缩进1.27厘米
46
s1的值为: {1, 2, 'Python'}
s2的值为: {'y', 1, 2, 't', 'n', 'h', 'P', 'o'}
s1的值为: {1, 2, 'Python'}
s2的值为: {'y', 1, 2, 't', 4, 'n', 5, 'h', 'P', 'o'}
示例01
程序执行完毕后,将在屏幕上输出如下结果:
s1.intersection(s2)
集合中的intersection方法可以用于计算一个集合与另一个集合的交集。
其作用是计算s1和s2的交集并返回。intersection方法不会修改s1和s2本身的值。
集合Set
示例01
代码缩进 4个空格
正文缩进1.27厘米
48
s1.union(s2)
集合中的union方法可以用于计算一个集合与另一个集合的并集。
其作用是计算s1和s2的并集并返回。union方法不会修改s1和s2本身的值。
集合Set
示例01
代码缩进 4个空格
正文缩进1.27厘米
49
s1.difference(s2)
集合中的difference方法可以用于计算一个集合与另一个集合的差集。
其作用是计算s1和s2的差集并返回,差集是指由包含在s1中但不包含在s2中的元素组成的集合。difference方法不会修改s1和s2本身的值。
集合Set
示例01
代码缩进 4个空格
正文缩进1.27厘米
50
s1.symmetric_difference(s2)
集合中的symmetric_difference方法可以用于计算一个集合与另一个集合的对称差集。
其作用是计算s1和s2的对称差集并返回,对称差集是指由只包含在s1中或只包含在s2中的元素组成的集合。symmetric_difference方法不会修改s1和s2本身的值。
集合Set
示例01
代码缩进 4个空格
正文缩进1.27厘米
51
s1=set([1,2,3]) #创建集合对象并赋给变量s1
s2=set([2,3,4]) #创建集合对象并赋给变量s2
s3=s1.intersection(s2) #计算s1和s2的交集,并将返回集合赋给s3
s4=s1.union(s2) #计算s1和s2的并集,并将返回集合赋给s4
s5=s1.difference(s2) #计算s1和s2的差集,并将返回集合赋给s5
s6=s1.symmetric_difference(s2) #计算s1和s2的对称差集,并将返回集合赋给s6
print('s1和s2的值分别为:',s1,s2)
print('s1和s2的交集为:',s3)
print('s1和s2的并集为:',s4)
print('s1和s2的差集为:',s5)
print('s1和s2的对称差集为:',s6)
交集、并集、差集、对称差集示例
集合Set
示例01
代码缩进 4个空格
正文缩进1.27厘米
52
s1和s2的值分别为: {1, 2, 3} {2, 3, 4}
s1和s2的交集为: {2, 3}
s1和s2的并集为: {1, 2, 3, 4}
s1和s2的差集为: {1}
s1和s2的对称差集为: {1, 4}
程序执行完毕后,将在屏幕上输出如下结果:
示例01
s1.issubset(s2)
集合中的issubset方法可以用于判断一个集合是否是另一个集合的子集。
其作用是判断s1是否是s2的子集。如果s1是s2的子集,则返回True;否则,返回False。
集合Set
示例01
代码缩进 4个空格
正文缩进1.27厘米
54
s1.issuperset(s2)
集合中的issuperset方法可以用于判断一个集合是否是另一个集合的父集。
其作用是判断s1是否是s2的父集(即判断s2是否是s1的子集)。如果s1是s2的父集,则返回True;否则,返回False。
集合Set
示例01
代码缩进 4个空格
正文缩进1.27厘米
55
s1=set([1,2,3,4]) #创建集合对象并赋给变量s1
s2=set([2,3,4,5]) #创建集合对象并赋给变量s2
s3=set([1,3]) #创建集合对象并赋给变量s3
print('s3是s1的子集:',s3.issubset(s1))
print('s1是s3的父集:',s1.issuperset(s3))
print('s3是s2的子集:',s3.issubset(s2))
print('s2是s3的父集:',s3.issuperset(s2))
子集、父集示例
s3是s1的子集: True
s1是s3的父集: True
s3是s2的子集: False
s2是s3的父集: False
程序执行完毕后,将在屏幕上输出如下结果:
集合Set
示例01
代码缩进 4个空格
正文缩进1.27厘米
56
字典Dictionary
PART 02
57
与集合类似,字典(dictionary)也是由若干无序的元素组成。
但与集合不同的是,字典是一种映射类型,字典中的每个元素都是键(key):值(value)的形式。
字典中每个元素键的取值必须唯一(即集合中不能包含键值的元素)且必须是可哈希类型的数据,但对于每个元素值的取值则没有任何限制。
字典的主要应用是做数据的快速检索。
实际使用字典时,将要查询的数据作为键,将其他数据作为值。
例如,在进行学生信息管理时,经常要根据学号进行学生信息的查询,此时就可以将学号作为键、而将其他信息作为值。
可以使用一对大括号{}或dict函数创建字典,如果要创建空字典可以使用{}或dict()。
创建字典
代码缩进 4个空格
正文缩进1.27厘米
58
字典Dictionary
【任务描述】
了解字典及其特性
了解字典常用操作
【关键步骤】
了解字典及其特性
了解字典常用操作
示例02
代码缩进 4个空格
正文缩进1.27厘米
59
d.fromkeys(seq[, value])
使用fromkeys方法进行字典初始化的方法。a
其中,d是一个已创建的字典对象;seq是一个包含了字典所有键名的序列;value是一个可选参数,其指定了各元素的初始值,默认情况下所有元素的值都被赋为None。
字典Dictionarya
示例02
代码缩进 4个空格
正文缩进1.27厘米
60
d1={}.fromkeys(['sno','name','major'])
d2=dict().fromkeys(['sno','name','major'], 'Unknown')
print('d1的值为:', d1)
print('d2的值为:', d2)
示例:
d1的值为: {'sno': None, 'name': None, 'major': None}
d2的值为: {'sno': 'Unknown', 'name': 'Unknown', 'major': 'Unknown'}
程序执行完毕后,将在屏幕上输出如下结果:
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
61
d.update(d2) #用另一个字典对象d2的元素修改或插入字典对象d的元素
或d.update(键1=值1, 键2=值2, …, 键N=值N) #用键值列表修改或插入字典对象d的元素
给指定键的元素赋值时,如果该键在字典中已存在,则会将该键对应的元素值做修改;如果该键在字典中不存在,则会在字典中插入一个新元素。
另外,也可以使用字典中的update方法一次修改或插入多个元素,update方法的语法格式为:
字典Dictionary
示例01
代码缩进 4个空格
正文缩进1.27厘米
62
1 stu=dict(sno='1810101') #创建字典对象并赋给变量stu
2 print(stu) #输出stu的值
3 stu['sno']='1810100' #将键为'sno'的元素的值修改为'1810100'
4 print(stu) #输出stu的值
5 stu['name']='李晓明' #插入一个键为'name'的元素,其值为'李晓明'
6 print(stu) #输出stu的值
7 stu.update({'name':'马红','age':19})
8 print(stu) #输出stu的值
9 stu.update(name='张刚',major='计算机')
10 print(stu) #输出stu的值
示例:
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
63
{'sno': '1810101'}
{'sno': '1810100'}
{'sno': '1810100', 'name': '李晓明'}
{'sno': '1810100', 'name': '马红', 'age': 19}
{'sno': '1810100', 'name': '张刚', 'age': 19, 'major': '计算机'}
程序执行完毕后,将在屏幕上输出如下结果:
示例02
d.pop(key[, default])
使用del可以删除某个元素,也可以使用字典中的pop方法删除指定键的元素。
其作用是从字典d中删除键为key的元素并返回该元素的值;如果d中不存在键为key的元素,则返回default参数的值。
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
65
1 d=dict(sno='1810100', name='李晓明', age=19) #创建字典对象并赋给变量d
2 print('第2行输出的字典d:', d) #输出d的值
3 del d['age'] #使用del删除d中键为'age'的元素
4 name=d.pop('name') #使用pop删除d中键为'name'的元素,并将返回的元素值赋给name
5 print('name的值为:', name)
6 print('第6行输出的字典d:', d)
7 major=d.pop('major', 'Not found') #使用pop删除d中键为'major'的元素,并将返回的元素值赋给major
8 print('major的值为:', major)
示例:
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
66
第2行输出的字典d: {'sno': '1810100', 'name': '李晓明', 'age': 19}
name的值为: 李晓明
第6行输出的字典d: {'sno': '1810100'}
major的值为: Not found
程序执行完毕后,将在屏幕上输出如下结果:
示例02
67
len(d)
使用Python提供的len方法可以计算字典中的元素个数,len方法的语法格式为:
字典d中的元素个数为: 3
程序执行完毕后,将在屏幕上输出如下结果:
其中,d为要计算元素个数的字典。例如,对于下面的代码:
d=dict(sno='1810100', name='李晓明', age=19) #创建字典对象并赋给变量d
print('字典d中的元素个数为:', len(d))
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
68
d.clear()
使用字典中的clear方法可以一次将一个字典中的所有元素都清除,clear方法的语法格式为:
字典d中的元素个数为: 3
字典d中的元素个数为: 0
程序执行完毕后,将在屏幕上输出如下结果:
其中,d为要清除元素的字典。例如,对于下面的代码:
d=dict(sno='1810100', name='李晓明', age=19) #创建字典对象并赋给变量d
print('字典d中的元素个数为:', len(d))
d.clear() #调用clear方法清除d中的所有元素
print('字典d中的元素个数为:', len(d))
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
69
d.get(key, default=None)
我们可以使用两种方法判断字段中是否存在某个键。一种方法是使用字典中的get方法,其语法格式为:
其作用是从字典d中获取键为key的元素的值并返回。如果在字典d中不存在键为key的元素,则返回default参数的值(默认为None)。
另一种方法是使用成员运算符in。
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
70
d=dict(sno='1810100', name='李晓明') #创建字典对象并赋给变量d
if d.get('sno')!=None: #如果get方法返回的不是None
print('字典d中存在键为sno的元素')
else: #否则
print('字典d中不存在键为sno的元素')
if 'name' in d: #如果字典d中有键为'name'的元素
print('字典d中存在键为name的元素')
else:
print('字典d中不存在键为name的元素')
if d.get('age')!=None: #如果get方法返回的不是None
print('字典d中存在键为age的元素')
else: #否则
print('字典d中不存在键为age的元素')
示例:
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
71
字典d中存在键为sno的元素
字典d中存在键为name的元素
字典d中不存在键为age的元素
程序执行完毕后,将在屏幕上输出如下结果:
示例02
第一种:
dMerge=dict(d1,**d2)
第二种:
dMerge=d1.copy()
dMerge.update(d2)
这里介绍2种不同的字典拼接方法:
其中,d1和d2是待拼接的两个字典,dMerge用于保存拼接后的字典。
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
73
d1=dict(sno='1810100', name='李晓明') #创建字典对象并赋给变量d1
d2=dict(age=19) #创建字典对象并赋给变量d2
dMerge1=dict(d1,**d2)
print('dMerge1的值为:', dMerge1)
dMerge2=d1.copy() #使用copy方法复制d1生成新的字典对象并赋给dMerge2
dMerge2.update(d2) #根据d2中的元素对dMerge2进行修改/插入操作
print('dMerge2的值为:', dMerge2)
示例:
dMerge1的值为: {'sno': '1810100', 'name': '李晓明', 'age': 19}
dMerge2的值为: {'sno': '1810100', 'name': '李晓明', 'age': 19}
程序执行完毕后,将在屏幕上输出如下结果:
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
74
d.keys()
使用字典中的keys方法可以获取一个字典所有的键,keys方法的语法格式为:
d中的键为: dict_keys(['sno', 'name'])
程序执行完毕后,将在屏幕上输出如下结果:
d=dict(sno='1810100', name='李晓明') #创建字典对象并赋给变量d
print('d中的键为:', d.keys())
其作用是返回一个包含d中所有键的对象。例如,对于下面的代码:
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
75
d.values()
使用字典中的values方法可以获取一个字典所有的值, values方法的语法格式为:
d中的值为: dict_values(['1810100', '李晓明'])
程序执行完毕后,将在屏幕上输出如下结果:
d=dict(sno='1810100', name='李晓明') #创建字典对象并赋给变量d
print('d中的键为:', d.values())
其作用是返回一个包含d中所有值的对象。例如,对于下面的代码:
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
76
d.items()
使用字典中的items方法可以返回一个可按(键, 值)方式遍历的对象,items语法格式为:
sno 1810100
name 李晓明
程序执行完毕后,将在屏幕上输出如下结果:
d=dict(sno='1810100', name='李晓明') #创建字典对象并赋给变量d
for key,value in d.items():
print(key,value)
其中,d是一个字典。例如,对于下面的代码:
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
77
d.copy()
使用字典中的copy方法可以实现一个字典的浅拷贝。copy方法的语法格式为:
其作用是返回一个对字典d进行浅拷贝而得到的新字典。
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
78
1 stu1={'name':'李晓明', 'age':19, 'score':{'python':95,'math':92}}
2 stu2=stu1 #直接赋值,此时stu2和stu2指向同一个字典对象
3 stu3=stu1.copy() #使用copy方法进行浅拷贝
4 print('stu1、stu2和stu3的内存地址分别为:',id(stu1),id(stu2),id(stu3))
5 stu1['name']='马红' #将stu1中键为name的元素的值修改为'马红'
6 print('stu1的值为:',stu1)
7 print('stu2的值为:',stu2)
8 print('stu3的值为:',stu3)
9 print("stu1['score']和stu3['score']的内存地址分别为:", id(stu1['score']), id(stu3['score']))
10 stu1['score']['python']=100
11 print('stu1的值为:',stu1)
12 print('stu3的值为:',stu3)
示例:
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
79
stu1、stu2和stu3的内存地址分别为: 2418482829568 2418482829568 2418482829928
stu1的值为: {'name': '马红', 'age': 19, 'score': {'python': 95, 'math': 92}}
stu2的值为: {'name': '马红', 'age': 19, 'score': {'python': 95, 'math': 92}}
stu3的值为: {'name': '李晓明', 'age': 19, 'score': {'python': 95, 'math': 92}}
stu1['score']和stu3['score']的内存地址分别为: 2418482829496 2418482829496
stu1的值为: {'name': '马红', 'age': 19, 'score': {'python': 100, 'math': 92}}
stu3的值为: {'name': '李晓明', 'age': 19, 'score': {'python': 100, 'math': 92}}
程序执行完毕后,将在屏幕上输出如下结果:
浅拷贝使得原有字典对象和生成的字典对象具有一定独立性,但并不完全独立;
当对字典可变类型元素中的元素做修改时,则会产生问题。
为了解决这个问题,对于含有可变类型元素的字典对象,我们应该使用深拷贝方法。
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
80
copy.deepcopy(d)
使用copy模块的deepcopy方法可以实现深拷贝,deepcopy方法的语法格式为:
其作用是根据字典d进行深拷贝创建一个新的字典对象并返回。
深拷贝不仅使得原有字典对象和生成的字典对象对应不同的内存空间,而且使得两个字典对象中的可变类型元素对应不同的内存空间,从而使得两个字典对象完全独立。
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
81
1 import copy #导入copy模块
2 stu1={'name':'李晓明', 'age':19, 'score':{'python':95,'math':92}}
3 stu2=copy.deepcopy(stu1) #使用deepcopy方法进行深拷贝
4 print("stu1和stu2的内存地址分别为:", id(stu1), id(stu2))
5 print("stu1['score']和stu2['score']的内存地址分别为:", id(stu1['score']), id(stu2['score']))
6 stu1['score']['python']=100
7 print('stu1的值为:',stu1)
8 print('stu2的值为:',stu2)
示例:
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
82
stu1和stu2的内存地址分别为: 2615634123008 2613491686568
stu1['score']和stu2['score']的内存地址分别为: 2615634122936 2613491862984
stu1的值为: {'name': '李晓明', 'age': 19, 'score': {'python': 100, 'math': 92}}
stu2的值为: {'name': '李晓明', 'age': 19, 'score': {'python': 95, 'math': 92}}
程序执行完毕后,将在屏幕上输出如下结果:
字典Dictionary
示例02
代码缩进 4个空格
正文缩进1.27厘米
83
谢谢观看
$$