python編程基礎（二）

第6章 序列 字元串 列表 元組

本章主題

• 序列簡介
• 字元串
• 列表
• 元組

6.1 序列

訪問模式：每一個元素可以通過制定一個偏移量的方式得到。而多個元素可以通過切片操作的方式一次得到。

6.11 標準類型操作符

標準類型操作符一般都能適用所有的序列類型。

6.1.2序列類型操作符

1.成員關係操作符（in、not in）

成員關係操作符用來判斷一個元素是否屬於一個序列的。

in、not in 操作符的返回值一般來講就是True/False，滿足成員關係就返回True，否則就是False

2.連接操作符（+）

此操作符允許我們把一個序列和另一個相同類型的序列做連接。語法：

sequence1+sequence2n

3.重複操作符（*）

當你需要一個序列的多份拷貝的時候，重複操作符非常有用，語法如下：

sequence*copies_intn

4.切片操作符 [] ,[:],[::]

>>> s=[0,1,2,3,4]n>>> s[:]n[0, 1, 2, 3, 4]n>>> s[0:3]n[0, 1, 2]n>>> s[:3]n[0, 1, 2]n>>> s[2:5]n[2, 3, 4]n>>> s[2:]n[2, 3, 4]n>>> s[1:3]n[1, 2]n>>> s[3]n3n>>> s[::]n[0, 1, 2, 3, 4]n

5.用步長索引來擴展的切片操作

序列的最後一個切片操作的是擴展切片操作，它多出來的第三個索引值被用做步長數。

>>> s=abcdefghn>>> s[::-1]t#可以視作「翻轉」操作nhgfedcban>>> s[::2]t#隔一個取一個的操作nacegn

6.切片索引更多內容

切片索引的語法：開始和結束索引值可以超過字元串的長度。

>>> s=[1,2,3,4,5,6,7]n>>> s[-100:100]n[1, 2, 3, 4, 5, 6, 7]n

每次把位於最後的一個字元砍掉。

>>> s=abcdefghijklmnn>>> i=-1n>>> for i in range(-1,-len(s),-1):nprint s[:i]nabcdefghijklmnabcdefghijklnabcdefghijknabcdefghijnabcdefghinabcdefghnabcdefgnabcdefnabcdenabcdnabcnabnan

如何在第一次迭代的時候就顯示整個字元串呢？

我們的方法：使用None作為索引值。

>>> s=abcdefghijklmnn>>> for i in [None] + range(-1,-len(s),-1):nprint s[:i]nnabcdefghijklmnnabcdefghijklmnabcdefghijklnabcdefghijknabcdefghijnabcdefghinabcdefghnabcdefgnabcdefnabcdenabcdnabcnabnan

我們假設另一種方法可以實現，給出代碼如下：

>>> for i in [None].extend(range(-1,-len(s),-1)):nprint s[:i]nnTraceback (most recent call last):nFile "<pyshell#28>", line 1, in <module>nfor i in [None].extend(range(-1,-len(s),-1)):nTypeError: NoneType object is not iterablen

我們看見報錯了。原因是：[None].extend(...)函數返回None，None既不是序列類型也不是可迭代的對象。

6.1.3 內建函數（BIF）

序列本身就內含了迭代的概念。迭代這個概念是從序列，迭代器，或其他支持迭代器操作的對象中泛化而來的。

python的for循環可以遍歷所有的可迭代類型，在（非純序列對象上）執行for循環時，就像在一個純序列對象上執行一樣。

1.類型轉換

內建函數list()、str()、tuple()被用做在各種序列類型之間的轉換。這種類型轉換實際是工廠函數將對象作為參數將其內容拷貝到新生的對象中。

序列類型轉換工廠函數

• list(iter) 可迭代對象轉換列表

• str(obj) 把obj對象轉換為字元串（對象的字元串表示方法）

• unicode(obj) 把對象轉換為unicode字元串（使用默認編碼）

• basestring() 抽象工廠函數，其作用僅僅是為str、unicode函數提供父類，所以不能被實例化也不能被調用
• tuple(iter) 把一個可迭代對象轉換為一個元組對象

2.可操作

python為序列類型提供以下可操作的BIF。

注意：len()、reversed()、sum()函數只能接受序列類型對象作為參數，剩下的則還可以接受可迭代對象作為參數。

max()、min()函數也可以接受一個參數列表

序列類型可用的內建函數

