——列表：list第4章

序列是什么：列元字集——列表：list第4章序列是什么：列元字集列表、元組、字典和集合是Python中常用的序列類型，很多復雜的業(yè)務邏輯最終還是由這些基本數(shù)據類型來實現(xiàn)。表4.1比較了這幾種結構的區(qū)別。比較項列表元組字典集合類型名稱listtupledictset定界符方括號[]圓括號()大括號{}大括號{}是否可變是否是是是否有序是是否否是否支持下標是（使用序號作為下標）是（使用序號作為下標）是（使用“鍵”作為下標）否元素分隔符逗號逗號逗號逗號對元素形式的要求無無鍵：值必須可哈希對元素值的要求無無“鍵”必須可哈希必須可哈希元素是否可重復是是“鍵”不允許重復，“值”可以重復否元素查找速度非常慢很慢非常快非?？煨略龊蛣h除元素速度尾部操作快，其他不允許快快列表、元組、字典和集合是Python中常用的序列類型，很多復201創(chuàng)

建

列

表目錄01創(chuàng)建列表目3創(chuàng)建列表列表可以通過多種方式創(chuàng)建。例如：>>>list1=[-23,5.0,'python',12.8e+6] #列表包含不同類型數(shù)據>>>list2=[list1,1,2,3,4,5] #列表中包含列表>>>print(list2) #[[-23,5.0,'python',12800000.0],1,2,3,4,5]>>>list2=[1]*6 #產生6個全為1的數(shù)組創(chuàng)建列表列表可以通過多種方式創(chuàng)建。>>>list1=[-202索引和切片1.索引和切片2.運算符目錄3.內置函數(shù)02索引和切片1.索引和切片2.運算符目3.內置函數(shù)51.索引和切片序列中所有的元素都是有編號的，從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。列表中值的切片可以用“列表變量[頭下標:尾下標:步長]”來截取相應的列表，列表被分片后返回一個包含所含元素的新列表。例如：1.索引和切片序列中所有的元素都是有編號的，從0開始遞增。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.運算符（1）加(+)是列表連接運算符。>>>ls2.運算符（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] #True2.運算符（4）存儲單元是否相同：is[not]>>>x3.內置函數(shù)除了列表對象自身方法之外，很多Python內置函數(shù)也可以對列表進行操作。例如：>>>list3=[1,2,3,4,5,6,7,8,9,10]>>>len(list3) #10>>>min(list3) #1 最小值>>>max(list3) #10 最大值3.內置函數(shù)除了列表對象自身方法之外，很多Python內置03列表的基本操作1.更新列表：元素賦值目錄2.刪除元素：使用del語句03列表的基本操作1.更新列表：元素賦值目2.刪除元素101.更新列表：元素賦值例如：>>>list3=[1,2,3,4,5,6,7,8,9,10]>>>list3[0]='one' #元素賦值改變>>>list3[1:4]=['two','three','four'] #[1:3]區(qū)段賦值改變>>>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]1.更新列表：元素賦值例如：>>>list3=[1,22.刪除元素：使用del語句>>>list4=[1,2,3,4,5,6,7,8,9,10]>>>dellist4[1] #刪除列表第1個元素2>>>list4[0:5]=[] #[0:4]]區(qū)段刪除>>>list4 #[7,8,9,10]>>>dellist4[:] #清空列表,list4列表變量還在>>>list4 #[]>>>dellist4 #刪除實體變量list42.刪除元素：使用del語句>>>list4=[1,2,04列

表

方

