【文档说明】Python实用案例教程-第4章-列元字集课件.pptx，共(87)页，1.644 MB，由小橙橙上传

转载请保留链接：https://www.ichengzhen.cn/view-2422.html

以下为本文档部分文字说明：

——列表：list第4章序列是什么：列元字集列表、元组、字典和集合是Python中常用的序列类型，很多复杂的业务逻辑最终还是由这些基本数据类型来实现。表4.1比较了这几种结构的区别。比较项列表元组字典集合类型名称

listtupledictset定界符方括号[]圆括号()大括号{}大括号{}是否可变是否是是是否有序是是否否是否支持下标是（使用序号作为下标）是（使用序号作为下标）是（使用“键”作为下标）否元素分隔符逗号逗号逗号逗号对元素形式的

要求无无键：值必须可哈希对元素值的要求无无“键”必须可哈希必须可哈希元素是否可重复是是“键”不允许重复，“值”可以重复否元素查找速度非常慢很慢非常快非常快新增和删除元素速度尾部操作快，其他不允许快快01创建列表目录

创建列表列表可以通过多种方式创建。例如：>>>list1=[-23,5.0,'python',12.8e+6]#列表包含不同类型数据>>>list2=[list1,1,2,3,4,5]#列表中包含列表>>>print(list2)#[[-23,5.0,'pytho

n',12800000.0],1,2,3,4,5]>>>list2=[1]*6#产生6个全为1的数组02索引和切片1.索引和切片2.运算符目录3.内置函数1.索引和切片序列中所有的元素都是有编号的，从0开始递增

。可以通过编号分别对序列的元素进行访问。Python的序列也可以从右边开始索引，最右边的一个元素的索引为-1，向左开始递减。例如：>>>lst=['A','B','C','D','E','F','G','H']前面序号索引号为0，1，2，3，4，5，6，7。后面

序号索引号为-8，-7，-6，-5，-4，-3，-2，-1。列表中值的切片可以用“列表变量[头下标:尾下标:步长]”来截取相应的列表，列表被分片后返回一个包含所含元素的新列表。例如：2.运算符（1）加(+)是列表连接运算符。例如：>>>lst+[1,2,3]#[‘A’,‘B’,‘

C’,‘D’,‘E’,‘F’,‘G’,‘H’,1,2,3]（2）乘（∗）是重复操作。例如：>>>lst*2#[‘A’,‘B’,‘C’,‘D’,‘E’,‘F’,‘G’,‘H’,‘A’,‘B’,‘C’,‘D’,‘E’,‘F’,‘G’,‘H’]（3）成员资格：[

not]in可以使用in运算符来检查一个值是否在序列中，如果在其中，则返回True；如果不在，则返回False。notin与in功能相反。例如：>>>'E'inlst#True>>>'X'notinlst#True2.运算符（4）存储单元是否相同：is[not]用来测试两个对象是否同

一个，如果是则返回True，否则返回False。如果两个对象是同一个，两者具有相同的内存地址。例如：>>>x=[1,2,3]>>>x[0]isx[1]#Flase>>>c=x>>>xisc#True>>>y=[1,

2,3]>>>xisy#False>>>x[0]isy[0]#True3.内置函数除了列表对象自身方法之外，很多Python内置函数也可以对列表进行操作。例如：>>>list3=[1,2,3,4,5,6,7,8,9,10]>>>len(list3)#

10>>>min(list3)#1最小值>>>max(list3)#10最大值03列表的基本操作1.更新列表：元素赋值目录2.删除元素：使用del语句1.更新列表：元素赋值例如：>>>list3=[1,2,3,4,5,6,7

,8,9,10]>>>list3[0]='one'#元素赋值改变>>>list3[1:4]=['two','three','four']#[1:3]区段赋值改变>>>list3['one','two',

'three','four',5,6,7,8,9,10]>>>str=list('python')>>>str#['p','y','t','h',’o’,’n’]>>>str[2:]=list('THON')#对2的元

素和以后的元素进行赋值>>>str#['p','y','T,H',’O’,’N’]>>>list1=[1,2,3,4,5,6]>>>list1a=list1#直接赋值，list1和list1a引用同一个

列表>>>list1b=list1[:]#整个列表切片后再赋值得到一个列表的副本>>>list1[2]='C'#修改第3个元素>>>list1#[1,2,'C',4,5,6]>>>list1a#[1,

2,'C',4,5,6]>>>list1b#[1,2,3,4,5,6]2.删除元素：使用del语句>>>list4=[1,2,3,4,5,6,7,8,9,10]>>>dellist4[1]#删除列表第1个元素2>

>>list4[0:5]=[]#[0:4]]区段删除>>>list4#[7,8,9,10]>>>dellist4[:]#清空列表,list4列表变量还在>>>list4#[]>>>dellist4#删除实体变量list404列表方法1.常用方法

目录3.遍历列表元素2.排序1.常用方法列表.append(元素)，用于在列表末尾追加新的元素。列表.extend(序列)，可以在列表的末尾一次性追加另一个序列中的多个值。列表.count(元素)，统计某个元素在列表中出现的次数。