• enumerate(iter)tt接受一個可迭代的對象作為參數，返回一個enumerate 對象（同時也是一個迭代器），該對象生成由iter每個元素的index值和item值組成的元組
• len(seq)tttt返回seq的長度
• reverse(seq)ttt接受一個序列作為參數，返回一個逆序訪問的迭代器
• sum(seq,init=0)tt返回seq和可選參數init的總和，其效果等同於reduce(operator.add，seq，init)
• zip([it0,it1...itN])tt返回一個列表，其中第一個元素是it()，it1....這些元素組成的第一個元素組成的列表。
• sorted(iter,func)tt接受一個可迭代的對象作為參數，返回一個有序的列表

6.2 字元串

通過在引號間包含字元的方式創建它。

python裡面單引號和雙引號的作用是相同的。

1.字元串的創建和賦值

創建一個字元串就像使用一個標量一樣簡單，可以吧str()作為工廠方法來創建一個字元串並把它賦值給一個變數

>>> aString=Hello world!t#使用單引號n>>> anotherString="Python is cool!"t#使用雙引號n>>> print aStringnHello world!n>>> anotherStringnPython is cool!n>>> s=str(range(4))n>>> sn[0, 1, 2, 3]n

2.如何訪問字元串的值（字元和子串）

用方括弧加一個或者多於一個索引的方式來獲得子串：

>>> aString=Hello world!n>>> aString[0]nHn>>> aString[1:5]nellon>>> aString[6:]nworld!n

3.如何改變字元串

通過給一個變數賦值（或者重賦值）的方式「更新」一個已有的字元串。

>>> aString=aString[:6]+Python!n>>> aStringnHello Python!n>>> aString=different string altogethern>>> aStringndifferent string altogethern

4.如何刪除字元和字元串

字元串是不可變得，你可以清空一個字元串，或把剔除了需要的部分

>>> aString=Hello World!n>>> aString=aString[:3]+aString[4:]n>>> aStringnHelo World!n

通過賦一個空字元串或使用del語句來清空或刪除一個字元串：

>>> del aStringn>>> aStringn

6.3 字元串和操作符

6.3.1 標準類的操作符

下面給出一些操作符是怎麼樣用於字元串類型的：

>>> str1=abcn>>> str2=lmnn>>> str3=xyzn>>> str1<str2nTruen>>> str2!=str3nTruen>>> str1<str3 and str2==xyznFalsen

6.3.2 序列操作符切片（[]和[:]）

（1）正向索引

x是[start:end]中的一個索引值，那麼 start<=x<end

>>> aString=abcdn>>> len(aString)n4n>>> aString[0]nan>>> aString[1:3]nbcn>>> aString[2:4]ncdn>>> aString[4]nTraceback (most recent call last):nFile "<pyshell#16>", line 1, in <module>naString[4]nIndexError: string index out of rangen

使用不在本例範圍內的索引值都會報錯。

（2）反向索引

反向索引時候，從-1開始，向字元串的開始方位計數，到字元串長度的負數為索引的結束。

>>> aString=abcdn>>> -len(aString)n-4n>>> aString[-1]ndn>>> aString[-3:-1]nbcn>>> aString[-4]nan

若開始索引或結束索引沒有被指定，則分別以字元串的第一個和最後一個索引值為默認值。

>>> aString[2:]ncdn>>> aString[1:]nbcdn>>> aString[:-1]nabcn>>> aString[:]nabcdn

（3）成員操作符(in， not in)

成員操作符用於判斷一個字元串或者一個子串是否出現在另一個字元串中。出現為True，否則為False

>>> bc in abcdnTruen>>> n in abcdnFalsen>>> nm not in abcdnTruen

例6-1 標識符檢查（idcheck.py）

#！usr/bin/env pythonnnimport stringnnalphas=string.letters+_nnums=string.digitsnnprint Welcome to the Identifier Checker v1.0nprint Testees must be at least 2 chars long.nmyInput=raw_input(Identifier to test)nnif len(myInput)>1:nn if myInput[0] not in alphasn print invalid:first symbol must be alphasn else:n for otherChar in myInput[1:]:nn if otherChar not in myInput[1:]:n print invalid:remaining symbols must be alphanumbericn breakn else:n print "okay as an identifier"n

2. 連接符（+）

運行時刻字元串連接。通過連接操作符來從原有的字元串獲得一個新的字元串。

>>> asndgfya+iwue9wqunasndgfyaiwue9wqun>>> hello++worldnhelloworldn>>> hello+ +worldnhello worldnn>>> s=Spanish+ +Inqusition+ +Made Easyn>>> snSpanish Inqusition Made Easyn>>> import stringn>>> string.upper(s[:3]+s[20])nSPAAn