法1.常用方法目錄3.遍歷列表元素2.排序04列表方法1.常用方法目3.遍歷列表元素2131.常用方法列表.append(元素)，用于在列表末尾追加新的元素。列表.extend(序列)，可以在列表的末尾一次性追加另一個序列中的多個值。列表.count(元素)，統(tǒng)計某個元素在列表中出現(xiàn)的次數(shù)。列表.index(元素)，從列表中找出某個值第一個匹配項的索引位置。列表.insert(索引,元素)：將對象插入到指定序號的列表中。列表.pop([索引])：移除列表中的一個元素（默認是最后一個），并且返回該元素的值。列表.remove(元素)：移除列表中某個值的第一個匹配項。列表.reverse()：將列表中元素順序全部反向。1.常用方法列表.append(元素)，用于在列表末尾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”出現(xiàn)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.remove(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.常用方法例如：>>>a=[1,2,1,2,3,4,1.常用方法比較列表的大?。?gt;>>[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.常用方法比較列表的大?。篖ist1=['one'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.2】列表前移n位。lst=[1,2,31.常用方法【例4.3】將第1個和第2個列表中的數(shù)據所有組合成一個新的列表。代碼如下（ch4,lstComb.py）：List1=['A','B','C','D'];List2=[1,2];List3=[]foriinList1:forjinList2:List3.append([i,j])print(List3)運行結果：1.常用方法【例4.3】將第1個和第2個列表中的數(shù)據所有組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,'天')運行結果：1.常用方法【例4.4】判斷今天是今年的第幾天。impor2.排序排序方法：列表.sort([參數(shù)])，對原列表進行排序，并返回空值。指定的參數(shù)對列表進行排序方式進行控制。（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方法默認的方式進行排序，可以指定參數(shù)：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.排序排序方法：列表.sort([參數(shù)])，對原列表進行2.排序（3）多維列表多維列表就是列表的數(shù)據元素本身也是列表。為了引用二維列表中的一個數(shù)據值，需要兩個索引號，一個是外層列表的，另外一個是元素列表的。例如：>>>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.排序（3）多維列表>>>list2=[[1,2,3]2.排序【例4.5】輸入20成績，找出其中的最高分數(shù)、平均分數(shù)、并且對成績從大到小排序。代碼如下（ch4,lstMAS.py）sum=0list1=[]foriinrange(0,6):n=int(input("n="))sum=sum+nlist1.append(n)print("最高分數(shù)為:",max(list1))print("平均分數(shù)為:%6.2f"%(sum/len(list1)))list1.sort(reverse=True)print(list1)運行結果：2.排序【例4.5】輸入20成績，找出其中的最高分數(shù)、平均3.遍歷列表元素fork,vinenumerate(列表): print(k,v)例如：>>>list1=[-23,5.0,'python',12.8e+6] #列表包含不同類型數(shù)據>>>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]77883.遍歷列表元素fork,vinenumerate05列

表

推導

式1．嵌套列表平鋪目錄3．同時遍歷多個列表或可迭代對象2．元素條件過濾4．復雜的條件篩選05列表推導式1．嵌套列表平鋪目3．同時遍歷多個列表或24列表推導式由于Python的內部對列表推導式做了大量優(yōu)化，所以運行速度快，是推薦使用的一種技術。列表推導式的語法：[<表達式>for<表達式1>in<序列1>if<條件1>for<表達式2>in<序列2>if<條件2>?列表推導式在邏輯上等價于一個循環(huán)語句，只是形式上更加簡潔。例如：lst=[x?xforxinrange(n)]等價于:lst=[]forxinrange(n):lst.append(x?x)列表推導式由于Python的內部對列表推導式做了大量優(yōu)化，所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=[]>>>foreleminlist1:fornuminelem:list2.append(num)>>>list2[1,2,3,4,5,6,7,8,9]1．嵌套列表平鋪例如：>>>lst=[[1,2,3],[42．元素條件過濾使用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,valueinenumerate(lst)ifvalue==m] #找最大元素所有位置[8]2．元素條件過濾使用if子句可以對列表中的元素進行篩選，保留2．元素條件過濾【例4.6】接收一個所有元素值都不相等的整數(shù)列表x和一個整數(shù)n，要求將值為n的元素作為支點，將列表中所有值小于n的元素全部放到n的前面，所有值大于n的元素放到n的后面。代碼如下（ch4,lstInfer.py）：lst=[0,1,-2,3,-4,5,-6,7,-8,9,-10]n=0lst1=[iforiinlstifi<n]lst2=[iforiinlstifi>n]lst=lst1+[n]+lst2print(lst)運行結果：2．元素條件過濾【例4.6】接收一個所有元素值都不相等的整數(shù)3．同時遍歷多個列表或可迭代對象例如：>>>list1=[1,2,3]>>>list2=[1,3,4,5]>>>[(x,y)forxinlist1foryinlist2ifx==y] #（1）[(1,1),(3,3)]>>>[(x,y)forxinlist1ifx==1foryinlist2ify!=x] #（2）[(1,3),(1,4),(1,5)]其中：（1）兩個列表元素同時遍歷時根據元素條件篩選。（2）兩個列表元素同時遍歷時用兩個元素條件篩選。3．同時遍歷多個列表或可迭代對象例如：>>>list1=[4．復雜的條件篩選當然，列表推導式中使用函數(shù)或復雜表達式。（1）推導式為復雜表達式。例如：lst=[1,-2,3,-4]print([val+2ifval%2==0elseval+1forvalinlstifval>0])[2,4] 其中，列表推導式為“val+2ifval%2==0elseval+1”。（2）if判斷條件為復雜條件表達式下列語句能夠生成2`20之間的素數(shù)。例如：>>>importmath>>>[numfornuminrange(2,20)if0notin[num%gforginrange(2,int(math.sqrt(num))+1)]][2,3,5,7,11,13,17,19]4．復雜的條件篩選當然，列表推導式中使用函數(shù)或復雜表達式。l——元組：tuple第4章

序列是什么：列元字集——元組：tuple第4章序列是什么：列元字集01元組的基本操作1.元組的基本介紹目錄3.枚舉2.元組的操作注意4.使用tuple的好處01元組的基本操作1.元組的基本介紹目3.枚舉2.元組321.元組的基本介紹說明：（1）不包含任何元素，創(chuàng)建空元組，例如：tl=()。（2）元組中只包含一個元素時，創(chuàng)建時需要在元素后面添加逗號，例如：t2=(6,)；（3）元組下標索引從0開始，可以進行截取、組合等操作。（4）無關閉分隔符的對象，以逗號隔開，默認為元組。例如：>>>t1=1,2,3,'four',5.0,3+4.2j,-1.2e+26 #創(chuàng)建元組>>>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.元組的基本介紹說明：>>>t1=1,2,3,'fou1.元組的基本介紹（5）元組運算符（+，*）函數(shù)和與列表函數(shù)基本上是一樣的。例如：>>>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) #元素個數(shù)，結果：9>>>4int2 #元素4是否存在于元組中，結果：False>>>tuple([1,2,3]) #參數(shù)是列表，轉換為元組(1,2,3)>>>tuple('ABC') #參數(shù)是字符串，轉換為元組('A','B','C')>>>tuple((1,2,3)) #參數(shù)為元組，轉換為元組(1,2,3)（6）以一個序列作為參數(shù)并把它轉換為元組，如果參數(shù)是元組，那么就會原樣返回該元組。1.元組的基本介紹（5）元組運算符（+，*）函數(shù)和與列表函2.元組的操作注意（1）修改元組元組中的元素值是不允許修改的，但用戶可以對元組進行連接組合。例如：>>>tup1,tup2=(1,2,3),('four','five') #同時賦值>>>tup3=tup1+tup2 #連接元組>>>tup3 #(1,2,3,'four','five')>>>tup2[1]=’two’ #錯誤（2）刪除元組元組中的元素值是不允許刪除的，但可以使用del語句來刪除整個元組。例如：>>>deltup22.元組的操作注意（1）修改元組>>>tup1,tup23.枚舉enumerate()函數(shù)用來枚舉可迭代對象中的元素，返回可迭代的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='')運行結果：

3.枚舉enumerate()函數(shù)用來枚舉可迭代對象中的元4.使用tuple的好處（1）tuple比list操作速度快。如果定義了一個值的常量集,并且唯一不斷地遍歷它,請使用tuple代替list。（2）如果對不需要修改的數(shù)據進行“寫保護”,可以使代碼更安全。（3）tuples可以在字典中用做key,但是list不行。因為字典的key必須是不可變的。4.使用tuple的好處（1）tuple比list02生成器推導式目錄02生成器推導式目38生成器推導式當需要使用生成器對象的元素時，可以轉化為列表或元組，或者使用生成器對象的__next__()方法或者Python內置函數(shù)next()進行遍歷，或者直接使用for循環(huán)遍歷。注意，只能從前往后正向訪問其中的元素，當然也不能使用下標訪問其中的元素。不能訪問已訪問過的元素。如果需要重新訪問，必須重新創(chuàng)建該生成器對象。例如：>>>gen=((j+1)*3forjinrange(6)) #創(chuàng)建生成器對象>>>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: #使用循環(huán)直接遍歷生成器對象中的元素print(item,end='')369121518生成器推導式當需要使用生成器對象的元素時，可以轉化為列表或元生成器推導式【例4.7】將指定元組中元素大于平均值的數(shù)成新元組。代碼如下（ch4,tupInfer.py）：tup1=(1,2,3,-4,5,-6,7,8,-9,10)avg=sum(tup1)/len(tup1) #平均值lst=[xforxintup1ifx>avg] #列表推導式tup2=tuple(lst)print(tup2)運行結果：生成器推導式【例4.7】將指定元組中元素大于平均值的數(shù)成新元——集合：set第4章

序列是什么：列元字集——集合：set第4章序列是什么：列元字集01集合的創(chuàng)建與訪問目錄01集合的創(chuàng)建與訪問目42集合的創(chuàng)建與訪問非空集合可以把逗號分隔的元素放在一對大括號中來創(chuàng)建，如：{'jack','sjoerd'}。集合元素必須是可哈希的、不可改變的，如str、tuple、frozenset、數(shù)字等。set()得到一個空的集合。例如：>>>set1=set() >>>set2={1,2,3} #{1,2,3}>>>set3=set([1,2,3]) #{1,2,3}>>>set4=set('abc') #'b','a','c'}集合是無序的不重復的，例如：>>>list1=[1,2,1,3]>>>set5=set(list1)>>>print(set5) #{3,1,2}集合的創(chuàng)建與訪問非空集合可以把逗號分隔的元素放在一對大括號中02集合基本操作符1.元素操作目錄3.查找和判斷2.邏輯操作4.其他02集合基本操作符1.元素操作目3.查找和判斷2.邏輯441.元素操作（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.add(9)>>>set2 #{1,3,5,7,9}>>>set2.clear() #{}1.元素操作（1）增加元素：集合.add(元素)>>>se2.邏輯操作（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}>>>ersection(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}

2.邏輯操作（1）與操作：集合1&集合2或集合1.int3.查找和判斷（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} #True 測試兩個集合是否相等>>>{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) #True>>>set4.issuperset(set3) #Flase>>>set3.issuperset({'two','six'}) #True3.查找和判斷（1）查找元素：集合雖然無法通過下標索引來定4.其他（1）轉變成列表或元組：list(集合)或tuple(集合)。例如：>>>set2={1,2,3} #{1,2,3}>>>list(set2) #[1,2,3]>>>tuple(set2) #(1,2,3)（2）得到集合元素個數(shù)：len(集合)。（3）集合彈出（刪除）元素：集合.pop()，從集合中刪除并返回任意一個元素。例如：>>>set2={1,2,3} #{1,2,3}>>>x=set2.pop()>>>print(x,len(set2)) #124.其他（1）轉變成列表或元組：list(集合)或tup4.其他（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之間的隨機數(shù)，統(tǒng)計出重復個數(shù)。代碼如下（ch4,setRand.py）：importrandommyset=set()n=0whilen<20:element=random.randint(1,20)myset.add(element)n=n+1print(myset,'重復',20-len(myset))運行結果：4.其他（4）集合的淺復制：集合.copy()，返回集合的——字典：dict第4章

序列是什么：列元字集——字典：dict第4章序列是什么：列元字集01字典基本操作符1.創(chuàng)建字典目錄2．基本操作01字典基本操作符1.創(chuàng)建字典目2．基本操作511.創(chuàng)建字典（1）直接創(chuàng)建例如：>>>dict1={1:'one',2:'two',3:'three'}其中，鍵是數(shù)字，值是字符串。>>>dict1a={'a':100,'b':'boy','c':[1,2,'AB']}其中，鍵是字符，值是數(shù)值、字符串、列表。（2）通過dict函數(shù)來建立字典例如：>>>list1=[(1,'one'),(2,'two'),(3,'three')]>>>dict2=dict(list1) #通過dict函數(shù)建立映射關系>>>dict2 #{1:'one',2:'two',3:'three'}>>>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.創(chuàng)建字典（1）直接創(chuàng)建>>>list1=[(1,'o1.創(chuàng)建字典（3）兩個列表合成字典例如：>>>lstkey=['a','b','c']>>>lstval=[1,2,3]>>>dict1=dict(zip(lstkey,lstval))>>>dict1{'a':1,'b':2,'c':3}1.創(chuàng)建字典（3）兩個列表合成字典>>>lstkey=2.基本操作（1）得到字典中項（鍵:值對）的個數(shù)：len(字典)（2）得到關聯(lián)鍵上的值：字典[鍵]例如：>>>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.基本操作（1）得到字典中項（鍵:值對）的個數(shù)：len2.基本操作（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'}"2.基本操作（4）刪除字典項：del字典[鍵]>>>d02字

典

方

法1．訪問字典項目錄2.修改刪除3．復制4.遍歷字典5．使用給定的鍵建立新的字典02字典方法1．訪問字典項目2.修改刪除3．復561.訪問字典項（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.訪問字典項（1）字典.get(鍵[,默認值])>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_values(['one','two','three'])（6）iter(字典)：在字典的鍵上返回一個迭代器。例如：>>>dict1={1:'one',2:'two',3:'three'}>>>iterd=iter(dict1) >>>iterd #<dict_keyiteratorobjectat0x0000027C8BE6CA48>1.訪問字典項（3）字典.items()：將所用的字典項以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.修改刪除（1）字典1.update([字典2])：利用2.修改刪除（3）字典.popitem()：pop()方法會彈出列表的最后一個元素，但popitem會彈出隨機的項，因為字典并沒有順序和最后的元素。>>>dict1={1:'one',2:'two',3:'three'}>>>print(dict1.pop(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都字典清空2.修改刪除（3）字典.popitem()：pop()方法3.復制（1）淺復制：字典.copy()淺復制值本身就是相同的，而不是得到副本。例如：>>>d1={'xm':'王一平','kc':['C語言','數(shù)據結構','計算機網絡']}>>>d2=d1.copy() #淺復制>>>d2['xm']='周婷' #修改字典’xm’對應的值>>>d2['kc'].remove('數(shù)據結構') #刪除字典的某個值>>>d1 #{'xm':'王一平','kc':['C語言','計算機網絡']}>>>d2 #{'xm':'周婷','kc':['C語言','計算機網絡']}3.復制（1）淺復制：字典.copy()>>>d1={'3.復制（2）深復制：deepcopy(字典)為避免上面淺復制帶來的影響，可以用深復制。>>>fromcopyimportdeepcopy #導入函數(shù)>>>d1={}>>>d1['id']=['one','two'] #{'id':['one','two']}>>>d2=d1.copy() #淺復制>>>d3=deepcopy(d1) #深復制>>>d1['id'].append('three') #{'id':['one','two','three']}>>>d2 #{'id':['one','two','three']}>>>d3 #{'id':['one','two']}3.復制（2）深復制：deepcopy(字典)>>>fr4.遍歷字典對字典對象迭代或者遍歷時默認遍歷字典中的鍵。如果需要遍歷字典的元素必須使用字典對象的items()方法明確說明，如果需要遍歷字典的“值”則必須使用字典對象的values()方法明確說明。當使用內置函數(shù)以及in運算符對字典對象進行操作時也是一樣。例如：dict1={1:'one',2:'two',3:'three'}foritemindict1: #遍歷元素健，foritemindict1.keys()等價print(item,end='')print()foritemindict1.items(): #遍歷元素print(item,end='')print()foritemindict1.values(): #遍歷元素值print(item,end='')print()4.遍歷字典對字典對象迭代或者遍歷時默認遍歷字典中的鍵。如5.使用給定的鍵建立新的字典fromkeys(seq[,值])：使用給定的鍵建立新的字典，每個鍵默認對應的值為None。例如：>>>{}.fromkeys(['oldname','newname'])#{'oldname':None,'newname':None}>>>dict.fromkeys(['oldname','newname'])#{'oldname':None,'newname':None}>>>dict.fromkeys(['oldname','newname'],'zheng')不用默認的None，自己提供默認值’zheng’。{'oldname':'zheng','newname':'zheng'}5.使用給定的鍵建立新的字典fromkeys(seq[,——序

列第4章

序列是什么：列元字集——序列第4章序列是什么：列元字集01序列間的轉換1.字符串和列表和元組轉換目錄2.列表轉換為字符串3.其他相互轉換01序列間的轉換1.字符串和列表和元組轉換目2.列表轉換為字661.字符串和列表和元組轉換Python列表、元組和字符串，它們之間的互相轉換使用3個函數(shù)，即str()、tuple()和list()。例如：>>>str="python">>>list(str) #['p','y','t','h','o','n']>>>tuple(str) #('p','y','t','h','o','n')>>>tuple(list(str)) #('p','y','t','h','o','n')>>>str([1,2,3]) #'[1,2,3]'>>>str((1,2,3)) #'(1,2,3)'>>>str({1,2,3}) #'{1,2,3}'1.字符串和列表和元組轉換Python列表、元組和字符串，它1.字符串和列表和元組轉換【例4.9】統(tǒng)計一個字符串中大寫字母、小寫字母、數(shù)字、其他字符個數(shù)，然后將其組成一個新元組，前面元素包含統(tǒng)計個數(shù)，然后將字符串作為元素。代碼如下（ch4,strCont.py）：'''統(tǒng)計一個字符串中小寫字母、大寫字母、數(shù)字、其他字符個數(shù)

然后將其組成一個新元組'''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,數(shù)字=%d,其他字符=%d"%(mytup[0],mytup[1],mytup[2],mytup[3]))1.字符串和列表和元組轉換【例4.9】統(tǒng)計一個字符串中大寫2.列表轉換為字符串列表和元組通過joln函數(shù)轉換為字符串。例如：>>>list1=['a','b','c']>>>"".join(list1)2.列表轉換為字符串列表和元組通過joln函數(shù)轉換為字符串。3.其他相互轉換例如：>>>dict1={1:'one',2:'two',3:'three'}>>>list1=['a','b','c']>>>tup1=tuple(dict1) #(1,2,3)字典的key組成的tuple>>>set(list1) #{'c','a','b'}>>>set(tup1) #{1,2,3}3.其他相互轉換例如：>>>dict1={1:'o3.其他相互轉換例如：>>>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') #創(chuàng)建可變集合，自動去除重復{'a','c','b','e','d'}>>>_.add('f')>>>_ #上一次正確的輸出結果{'a','c','b','e','f','d'}>>>frozenset('aacbbeeed') #創(chuàng)建不可變集合，自動去除重復frozenset({'a','c','b','e','d'})3.其他相互轉換例如：>>>list(range(5))02常用內置函數(shù)1.范圍目錄2.最值和求和3.函數(shù)式編程02常用內置函數(shù)1.范圍目2.最值和求和3.函數(shù)式編程721.范圍（1）range函數(shù)range(結束)或range(起始,結束[,步長])：返回一個左閉右開的序列數(shù)。其中：步長默認為1，起始默認為0。如果步長>0，則最后一個元素（起始+步長）<結束。如果步長<0，則最后一個元素（起始+步長）>結束。否則拋出VauleError異常。例如：運行結果：list1=['A','B','C','D','E','F']foriinrange(len(list1)):print(list1[i],end=',')1.范圍（1）range函數(shù)運行結果：list1=['A'1.范圍range函數(shù)還可以對范圍對象進行包含測試、元素索引查找、支持負索引、分片操作及用==或!=來比較等。例如：>>>r=range(0,10,2)>>>3inr False #3不在范圍元素中>>>r[1] #第1個元素2>>>r.index(2) #元素2的位置1>>>r==range(0,12,2) #比較兩個范圍元素是否相等False >>>r==range(0,8,2) #后面范圍包含認為相等True1.范圍range函數(shù)還可以對范圍對象進行包含測試、元素索2.最值和求和max(x[,默認值,鍵])、min(x[,默認值,鍵])：計算列表、元組或其他包含有限個元素的可迭代對象x中所有元素最大值、最小值。其中，default參數(shù)用來指定可迭代對象為空時默認返回的最大值或最小值，而key參數(shù)用來指定比較大小的依據或規(guī)則，可以是函數(shù)或lambda表達式。sum(x[開始位置])：計算列表、元組或其他包含有限個元素的可迭代對象x中所有元素之和，start參數(shù)控制求和的初始值。len()：得到列表所包含的元素的數(shù)量。enumerate()：得到包含若干下標和值的迭代對象。all()：測試列表中是否所有元素都等價于True。any()：測試列表中是否有等價于True的元素。例如：>>>fromrandomimportrandint>>>L1=[randint(1,100)foriinrange(10)]>>>L1 #[99,48,42,87,16,61,71,73,88,46]>>>print(max(L1),min(L1),sum(L1)/len(L1)) #991663.12.最值和求和max(x[,默認值,鍵])、min(x2.最值和求和例如：>>>max(['2','11']) #'2'>>>max(['2','11'],key=len) #'11'>>>max([],default=None) #空>>>fromrandomimportrandint>>>L2=[[randint(1,50)foriinrange(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.最值和求和例如：>>>max(['2','11'])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)]2.最值和求和例如：>>>sum(2**ifori3.函數(shù)式編程（1）內置函數(shù)map(函數(shù),序列)：把map對象中每個元素是原序列中元素經過“函數(shù)”處理后返回。map()函數(shù)不對原序列或迭代器對象做任何修改。函數(shù)可以是系統(tǒng)函數(shù)，也可以是用戶自定義函數(shù)，函數(shù)只能帶一個參數(shù)。例如：>>>list(map(str,range(1,6))) #把數(shù)字元素轉換為字符串列表['1','2','3','4','5']>>>defadd(val): #定義單參數(shù)(val)函數(shù)addreturnval+1>>>list(map(add,range(1,6)))[2,3,4,5,6]3.函數(shù)式編程（1）內置函數(shù)map(函數(shù),序列)：把map3.函數(shù)式編程（2）標準庫functools函數(shù)reduce(函數(shù),序列)：將接收兩個參數(shù)的函數(shù)以迭代累積的方式從左到右依次作用到一個序列或迭代器對象的所有元素上，并且允許指定一個初始值。例如：>>>fromfunctoolsimportreduce>>>defaddxy(x,y): #定義雙參數(shù)(x,y)函數(shù)addxy returnx+y>>>list1=[1,2,3,4,5]>>>reduce(addxy,list1) #15其中，reduce執(zhí)行過程如下：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函數(shù)換成乘（*），則上述過程就能夠實現(xiàn)計算5！如果把addxy函數(shù)換參數(shù)變成字符串，則上述過程就能夠實現(xiàn)列表所有字符串元素連接。3.函數(shù)式編程（2）標準庫functools函數(shù)reduc3.函數(shù)式編程（3）內置函數(shù)filter(函數(shù),序列)：將單參數(shù)函數(shù)作用到一個序列上，返回函數(shù)返回值為True的那些元素組成的filter對象；如果函數(shù)為None，則返回序列中等價于True的元素。例如：>>>list1=['abc','123','+-*/','abc++123']>>>defisAN(x): #自定義函數(shù)isAN(x)，測試x是否為字母或數(shù)字returnx.isalnum() >>>filter(isAN,list1)<filterobjectat0x000002641C30ACC0>>>>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.函數(shù)式編程（3）內置函數(shù)filter(函數(shù),序列)：將3.函數(shù)式編程例如：>>>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)) #多列表元素重新組合[