列表.index(元素)，从列表中找出某个值第一个匹配项的索引位置。列表.insert(索引,元素)：将对象插入到指定序号的列表中。列表.pop([索引])：移除列表中的一个元素（默认是最后一个），并且

返回该元素的值。列表.remove(元素)：移除列表中某个值的第一个匹配项。列表.reverse()：将列表中元素顺序全部反向。1.常用方法例如：>>>a=[1,2,1,2,3,4,2,5]>>>a.append(6)#直接追加新的列表元素>>>a#[1,2,1,2,3,4,2,5,6]>>>a.

count(2)#元素“2”出现3次>>>b=[7,8]>>>a.extend(b)>>>a#[1,2,1,2,3,4,2,5,6,7,8]>>>a.index(2#1>>>a.insert(0,'begin')#在0位置的地方插入'begin'>>>a#[

'begin',1,2,1,2,3,4,2,5,6,7,8]>>>x=a.pop())#移除最后一个元素，并返回该元素的值>>>x#8>>>a#['begin',1,2,1,2,3,4,2,5,6,7]>>>a.remov

e(2)#移除第一个匹配到“2”的元素>>>a['begin',1,1,2,3,4,2,5,6,7]>>>a.reverse()#反向排列>>>a#[7,6,5,2,4,3,2,1,1,'begin']1.常用方法比较列表的大小：>>>[1,2,3]<[1,2,4]#True【例4.1】

输出列表中的所有非空元素。代码如下（ch4,enum.py）：List1=['one','two','','four','five']fori,vinenumerate(List1):#enumerate枚举列表所有元素ifv!='':print('List('

,i,')=',v)运行结果：1.常用方法【例4.2】列表前移n位。方法一代码（ch4,leftMove1.py）：lst=[1,2,3,4,5,6,7,8,9,10]n=3foriinrange(n):lst.append(lst.pop(0))print

(lst)运行结果：方法二代码（ch4,leftMove2.py）：lst=[1,2,3,4,5,6,7,8,9,10]n=3a=lst[:n]b=lst[n:]lst=b+aprint(lst)1.常用

方法【例4.3】将第1个和第2个列表中的数据所有组合成一个新的列表。代码如下（ch4,lstComb.py）：List1=['A','B','C','D'];List2=[1,2];List3=[]foriinList1:forjinList2:List3.append

([i,j])print(List3)运行结果：1.常用方法【例4.4】判断今天是今年的第几天。代码如下（ch4,todayn.py）：importtimecurdate=time.localtime()#获取

当前日期时间year,month,day=curdate[:3]day30=[31,28,31,30,31,30,31,31,30,31,30,31]ifyear%400==0or(year%4==0andyear%100!=0):#判断是否为闰年day30[1]=29ifmonth==1:

print(day)else:print(year,'年',month,'月',day,'日是今年',sum(day30[:month-1])+day,'天')运行结果：2.排序排序方法：列表.sort([参数])，对原列表进行

排序，并返回空值。指定的参数对列表进行排序方式进行控制。（1）默认排序例如：>>>a=[7,0,6,4,2,5,1,9]>>>x=a.sort()#对列表a(从小到大)排序，返回值(空值)赋给x>>>a#[0,1,2,4,5,6,7,

9]（2）控制排序如果不想按照sort方法默认的方式进行排序，可以指定参数：cmp、key、reverse。例如：>>>a=[7,0,6,4,2,5,1,9]>>>b=['student','is','the','most']

>>>b.sort(key=len)>>>b#['is','the','most','student']>>>a.sort(reverse=True)#对列表a从大到小排序>>>a#[9,7,6,5,4,2,1,0

]2.排序（3）多维列表多维列表就是列表的数据元素本身也是列表。为了引用二维列表中的一个数据值，需要两个索引号，一个是外层列表的，另外一个是元素列表的。例如：>>>list2=[[1,2,3],[4,5

,6],[7,8,9]]>>>list2[0][1]#2>>>list2[2][1]#8例如：>>>list3=[[['000','001','002'],['010','011','012']],[['100','101','102'],['110','111','112'

]],[['200','201','202'],['210','211','212']]]>>>list3[2][1][0]#’210’例如：>>>List4=[[i*jforiinrange(1,10)]forjinrange(1,10)]>>>List4[[1,2,3,4,5,6,7,8

,9],[2,4,6,8,10,12,14,16,18],[3,6,9,12,15,18,21,24,27],[4,8,12,16,20,24,28,32,36],[5,10,15,20,25,30,35,40,45

],[6,12,18,24,30,36,42,48,54],[7,14,21,28,35,42,49,56,63],[8,16,24,32,40,48,56,64,72],[9,18,27,36,45,54,63,72,81]

]2.排序【例4.5】输入20成绩，找出其中的最高分数、平均分数、并且对成绩从大到小排序。代码如下（ch4,lstMAS.py）sum=0list1=[]foriinrange(0,6):n=int(input("n="))sum=sum+nlist1.append(n)

print("最高分数为:",max(list1))print("平均分数为:%6.2f"%(sum/len(list1)))list1.sort(reverse=True)print(list1)运行结果：3.遍历列表元素fork,vinenume