上面的例子（使用string模塊）其實我們不建議使用。

我們可以用join()方法來把他們連接在一起：

>>> %s %s %(Spanish,Inquistion)nSpanish Inquistionn>>> s= .join((Spanish,Inqusition,Made Easy))n>>> snSpanish Inqusition Made Easyn>>> (%s%s %(s[:3],s[20])).upper()nSPAAn

3.編譯時字元串連接

>>> foo="Hello" world!n>>> foonHelloworld!n

4.普通字元串轉化為unicode字元串

若把一個普通的字元串和一個Unicode字元串做連接處理，python會在連接操作前把普通字元串轉化為unicode字元串：

>>> Hello+u +World+u!nuHello World!n>>> N!*3nN!N!N!n

6.4 只適用於字元串的操作符

6.4.1 格式化字元串（%）

python支持兩種格式的輸入參數，第一種是元組，第二種是字典。

下面是一些使用格式字元串的例子：

1.十六進位

>>> "%x"% 108n6cn>>> "%#x"% 108n0x6cn

2.浮點型和科學計數法形式輸出

>>> %f% 1234.56789n1234.567890n>>> %.2f%1234.56789n1234.57n>>> %E %1234.56789n1.234568E+03n>>> %g% 1234.56789n1234.57n>>> "%e" %(1111111111111111)n1.111111e+15n

3.整型和字元串輸出

>>> "%+d" % 4n+4n>>> "we are at %d%%" % 100nwe are at 100%n>>> "MM/DD/YY=%02d/%02d/%d"%(2,15,67)nMM/DD/YY=02/15/67n

6.4.2 字元串模板：更簡單的替代品

>>> from string import Templaten>>> s=Template(There are ${howmany} ${lang} Quotation Symbols)n>>> print s.substitute(lang=Python,howmany=3)nThere are 3 Python Quotation Symbolsn>>> print s.substitute(lang=Python)nnTraceback (most recent call last):nFile "<pyshell#23>", line 1, in <module>nprint s.substitute(lang=Python)nFile "D:pylibstring.py", line 176, in substitutenreturn self.pattern.sub(convert, self.template)nFile "D:pylibstring.py", line 166, in convertnval = mapping[named]nKeyError: howmanyn>>> print s.safe_substitute(lang=Python)nThere are ${howmany} Python Quotation Symbolsn

6.4.3 原始字元串操作符（r/R）

正則表達式的創建定義了高級搜索匹配方式的字元串，通常由字元、分組、匹配信息、變數名和子夫雷等特殊符號構成。

>>> nnnn>>> print nnnn>>> rnnnn>>> print rnnnn

6.4.4Unicode字元串操作符(u/U)

Unicode操作符必須出現在原始字元串操作符的前面

urHellonWorld!

6.5內建函數

6.5.1 標準類型函數

cmp()

同比較操作符一樣，內建的cmp()函數也根據字元串的ASCII碼值進行比較。

>>> str1=abcn>>> str2=lmnn>>> str3=xyzn>>> cmp(str1,str2)n-1n>>> cmp(str3,str1)n1n>>> cmp(str2,lmn)n0n

6.5.2序列類型函數

（1）len()函數返回字元串的字元數

>>> str1=abcn>>> len(str1)n3n>>> len(Hello world!)n12n

（2）max() and min()函數能返回最大或最小的字元

>>> max(str2)nnn>>> min(str2)nln>>> min(ab12cd)n1n>>> max(ab12cd)ndn

（3）enumerate()

>>> s=foobarn>>> for i,t in enumerate(s):nprint i,tnnn0 fn1 on2 on3 bn4 an5 rn

（4）zip()

>>> s,t=foa,obrn>>> zip(s,t)n[(f, o), (o, b), (a, r)]n

6.5.3字元串類型函數

（1）raw_input()

內建函數raw_input()函數使用給定的字元串提示用戶輸入並將這個輸入返回。

>>> uer_name=raw_input("Enter your name: ")nEnter your name: Tomn>>> uer_namenTomn>>> len(uer_name)n3n

（2）str() and unicode()

str() and unicode()都是工廠函數，就是說產生對應的類型的對象。接受一個任意類型的對象，然後創建該對象的可列印的或者unicode的字元串表示。

（3）chr() unichr() ord()

chr()函數返回一個對應的字元。unichr()返回的是unicode字元。

ord()函數是chr()函數或unichr()函數的配對

>>> chr(65)nAn>>> ord(a)n97n>>> ord(u2345)nnTraceback (most recent call last):nFile "<pyshell#2>", line 1, in <module>nord(u2345)nTypeError: ord() expected a character, but string of length 2 foundn>>> unichr(12345)nu?n

6.6 字元串內建函數

書上給出了很多很全。我摘錄幾個常用的。

string.join(seq)tt以string作為分隔符，將seq中所有的元素合併為一個新的字元串。

string.lower()ttt轉換string中所有大寫字元為小寫

string.lstrip()ttt截掉string左邊的空格

string.split(str="",num=string.count(str))

以str為分隔符切片str，若num有指定值，則僅分隔num個子字元串

string.upper()ttt轉換string中的小寫字母為大寫

>>> quest=what is your favorite color?n>>> quest.count(or)n2n>>> :.join(quest.split())nwhat:is:your:favorite:color?n>>> quest.upper()nWHAT IS YOUR FAVORITE COLOR?n

6.7 字元串的獨特特性

6.7.1 特殊字元串的控制和控制字元

6.7.2 三引號

三引號允許字元串跨行多行。

6.73 字元串不變性

字元串是一種不可變得數據類型。

>>> abc+defnabcdefn>>> s=abcn>>> s=s+abcn>>> snabcabcn

6.8 Unicode

6.8.1術語

其中，較為熟悉的是，

ASCII 美國標準信息交換碼

UTF-8 8位的轉換格式（無符號位元組序列，長度1-4個位元組）

6.6.2 什麼是Unicode

Unicode通過使用一個或多個位元組來表示一個字元的方法突破例如ASII的限制。這種機制下，可以表示超過90000個字元。

6.8.3 怎麼樣用Unicode

新的內建函數unicode() 和 unichr() 可以看成是unicode版本的str()和 chr()

6.84 Codec 是什麼

codec是COder/DECoder的首字母組合。定義了文本的二進位轉換方式。

支持幾種編碼方式，如：UTF-8 ,ASCII

6.8.6 把unicode應用待實際應用中

遵守以下幾個原則：

• 程序中出現字元串時一定要加個前綴u
• 不要用str()函數，用unicode()代替
• 不要使用過時的string模塊
• 不到必須時不要在你的程序裡面編解碼Unicode字元。

6.8.8 python的unicode支持

1.RE引擎unicode的支持

正則表達式引擎需要Unicode支持。

utf-8 變數長度為8的編碼

6.9 相關模塊

正則表達式（re），提供了高級的字元串模式匹配方案，通過描述這些模式的語法，可以像是要使用「過濾器」一樣高效的查找傳進來的文本。這些過濾器允許你基於自定義的模式字元串抽取匹配模式、執行查找-替換或分隔字元。

6.10 字元串關鍵點總結

1.一些引號分割的字元

2.不可分字元類型

3.字元串格式化字元（%）提供類似printf()功能

4.三引號

5.原始字元串對每個特殊字元串都使用它的原意

6. python字元串不是通過NULL或者0來結束的

6.11 列表

1.如何創建列表數據類型並給它賦值

>>> alist=[123,abc,4.56]n>>> print alistn[123, abc, 4.56]n

2.訪問列表中的值

列表的切片操作就像字元串中一樣，切片操作符（[]）和索引值範圍一起使用。

>>> alist=[123,abc,4.56]n>>> print alistn[123, abc, 4.56]n>>> alist[0]n123n>>> alist[1:4]n[abc, 4.56]n>>> alist[:3]n[123, abc, 4.56]n>>> alist[:2]n[123, abc]nn3.如何更新列表n>>> alistn[123, abc, 4.56]n>>> alist[2]n4.56n>>> alist[2]=replacern>>> alistn[123, abc, replacer]n

4.如何刪除列表中的元素或者列表本身

>>> alistn[123, abc, replacer]n>>> del alist[1]n>>> alistn[123, replacer]n

6.12 操作符

6.12.1 標準類型操作符

>>> list1=[abc,123]n>>> list2=[xyz,789]n>>> list3=[abc,123]n>>> list1<list2nTruen>>> list2<list3nFalsen>>> list2>list3 and list1==list3nTruen

6.12.2 序列操作符

1.切片([]和[:])

>>> num=[43,1.23,2,6.1e5]n>>> str_list=[jack,jumped,over]n>>> mix_list=[4,-1.9+6j,beef]n>>> num[1]n1.23n>>> num[:2]n[43, 1.23]n>>> str_list[2]novern>>> mix_list[1]n(-1.9+6j)n