rate(列表):print(k,v)例如：>>>list1=[-23,5.0,'python',12.8e+6]#列表包含不同类型数据>>>list2=[list1,1,2,3,4,5,[61,62],7,8]#列表中包含列表>>>fork,vinenumerate(list2)

:print(k,v)0[-23,5.0,'python',12800000.0]11223344556[61,62]778805列表推导式1．嵌套列表平铺目录3．同时遍历多个列表或可迭代对象2．元素条件过滤4．复杂的条件筛选列表推

导式由于Python的内部对列表推导式做了大量优化，所以运行速度快，是推荐使用的一种技术。列表推导式的语法：[<表达式>for<表达式1>in<序列1>if<条件1>for<表达式2>in<序列2>if<条件2>⋮列表推导式在逻辑上等价于一个

循环语句，只是形式上更加简洁。例如：lst=[x∗xforxinrange(n)]等价于:lst=[]forxinrange(n):lst.append(x∗x)1．嵌套列表平铺例如：>>>lst=[[1,2,3],[4,5,6],[7,8,9]]>>>[

expforeleminlstforexpinelem][1,2,3,4,5,6,7,8,9]等价于下面的代码：>>>list1=[[1,2,3],[4,5,6],[7,8,9]]>>>list2=[]>>>foreleminl

ist1:fornuminelem:list2.append(num)>>>list2[1,2,3,4,5,6,7,8,9]2．元素条件过滤使用if子句可以对列表中的元素进行筛选，保留符合条件的元素。例如：>>>lst=[1,-2,3,-4,5,-6,7,-8,

9,-10]>>>[iforiinlstifi+2>=0]#筛选条件：元素+2>=0[1,-2,3,5,7,9]>>>m=max(lst)>>>m9>>>[indexforindex,valueinen

umerate(lst)ifvalue==m]#找最大元素所有位置[8]2．元素条件过滤【例4.6】接收一个所有元素值都不相等的整数列表x和一个整数n，要求将值为n的元素作为支点，将列表中所有值小于n的元素全部放到n的前面，所有值大于n的元素放到n的后面。代码如下（ch4,lstIn

fer.py）：lst=[0,1,-2,3,-4,5,-6,7,-8,9,-10]n=0lst1=[iforiinlstifi<n]lst2=[iforiinlstifi>n]lst=lst1+[n]+lst2p

rint(lst)运行结果：3．同时遍历多个列表或可迭代对象例如：>>>list1=[1,2,3]>>>list2=[1,3,4,5]>>>[(x,y)forxinlist1foryinlist2ifx==y]#（1）[(1,1),(3,3)]>>>[(x,y)forxinlist1i

fx==1foryinlist2ify!=x]#（2）[(1,3),(1,4),(1,5)]其中：（1）两个列表元素同时遍历时根据元素条件筛选。（2）两个列表元素同时遍历时用两个元素条件筛选。4．复杂的条件筛选当然，列

表推导式中使用函数或复杂表达式。（1）推导式为复杂表达式。例如：lst=[1,-2,3,-4]print([val+2ifval%2==0elseval+1forvalinlstifval>0])[2,4]其中，列表推导式为“val+2ifval%2==0elseval+1”。（2）i