2.成員關係操作符

>>> x in mix_listnFalsen>>> 4 in numnFalsen

3.連接操作符

>>> num+mix_listn[43, 1.23, 2, 610000.0, 4, (-1.9+6j), beef]n>>> str_list+mix_listn[jack, jumped, over, 4, (-1.9+6j), beef]n

4.重複操作符

>>> num*2n[43, 1.23, 2, 610000.0, 43, 1.23, 2, 610000.0]n>>> num*3n[43, 1.23, 2, 610000.0, 43, 1.23, 2, 610000.0, 43, 1.23, 2, 610000.0]n

6.12.3列表類型操作符和列表解析

>>> [i*2 for i in [8,-2,5]]n[16, -4, 10]n>>> [i for i in range(8) if i%2==0]n[0, 2, 4, 6]n

6.13 內建函數

6.13.1 標準類型函數

cmp()

>>> list1,list2=[123,xyz],[456,abc]n>>> cmp(list1,list2)n-1n>>> cmp(list2,list1)n1n>>> list3=list2+[789]n>>> list3n[456, abc, 789]n>>> cmp(list2,list3)n-1n

6.13.2 序列類型函數

1. len()

返回列表或元組的個數。

>>> num=[43,1.23,2,6.1e5]n>>> len(num)n4n

2. max() 和min()

>>> str_list=[jack,jumped,over,candestick]n>>> max(num)n610000.0n>>> min(num)n1.23n>>> max(str_list)novern>>> min(str_list)ncandestickn

3.sorted() reversed()

>>> s=[Thry,stamp,them,when,"theyre",small]n>>> for t in reversed(s):nprint tnnnsmallntheyrenwhennthemnstampnThryn>>> sorted(s)n[Thry, small, stamp, them, "theyre", when]n

4.enumerate() zip()

>>> for i,albums in enumerate(albums):nprint i,albumsnn0 tn1 an2 bn3 ln4 en5 sn>>> fn=[ian,stuart,david]n>>> ln=[bairnson,elliott,paton]n>>> n>>> for i,j in zip(fn,ln):nprint (%s%s %(i,j)).title()nnIanbairnsonnStuartelliottnDavidpatonn

5.sum()

>>> a=[6,4,5]n>>> sum(a)n15n>>> sum(a,10)n25n

6.list()和tuple()

list()函數和tuple()函數接受可迭代對象作為參數，並通過淺拷貝數據來創建一個新的列表或者元組。

6.14 列表類型內建函數

6.15 列表的特殊特性

1.堆棧

堆棧是一個後進先出（LIFO）的數據結構，想像放盤子的時候，第一個離開的堆棧的是你放上去的最後一個。

添加堆棧，使用「push」，刪除一個元素，把它「pop」出堆棧。

2.隊列

隊列是一種 先進先出（FIFO）的數據結構，類似在超市排隊時候，隊列的第一個人先接受服務。

新的元素通過「入隊」的方式進入隊列末尾，「出隊」就是從隊列的頭部刪除。

6.16 元組

元組是跟列表一種非常相似的另一種容器類型。不同之處在於元組是用圓括弧括起來的。

1.如何創建一個元組並賦值

>>> atuble=(123,abc,4.56)n>>> print atublen(123, abc, 4.56)n

2.如何訪問元組中的值

元組的切片與列表的切片一樣。

>>> atuble[1:3]n(abc, 4.56)n>>> atuble[:3]n(123, abc, 4.56)n

3.如何更新元組

元組是不可變類型。

>>> tup1=[12,34.56]n>>> tup2=[abc,xyz]n>>> tup3=tup1+tup2n>>> tup3n[12, 34.56, abc, xyz]n

4.如何移除一個元組中的元素以及元組本身

刪除一個單獨的元組的元素是不可能的，多數時候是殺出一個對象。

del atuble

6.17 元組操作符和內建函數

6.17.1 標準類型操作符、序列類型操作符和內建函數

元組的對象和序列類型操作符和列表的完全一樣，下面不做贅述。

1.創建、重複、連接操作

2.成員關係操作、切片操作

3.內建函數

4.操作符

6.18 元組的特殊特性

6.18.1不可變給元組帶來了什麼影響

數據類型是不可變的，一旦一個對象被定義了，值就不能再被更新，除非創造一個新的對象。

6.18.2 元組也不是那麼「不可變」

元組本身是不可變的，但是元組包含的可變對象可以變

>>> t=([xyz,123],23,-103.4)n>>> tn([xyz, 123], 23, -103.4)n>>> t[0][1]n123n>>> t[0][1]=[abc,def]n>>> tn([xyz, [abc, def]], 23, -103.4)n

6.18.3 默認集合類型

所有的多對象的、逗號分隔的、沒有明確用符號定義的，這些集合默認的類型都是元組

所有函數返回的多對象都是元組類型。

6.18.4 單元素元組

無法創建一個元素的元組

>>> (x)nxn>>> (x,)n(x,)n>>> type (x)n<type str>n

6.18.5 字典的關鍵字

不可變對象是不可變的，這也意味著通過hash演算法得到的值總是一個值。

第7章 映像和集合類型

本章主題：

• 映射類型：字典
• 操作符
• 內建函數
• 內建方法
• 字典的鍵
• 集合類型
• 操作符
• 內建函數『
• 內建方法
• 相關模塊

7.1映射類型：字典

字典是python語言中唯一的映射類型，映射類型對象是哈希值（鍵，key）和指定的對象（值，value）是一對多的關係。

一個字典的對象是可變的，是一個容器類型，能儲存任意個數的python對象，其中也包括其他容器類型。

字典類型和序列類型容器類（列表、元組）的區別是存儲和訪問的數據的方式不同。序列類型知識數字類型的鍵（從序列的開始起按數值順序索引）。影響類型中的數據是無序排列的。

7.1.1 如何創建字典和給字典賦值

創建字典只需要給字典賦值一個變數，不管這個字典是否包含元素

>>> dict1={}n>>> dict2={name:earth,port:80}n>>> dict1,dict2n({}, {name: earth, port: 80})n

可以用工廠方法dict()創建字典

>>> fdict=dict(([x,1],[y,2]))n>>> fdictn{y: 2, x: 1}n

用一個內建方法fromkeys()來創建一個」默認「字典。字典中華元素具有相同的值

>>> ddict={}.fromkeysn>>> ddict={}.fromkeys((x,y),-1)n>>> ddictn{y: -1, x: -1}n>>> edict={}.fromkeys((foo,bar))n>>> ddictn{y: -1, x: -1}n

7.1.2 如何訪問字典中的值

要遍歷一個字典（一般用鍵），只需要循環查看它的鍵。

>>> dict2={name:earth,port:80}n>>> for key in dict2.keys():nprint key=%s,value=%s %(key,dict2[key])nnnkey=name,value=earthnkey=port,value=80n

你還可以使用迭代器來輕鬆地訪問數據類型對象（sequence-like objects），比如字典和文件。只需要用字典的名字就可以在for循環里遍歷字典。

>>> dict2={name:earth,port:80}n>>> for key in dict2:nprint key=%s,value=%s %(key,dict2[key])nnnkey=name,value=earthnkey=port,value=80n

要得到字典中某個元素的值，可以使用你所熟悉的字典加上括弧來得到。

>>> dict2[name]nearthn

一個字典中混用數字和字元串的例子：

>>> dict3={}n>>> dict3[1]=abcn>>> dict3[1]=3.14159n>>> dict3[3.2]=xyzn>>> dict3n{1: 3.14159, 1: abc, 3.2: xyz}n

除了逐一賦值之外，我們還可以給dict3整體賦值：

>>> dict3={1: 3.14159, 1: abc, 3.2: xyz}n>>> dict3n{1: 3.14159, 1: abc, 3.2: xyz}n

7.1.3 如何更新字典

可以通過以下幾種方式對字典進行修改：添加一個新數據項或新元素（一個鍵-值對）：修改一個已經存在的數據項：或刪除一個已經存在的數據項。

>>> dict2[name]=venusn>>> dict2[port]=6969n>>> dict2[arch]=sunos5n>>> dict2n{arch: sunos5, name: venus, port: 6969}n

7.1.4 如何刪除字典元素和字典

刪除整個字典，使用del語句。一般是刪除單個元素或清除整個字典的內容。

del dict2[name]tt#刪除鍵為『name』的條目

dict2.clear()ttt#刪除dict 中所有條目

del dict2tttt#刪除整個dict字典

dict2.pop(name)tt#刪除並返回鍵值為『w』的條目

7.2 映射類型操作符

字典可以和所有的標準類型操作符一起工作。但是不支持像拼接和重複這樣的操作

7.2.1 標準類型操作符

下面進行操作符的簡單示例