f判断条件为复杂条件表达式下列语句能够生成2`20之间的素数。例如：>>>importmath>>>[numfornuminrange(2,20)if0notin[num%gforginrange(2,int(math.sqrt(

num))+1)]][2,3,5,7,11,13,17,19]——元组：tuple第4章序列是什么：列元字集01元组的基本操作1.元组的基本介绍目录3.枚举2.元组的操作注意4.使用tuple的好处1.元组的基本介绍说明：（1）不包含任何元素，创建空元组，例如：tl=()。（2）元

组中只包含一个元素时，创建时需要在元素后面添加逗号，例如：t2=(6,)；（3）元组下标索引从0开始，可以进行截取、组合等操作。（4）无关闭分隔符的对象，以逗号隔开，默认为元组。例如：>>>t1=1,2,3,'four',5.0,3+4.2j,-1.2e+26#创建元组>>>t1(1,2,3,'

four',5.0,(3+4.2j),-1.2e+26)>>>tup1=('python',3.7,True)>>>x,y,z=tup1#同时给多个变量赋值>>>x'python'>>>tup1[1]#得到第1个元素3.71.元组的基本介绍（5）元组运算符（+，*）函数和与列表函数基本上是一样

的。例如：>>>t1=1,2,3,'four',5.0,3+4.2j,-1.2e+26>>>t2=t1+(5,6)#元组连接>>>t2#(1,2,3,'four',5.0,(3+4.2j),-1.2e+26,5,6)>>>len(t2)#元素个数，结果：9

>>>4int2#元素4是否存在于元组中，结果：False>>>tuple([1,2,3])#参数是列表，转换为元组(1,2,3)>>>tuple('ABC')#参数是字符串，转换为元组('A','B','C')>>>tuple((1,

2,3))#参数为元组，转换为元组(1,2,3)（6）以一个序列作为参数并把它转换为元组，如果参数是元组，那么就会原样返回该元组。2.元组的操作注意（1）修改元组元组中的元素值是不允许修改的，但用户可以对元组进行连接组合。例如：>>>tup1,tup2=(1,2,3),('four','five

')#同时赋值>>>tup3=tup1+tup2#连接元组>>>tup3#(1,2,3,'four','five')>>>tup2[1]=’two’#错误（2）删除元组元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组。例如：>>>deltup23.枚举en

umerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。例如：>>>list(enumerate('python'))#[(0,'p'),

(1,'y'),(2,'t'),(3,'h'),(4,'o'),(5,'n')]>>>list(enumerate(['python','c语言']))#[(0,'python'),(1,'c语言')]例如：forindex,valueinenumerate(range(10,15)):print

((index,value),end='')运行结果：4.使用tuple的好处（1）tuple比list操作速度快。如果定义了一个值的常量集,并且唯一不断地遍历它,请使用tuple代替list。（2）如果对不需要修改的数据进行“写保护”,可以使代码更安全。（3）t

uples可以在字典中用做key,但是list不行。因为字典的key必须是不可变的。02生成器推导式目录生成器推导式当需要使用生成器对象的元素时，可以转化为列表或元组，或者使用生成器对象的__next__()方法或者Python内置函数next()进行遍历，或者直接使用for循环遍

历。注意，只能从前往后正向访问其中的元素，当然也不能使用下标访问其中的元素。不能访问已访问过的元素。如果需要重新访问，必须重新创建该生成器对象。例如：>>>gen=((j+1)*3forjinrange(6))#创建生成器对象

>>>gen<generatorobject<genexpr>at0x000001A8656EA570>>>>gen.__next__()#使用生成器对象的__next__()方法获取元素3>>>gen.__next__()#获取下一个元素6>>>tuple(gen)#将生成器对象转换为元

组(9,12,15,18)>>>tuple(gen)#生成器对象已遍历结束,没有元素了()>>>gen=((j+1)*3forjinrange(6))>>>list(gen)#将生成器对象转换为列表[3,6,9,

12,15,18]>>>foritemingen:#使用循环直接遍历生成器对象中的元素print(item,end='')369121518生成器推导式【例4.7】将指定元组中元素大于平均值的数成新元组。代码如下（ch4,tupInfer.py）：tu

p1=(1,2,3,-4,5,-6,7,8,-9,10)avg=sum(tup1)/len(tup1)#平均值lst=[xforxintup1ifx>avg]#列表推导式tup2=tuple(lst)prin

t(tup2)运行结果：——集合：set第4章序列是什么：列元字集01集合的创建与访问目录集合的创建与访问非空集合可以把逗号分隔的元素放在一对大括号中来创建，如：{'jack','sjoerd'}。集合元素必须是可哈希的、不可改变的，如str、tup

le、frozenset、数字等。set()得到一个空的集合。例如：>>>set1=set()>>>set2={1,2,3}#{1,2,3}>>>set3=set([1,2,3])#{1,2,3}>>>set

4=set('abc')#'b','a','c'}集合是无序的不重复的，例如：>>>list1=[1,2,1,3]>>>set5=set(list1)>>>print(set5)#{3,1,2}02集合基本操作符1.元素操作目录3.

查找和判断2.逻辑操作4.其他1.元素操作（1）增加元素：集合.add(元素)（2）增加多个元素：集合.update(列表)。（3）删除元素：集合.remove（元素）或集合.discard（元素）。若元素不存在

，集合.remove（元素）会报错，而集合.discard（元素）不会。（4）清空集合：集合.clear()，清空集合的所有元素。例如：>>>set2={1,2,3}#{1,2,3}>>>set2.add(5)#{1,2,3,5}>>>set2.update([5,7,8])#{1,2

,3,5,7,8}>>>set2.remove(2)#{1,3,5,7,8}元素都为不可变类型，无法直接修改元素，但可以通过先删除再添加来改变元素。例如：>>>set2.discard(8)>>>set2.ad

d(9)>>>set2#{1,3,5,7,9}>>>set2.clear()#{}2.逻辑操作（1）与操作：集合1&集合2或集合1.intersection(集合2)，返回一个新的set包含集合1和集合2中的公共元素。

（2）集合或操作：集合1l集合2或集合1.union(集合2)：返回一个新的set包含集合1和集合2中的每一个元素。（3）集合与非操作：集合1^集合2或集合1.symmetric_difference(集合2)，返回一个新的set包含集合1和集合2中不重复的元素。（4）集合减操作：

集合1-集合2或集合1.difference(集合2)，返回一个新的set包含集合1中有但是集合1中没有的元素。例如：>>>a={1,2,4,5,6}>>>b={1,2,3,5,6}>>>a&b#{1,2,5,6}>>>a.intersection(b)#{1,2,5,6}>

>>a|b#{1,2,3,4,5,6}>>a.union(b)#{1,2,3,4,5,6}>>>a^b#{3,4}>>>a–b#{4}3.查找和判断（1）查找元素：集合虽然无法通过下标索引来定位查找元素，但可以通过xinset来判定是否存在x元素。xnotin集合：判定集合

中是否不存在x元素。例如：>>>set3={'one','two','three','four','five','six'}>>>'TWO'inset3#Flase（2）比较>>>{1,2,3}<{1,2,3,4}#True测试是否子集>>>{1,2,3}=={3,2,1}#Tr

ue测试两个集合是否相等>>>{1,2,4}>{1,2,3}#False集合之间的包含测试（3）判断是否是子集（包含）或超集（）：集合1.issubset(集合2)或集合1.issuperset(集合2)

。例如：>>>set3={'one','two','three','four','five','six'}>>>set4={'two','six'}>>>set4.issubset(set3)#Tru

e>>>set4.issuperset(set3)#Flase>>>set3.issuperset({'two','six'})#True4.其他（1）转变成列表或元组：list(集合)或tuple(集合)。例如：>>>set2={1,2,3}#{1,

2,3}>>>list(set2)#[1,2,3]>>>tuple(set2)#(1,2,3)（2）得到集合元素个数：len(集合)。（3）集合弹出（删除）元素：集合.pop()，从集合中删除并返回任意一个元素。例如：>>>set2={1,2,3}#{1,2,3}>>>x=s

et2.pop()>>>print(x,len(set2))#124.其他（4）集合的浅复制：集合.copy()，返回集合的一个浅复制。例如：>>>set3={'one','two','three','four','five','six'}>>>set5=set3.copy()>>>set5

==set3#True>>>set3.remove(‘one’)>>>set5==set3#Flase【例4.8】生成20个1~20之间的随机数，统计出重复个数。代码如下（ch4,setRand.py）：importrandommyset=set()n=0whilen<20:ele

ment=random.randint(1,20)myset.add(element)n=n+1print(myset,'重复',20-len(myset))运行结果：——字典：dict第4章序列是什么：列元字集01字典基本操作符1.创建字典目录2．基本操作1.创建字典（1）直接创建例如：>

>>dict1={1:'one',2:'two',3:'three'}其中，键是数字，值是字符串。>>>dict1a={'a':100,'b':'boy','c':[1,2,'AB']}其中，键是字符，值是数值、字符串、列表。（2）通过dict函

数来建立字典例如：>>>list1=[(1,'one'),(2,'two'),(3,'three')]>>>dict2=dict(list1)#通过dict函数建立映射关系>>>dict2#{1:'one',2:'two',3:'thre

e'}>>>dict3=dict(one=1,two=2,three=3)#{'one':1,'two':2,'three':3}>>>dict(zip(['one','two','three'],[1,2,3]))#{'one':1,'two':2,'three':3}1.创建

字典（3）两个列表合成字典例如：>>>lstkey=['a','b','c']>>>lstval=[1,2,3]>>>dict1=dict(zip(lstkey,lstval))>>>dict1{'a':1,'b':2,'c':3}2.基本操作（1）得到字典中项（键

:值对）的个数：len(字典)（2）得到关联键上的值：字典[键]例如：>>>dict1={1:'one',2:'two',3:'three'}>>>print(len(dict1))#3>>>print(1,dict1[

1])#1one>>>print('one',dict3['one'])#one1如果使用字典中没有的键访问值，则会出错。（3）字典项添加修改：字典[键]=值例如：>>>dict1[1]='壹';dict1[2]='贰'>>>dict1[4]='肆'#键不存在，添加新的项>>>dict1#{1

:'壹',2:'贰',3:'three',4:'肆'}2.基本操作（4）删除字典项：del字典[键]能删单一的元素也能清空字典，清空只需一项操作。例如：>>>deldict1[3]#删除dict1键是3的项>>>dict1.clear()#清空dict1字典

所有条目>>>deldict1#删除字典dict1（5）判断是否存在键项：键notin字典例如：>>>dict1={1:'one',2:'two',3:'three'}>>>3indict1#True>>>4notindict1#True（6

）字典转换为字符串：str(字典)例如：>>>dict1={1:'one',2:'two',3:'three'}>>>str1=str(dict1)>>>str1#"{1:'one',2:'two',3:'three'}"02字典方法1．访问字典项目录2.修改

删除3．复制4.遍历字典5．使用给定的键建立新的字典1.访问字典项（1）字典.get(键[,默认值])例如：>>>d1['id']=['one','two']#{'id':['one','two']}>>>print(d1['name'])#打印字典中没有的键则会

报错>>>print(d1.get('id'))#['one','two']>>>print(d1.get('name'))#None用get方法就不会报错>>>d1.get('name','N/A')#'N/A'#取代默认的None,

用N/A来替代（2）字典.setdefault(键[，默认值])：在字典中不含有给定键的情况下设定相应的键值。例如：>>>d1={}>>>d1.setdefault('name','N/A')#'N/A'如果不设定值，默认是None>>>d1#{'name':'N/A

'}>>>d1['name']='周'#{'name':'周'}>>>d1.setdefault('name','N/A')#'周'当键为'name'的值不会空返回对应的值1.访问字典项（3）字典.items()：将所用的字典项以列表方法返回

，这些列表项中的每一项都来自于（键、值），但是并没有特殊的顺序。（4）字典.keys()：将字典中的键以列表形式返回。（5）字典.values()：以列表的形式返回字典中的值。例如：>>>dict1={1:'one',2:'two',3:'three'}>>>dict1.items

()#dict_items([(1,'one'),(2,'two'),(3,'three')])>>>dict1.keys()#dict_keys([1,2,3])>>>dict1.values()#dict_val

ues(['one','two','three'])（6）iter(字典)：在字典的键上返回一个迭代器。例如：>>>dict1={1:'one',2:'two',3:'three'}>>>iterd=iter(dict1)>>>iterd#<

dict_keyiteratorobjectat0x0000027C8BE6CA48>2.修改删除（1）字典1.update([字典2])：利用字典2项更新字典1，如果没有相同的键，会添加到旧的字典里面。>>>dict1={

1:'one',2:'two',3:'three'}>>>dict2={2:'two',4:'four'}>>>dict1.update(dict2)>>>dict1#{1:'one',2:'two',3:'three',4:'four'}（2）字典.pop(键

[，默认值])：获得对应于给定键的值，并从字典中移除该项。>>>dict1={1:'one',2:'two',3:'three'}>>>print(dict1.pop(1))#one>>>dict1#{2:'two',3:'three'}2.修改删除（3）字典.popitem()：pop()

方法会弹出列表的最后一个元素，但popitem会弹出随机的项，因为字典并没有顺序和最后的元素。>>>dict1={1:'one',2:'two',3:'three'}>>>print(dict1.po

p(1))#one>>>dict1#{2:'two',3:'three'}>>>print(dict1.popitem())（4）字典.clear()：清除字典中所有的项。>>>x={1:'one',2:'two',3:'three'}>>>y=x>>>x={}#x字典

清空，y不变>>>x={1:'one',2:'two',3:'three'}>>>y=x>>>x.clear()#x和y都字典清空3.复制（1）浅复制：字典.copy()浅复制值本身就是相同的，而不是得到副

本。例如：>>>d1={'xm':'王一平','kc':['C语言','数据结构','计算机网络']}>>>d2=d1.copy()#浅复制>>>d2['xm']='周婷'#修改字典’xm’对应的值>>>d2['kc'].remove('数据结构')#删除字典的某个值>>

>d1#{'xm':'王一平','kc':['C语言','计算机网络']}>>>d2#{'xm':'周婷','kc':['C语言','计算机网络']}3.复制（2）深复制：deepcopy(字典)为避免上面浅复制带来的影响，可以用深复制。>>>fromcopyimportdeepcopy

#导入函数>>>d1={}>>>d1['id']=['one','two']#{'id':['one','two']}>>>d2=d1.copy()#浅复制>>>d3=deepcopy(d1)#深复制>>>d1['id'].append('three')#{'id':['one','two','t

hree']}>>>d2#{'id':['one','two','three']}>>>d3#{'id':['one','two']}4.遍历字典对字典对象迭代或者遍历时默认遍历字典中的键。如果需要遍历字典的元素必须使用字典对象的ite

ms()方法明确说明，如果需要遍历字典的“值”则必须使用字典对象的values()方法明确说明。当使用内置函数以及in运算符对字典对象进行操作时也是一样。例如：dict1={1:'one',2:'two',3:'three'}foritemindict1:#遍历元素健，fori

temindict1.keys()等价print(item,end='')print()foritemindict1.items():#遍历元素print(item,end='')print()foritemindict1.values():#遍历元素值

print(item,end='')print()5.使用给定的键建立新的字典fromkeys(seq[,值])：使用给定的键建立新的字典，每个键默认对应的值为None。例如：>>>{}.fromkeys(['oldname','newname'])

#{'oldname':None,'newname':None}>>>dict.fromkeys(['oldname','newname'])#{'oldname':None,'newname':None}>>>dict.fromkeys(['old

name','newname'],'zheng')不用默认的None，自己提供默认值’zheng’。{'oldname':'zheng','newname':'zheng'}——序列第4章序列是什么：列元字集01序列间的转换1.字符串和列表

和元组转换目录2.列表转换为字符串3.其他相互转换1.字符串和列表和元组转换Python列表、元组和字符串，它们之间的互相转换使用3个函数，即str()、tuple()和list()。例如：>>>str="python">>>li

st(str)#['p','y','t','h','o','n']>>>tuple(str)#('p','y','t','h','o','n')>>>tuple(list(str))#('p','y','t','h','o','n')>>>s

tr([1,2,3])#'[1,2,3]'>>>str((1,2,3))#'(1,2,3)'>>>str({1,2,3})#'{1,2,3}'1.字符串和列表和元组转换【例4.9】统计一个字符串中大写字母、小写字母、数字、其他字符个数，然后将

其组成一个新元组，前面元素包含统计个数，然后将字符串作为元素。代码如下（ch4,strCont.py）：'''统计一个字符串中小写字母、大写字母、数字、其他字符个数然后将其组成一个新元组'''str1=input("str=")cont=[0,

0,0,0]forchinstr1:ifch.islower():cont[0]+=1elifch.isupper():cont[1]+=1elifch.isnumeric():cont[2]+=1else:cont[3]+=1cont.append(str1)mytup

=tuple(cont)print("小写字母=%d,大写字母=%d,数字=%d,其他字符=%d"%(mytup[0],mytup[1],mytup[2],mytup[3]))2.列表转换为字符串列表和元组通过joln函数转换为字符串。例

如：>>>list1=['a','b','c']>>>"".join(list1)3.其他相互转换例如：>>>dict1={1:'one',2:'two',3:'three'}>>>list1=['a','b','c']>>>tup1=tuple(d

ict1)#(1,2,3)字典的key组成的tuple>>>set(list1)#{'c','a','b'}>>>set(tup1)#{1,2,3}3.其他相互转换例如：>>>list(range(5))#把range对象转换为列表[0,1,2,3,4]>>>tuple(_

)#一个下画线(_)表示上一次正确的输出结果(0,1,2,3,4)>>>dict(zip('1234','abcde'))#两个字符串转换为字典{'1':'a','2':'b','3':'c','4':'d'}>>>set('aacbbeeed')#创建可变集合

，自动去除重复{'a','c','b','e','d'}>>>_.add('f')>>>_#上一次正确的输出结果{'a','c','b','e','f','d'}>>>frozenset('aacbbeeed')#创建不可变集合，自

动去除重复frozenset({'a','c','b','e','d'})02常用内置函数1.范围目录2.最值和求和3.函数式编程1.范围（1）range函数range(结束)或range(起始,结束[,步长])：返回一个左闭右开的序列数。其中：步长默认为1，起始默认为0。如果步长

>0，则最后一个元素（起始+步长）<结束。如果步长<0，则最后一个元素（起始+步长）>结束。否则抛出VauleError异常。例如：运行结果：list1=['A','B','C','D','E','F']foriinrange(len(list1)):print(list1[i],end=','

)1.范围range函数还可以对范围对象进行包含测试、元素索引查找、支持负索引、分片操作及用==或!=来比较等。例如：>>>r=range(0,10,2)>>>3inrFalse#3不在范围元素中>>

>r[1]#第1个元素2>>>r.index(2)#元素2的位置1>>>r==range(0,12,2)#比较两个范围元素是否相等False>>>r==range(0,8,2)#后面范围包含认为相等True2.最值和求和max(x[,默认值

,键])、min(x[,默认值,键])：计算列表、元组或其他包含有限个元素的可迭代对象x中所有元素最大值、最小值。其中，default参数用来指定可迭代对象为空时默认返回的最大值或最小值，而key参数用来指定比较大小的依据或规则，可以是函数或lambda表达式。s

um(x[开始位置])：计算列表、元组或其他包含有限个元素的可迭代对象x中所有元素之和，start参数控制求和的初始值。len()：得到列表所包含的元素的数量。enumerate()：得到包含若干下标和值的迭

代对象。all()：测试列表中是否所有元素都等价于True。any()：测试列表中是否有等价于True的元素。例如：>>>fromrandomimportrandint>>>L1=[randint(1,100)f

oriinrange(10)]>>>L1#[99,48,42,87,16,61,71,73,88,46]>>>print(max(L1),min(L1),sum(L1)/len(L1))#991663.12.最值和求和例如：>>>max([

'2','11'])#'2'>>>max(['2','11'],key=len)#'11'>>>max([],default=None)#空>>>fromrandomimportrandint>>>L2=[[randint(1,50)fori

inrange(5)]forjinrange(6)]>>>L2#包含6个子列表的列表[[4,40,43,48,29],[32,38,23,30,17],[39,15,36,45,32],[16,39,34,47

,45],[7,41,19,10,18],[28,4,45,50,38]]>>>max(L2,key=sum)#返回元素之和最大的子列表[16,39,34,47,45]>>>max(L2,key=lambdax:x[1])#返回所有子列表中第2个元素最大的子列表[7,41,19,10,18]2

.最值和求和例如：>>>sum(2**iforiinrange(10))#20+21+22+23+24+...，对应二进制10个11023>>>int('1'*10,2)#'1111111111',二进制10个1=10231023>>>sum([[1,2],[3],[4]],[])[1,2,3,4

]例如：>>>x=[2,3,1,0,4,5]>>>all(x)#测试是否所有元素都等价于TrueFalse#因为包含0元素>>>any(x)#测试是否存在等价于True的元素True#因为只有一个0元素，其他均非0>>>list(enumerate(x))#枚举

列表元素enumerate对象转换为列表[(0,2),(1,3),(2,1),(3,0),(4,4),(5,5)]3.函数式编程（1）内置函数map(函数,序列)：把map对象中每个元素是原序列中元素经过“函数”处理后返回。map()函数不对原序列

或迭代器对象做任何修改。函数可以是系统函数，也可以是用户自定义函数，函数只能带一个参数。例如：>>>list(map(str,range(1,6)))#把数字元素转换为字符串列表['1','2','3',

'4','5']>>>defadd(val):#定义单参数(val)函数addreturnval+1>>>list(map(add,range(1,6)))[2,3,4,5,6]3.函数式编程（2）标准库functools函数re

duce(函数,序列)：将接收两个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值。例如：>>>fromfunctoolsimportreduce>>>defaddxy(x,y):#定义双参数(x,y)函数addxyreturnx+y>

>>list1=[1,2,3,4,5]>>>reduce(addxy,list1)#15其中，reduce执行过程如下：x=1,y=2,addxy(x,y)=1+2；x=3,y=3,addxy(x,y)=3+3

；x=6,y=4,addxy(x,y)=6+4；x=10,y=5,addxy(x,y)=10+5；如果把addxy函数换成乘（*），则上述过程就能够实现计算5！如果把addxy函数换参数变成字符串，则上述过程就能够实现列表所有字符串元素连接。3.函数式编程（3）内置函数f

ilter(函数,序列)：将单参数函数作用到一个序列上，返回函数返回值为True的那些元素组成的filter对象；如果函数为None，则返回序列中等价于True的元素。例如：>>>list1=['abc','123','+-

*/','abc++123']>>>defisAN(x):#自定义函数isAN(x)，测试x是否为字母或数字returnx.isalnum()>>>filter(isAN,list1)<filterobjectat0x0000

02641C30ACC0>>>>list(filter(isAN,list1))#['abc','123']（4）元素压缩zip(x)：它把多个序列或可迭代对象x中的所有元素左对齐，然后往右拉，把所经过的每个序列中相同位置上的元素都放到一个元组中，只要有一个序列中的所有元素都处

理完，返回包含到此为止元组。例如：>>>x=zip('abcd',[1,2,3])#压缩字符串和列表>>>list(x)[('a',1),('b',2),('c',3)]>>>list(x)[]#zip对象

只能遍历一次3.函数式编程例如：>>>x=list(range(6))>>>x[0,1,2,3,4,5]>>>random.shuffle(x)#打乱元素顺序>>>x[2,3,1,0,4,5]>>>list(zip(x,[1]*6)

)#多列表元素重新组合[(2,1),(3,1),(1,1),(0,1),(4,1),(5,1)]>>>list(zip(['a','b','c'],x))#两个列表不等长以短的为准[('a',2),('b',3),('

c',1)3.函数式编程注意：enumerate、filter、map、zip等对象只能从前往后正向访问其中的元素，没有任何方法可以再次访问已访问过的元素，也不支持使用下标访问其中的元素。当所有元素访问结束以后，如果需要重新访问其中的元素，

必须重新创建该生成器对象。例如：>>>n=filter(None,range(10))>>>n<filterobjectat0x000001A865660588>>>>1innTrue>>>2innTrue>>>2innFalse#元素2已经访问>>>s=map(str,range(10))>

>>'2'insTrue>>>'2'insFalse#元素2已经访问——综合应用实例第4章序列是什么：列元字集综合应用实例【例4.10】判断一个数是否是水仙花数。在数论中，水仙花数(NarcissisticNumber)是指一个n位数，其各个位数的n次方之

和等于该数。例如，153是3位数，因为有153=13+53+33，所以153是一个水仙花数。因为n是一个不确定位数数字，用一个列表存放。代码如下（ch4,narc.py）：n=int(input("n="))list1=[]n

um=nwhile(num):ni=num%10num=num//10list1.append(ni)s=0bits=list1.__len__()foriinrange(0,bits):s=s+list1[i]**bitsprint(list1[i])ifs==n:print(n,"是水仙花

数！")else:print(n,"不是水仙花数！")运行结果：综合应用实例【例4.11】冒泡法数据排序。算法：每次把列表中起始位置和结束位置之间的最小元素移到到最前面，然后起始位置后移一个元素。代码如下（ch4,dataSort.py）

：importrandomlist1=[]#生成10个0~100之间的随机整数foriinrange(0,10):num=random.randint(0,100)list1.append(num);print(list

1)#对10个随机整数进行排序forjinrange(0,9):foriinrange(j+1,10):iflist1[j]>list1[i]:list1[i],list1[j]=list1[i],list1[i]#交换数据#输出排序结果print(

list1)运行结果：综合应用实例【例4.12】对10个10~100随机整数进行因数分解。显示因式分解结果，并验证分解式子是否正确。利用列表推导式生成随机整数计算素数。代码如下（ch4,randDec.py）

：fromrandomimportrandintfrommathimportsqrtlst=[randint(10,100)foriinrange(10)]maxNum=max(lst)#随机数中的最大数#计算最大数范围内所有素数primes=[pforpi

nrange(2,maxNum)if0notin[p%dfordinrange(2,int(sqrt(p))+1)]]fornuminlst:n=numresult=[]#存放所有因数forpinprim

es:whilen!=1:ifn%p==0:n=n/presult.append(p)else:breakelse:result='*'.join(map(str,result))#（1）breakprint(num,'=',result,num==eval(result))#（2）综合应用实

例其中：（1）生成因式分解式子。（2）num==eval(result)：将分解的式子转换为数值，看是否相等。运行结果：