>>> dict4={abc:123}n>>> dict5={abc:456}n>>> dict6={abc:123,97.3:83}n>>> dict7={xyz:123}n>>> dict4<dict5nTruen>>> dict4n{abc: 123}n>>> (dict4<dict6) and (dict4<dict7)nTruen>>> (dict5<dict6) and (dict5<dict7)nTruen>>> dict6<dict7nFalsen

7.2.2 映射類型操作符

1.字典的鍵查找操作符([])

鍵查找操作符是唯一用於字典類型的操作符，它和序列類型里的單一元素的切片(slice)操作符很像。

對於字典類型來說，用鍵查詢（字典里的元素），鍵為參數，而非一個索引。鍵操作符可以給字典賦值，也可以用於從字典中取值：

d[k]v 通過鍵k，給字典中某元素賦值v

d[k] 通過鍵k，查詢字典中元素的值

2.（鍵）成員關係操作（in、not in）

用 in 和 not in 來檢查某個鍵是否在字典中

>>> abc in dict4nTruen>>> name in dict4nFalsen

7.3 映射型的內建函數和工廠函數

7.3.1 映射類型相關的函數

如果參數是可以迭代的，一個支持迭代的對象，那麼每個迭代的元素都必須成對的出現。

>>> dict(zip((x,y),(1,2)))n{y: 2, x: 1}n>>> dict([[x,1],[y,2]])n{y: 2, x: 1}n>>> dict([xy[i-1],i] for i in range(1,3))n{y: 2, x: 1}n>>> dict8=dict(x=1,y=2)n>>> dict9=dict(**dict8)n>>> dictn<type dict>n>>> dict9n{y: 2, x: 1}n>>> dict9=dict8.copynn>>> dict9=dict8.copy()n>>> dict9n{y: 2, x: 1}n

內建函數len()函數，對字典調用它，會返回所有的元素(鍵-值對)的數目

>>> dict9n{y: 2, x: 1}n>>> len (dict9)n2n

內建函數hash()，可以判斷某個對象是否可以作為一個字典的鍵。

對一個對象作為參數傳遞給hash()，會返回這個對象的哈希值。只有這個對象是哈希的，才可以作為字典的鍵（函數的返回值是整型，不產生錯誤或異常）

>>> hash([])nnTraceback (most recent call last):nFile "<pyshell#27>", line 1, in <module>nhash([])nTypeError: unhashable type: listn

如果非哈希類型的值傳遞給hash()方法，就會報錯

下面我們給出3個映射類型的相關函數

dict([container]) 創建字典的工廠函數，提供了容器類（container），就用其中的條目填充字典，否則就創建一個空字典。

len(mapping) 返回映射的長度(鍵-值的個數)

hash(obj)tt返回objde 的哈希值

7.4 映射類型的內建方法

基本的字典方法關注他們的鍵和值。

keys()方法，返回一個列表，包含字典中的所有鍵；

values()方法，返回一個列表，包含字典中的所有值；

items()，返回一個包含所有(鍵，值)元組的列表。

>>> dict9n{y: 2, x: 1}n>>> dict9.keys()n[y, x]n>>> dict9.values()n[2, 1]n>>> dict9.items()n[(y, 2), (x, 1)]n

7.5 字典的鍵

字典的值是沒有限制的，字典的鍵是有類型限制的。

7.5.1 不允許一個鍵對應多個值

原則：每個鍵只能對應一個項。當鍵發生衝突時，取最後（最近）的賦值

>>> dict10={f:123,f:xyz}n>>> dict10n{f: xyz}n>>> dict10[f]nxyzn

鍵f所對應的值被替換了兩次，最後的賦值語句，值123代替了值xyz

7.5.2 鍵必須是可哈希的

多數python對象可以作為鍵，但他們必須是可哈希的。

像列表和字典這樣的可變類型，不可哈希，不可作為鍵。

本章小結 一個程序：管理用戶名和密碼的模擬登陸數據系統

#!/usr/bin/env/pythonnndb=() #空資料庫初始化程序nndef newuser():nprompt=login desired:nwhile Ture:nname=raw_input(prompt)nif db.has_key(name):nprompt=name taken,try another:ncontinuenelse:nbreaknpwd=raw_input(passwd:)ndb[name]=pwdnndef olduser():nname=raw_input(login:)npwd=raw_input(passwd:)npasswd=bd.get(name)nif passwd==pwd:nprint welcome back,namenelse:nprint login incorrectnndef showmenu():nprompt=n

7.6 集合類型

數學上，把set稱作不同的元素組成的集合，集合（set）的成員通常被稱作元素

集合對象是一組無序排列的哈希值。

7.6.1 如何創建集合類型和集合賦值

用集合工廠的方法set()和frozenset()

>>> s=set(cheeseshop)n>>> snset([c, e, h, o, p, s])n>>> t=frozenset(bookshop)n>>> tnfrozenset([b, h, k, o, p, s])n>>> type(s)n<type set>n>>> type(t)n<type frozenset>n>>> len(s)n6n>>> len(s)==len(t)nTruen>>> s==tnFalsen

7.6.2 如何訪問集合中的值

可以遍歷看集合成員或檢查某項元素是否是一個集合的成員

>>> k in snFalsen>>> k in tnTruen>>> c not in snFalsen>>> for i in s:nprint inncnenhnonpnsn

7.6.3 如何更新集合

用集合內建的方法和操作符來添加和刪除集合成員

>>> s.add(z)n>>> snset([c, e, h, o, p, s, z])n>>> s.update(pypi)n>>> snset([c, e, i, h, o, p, s, y, z])n>>> s.remove(z)n>>> snset([c, e, i, h, o, p, s, y])n>>> s-=set(pypi)n>>> snset([c, e, h, o, s])n

只有可變集合能被改變，不可變集合更改的時候就會報錯

>>> t.add(z)nnTraceback (most recent call last):nFile "<pyshell#73>", line 1, in <module>nt.add(z)nAttributeError: frozenset object has no attribute addn

7.6.4 如何刪除集合中的成員和集合

調用del即可

>>> del sn>>> snnTraceback (most recent call last):nFile "<pyshell#75>", line 1, in <module>nsnNameError: name s is not definedn

7.7 集合類型操作符

7.7.1 標準類型操作符（所有的集合類型）

1.成員關係（in，not in）

略

2.集合等價/不等價

>>> s=set(cheeseshop)n>>> snset([c, e, h, o, p, s])n>>> s==tnFalsen>>> s!=tnTruen>>> u=frozenset(s)n>>> s==unTruen>>> set(posh)==set(shop)nTruen

3.子集/超集

小於符號（<或<=）用來判斷子集

大於負荷（>或>=）用來判斷超集

>>> set(shop)<set(cheeseshop)nTruen>>> set(bookshop)>=set(shop)nTruen

7.7.2 集合類型操作符（所有的集合類型）

1.聯合（|）

聯合操作和集合的OR操作是等價的。

>>> s|tnset([c, b, e, h, k, o, p, s])n

2.交集（&）

交集集合和集合的AND操作是等價的，相同元素將合併

>>> s&tnset([h, s, o, p])n

3.差補/相對補集

兩個幾個的差補/相對補集指一個集合C，只屬於集合s，不屬於t

>>> s-tnset([c, e])n

4.對差等分

和他的布爾集合操作類似，對稱差分是集合的XOR（又稱之為異或）

>>> s^tnset([b, e, k, c])n>>> t|snfrozenset([c, b, e, h, k, o, p, s])n>>> t^snfrozenset([c, b, e, k])n>>> t-snfrozenset([k, b])n

7.8 內建函數

7.8.1標準內建函數

len()

把集合作為參數傳遞給len()函數，返回集合的基數

>>> s=set(u)n>>> snset([p, c, e, h, s, o])n>>> len(s)n6n

7.8.2 集合類型工廠函數

set() frozenset()

set() frozenset()工廠函數分別用來生成可變和不可變集合。

>>> set()nset([])n>>> set([])nset([])n>>> set(())nset([])n>>> set(shop)nset([h, s, o, p])n>>> frozenset([foo,bar])nfrozenset([foo, bar])n>>> f=open(number,w)n>>> for i in range(5):nf.write(%dn % i)nnn>>> f.close()n>>> f=open(number,r)n>>> set(f)nset([0n, 3n, 1n, 4n, 2n])n>>> f.close()n

7.9 集合類型內建方法

7.9.1 方法（所有的集合方法）

s.copy() 返回一個新集合，它是集合s的淺複製

7.9.2 方法（僅僅只用於可變集合）

• s.update(t) 用t中的元素修改s，s現在包含s或t的成員

• s.add(obj) 在集合s中添加對象obj

• s.remove(obj) 從集合對象中刪除對象obj

• s.discard(obj) 如果obj是集合s中的元素，從集合s中刪除對象obj

• s.pop() 刪除集合s中的任意一個對象，並返回它

• s.clear() 刪除集合s中所有對象

聲明：

以上學習筆記來自

《python核心編程》第2版 Wesley J.Chun 編著 宋吉廣譯 人民郵電出版社

推薦閱讀：