Python總結(jié)精簡

1、編碼風格使用4空格縮進，而非TAB。在小縮進（可以嵌套更深）和大縮進（更易讀）之間，4空格是一個很好的折中。TAB引發(fā)了一些混亂，最好棄用。折行以確保其不會超過79個字符。這有助于小顯示器用戶閱讀，也可以讓大顯示器能并排顯示幾個代碼文件。使用空行分隔函數(shù)和類，以及函數(shù)中的大塊代碼。可能的話，注釋獨占一行。使用文檔字符串。把空格放到操作符兩邊，以及逗號后面，但是括號里側(cè)不加空格：a = f(1,2) + g(3,4)統(tǒng)一函數(shù)和類命名?？偸怯胹elf作為方法的第一個參數(shù)。字符串利用三引號（）或（”）可以指示一個多行的字符串，在里面可以隨便使用單引號和雙引號。它也是文檔字符串DocStrings&g

2、t;>> def doc():'''Hi Hi'''pass>>> print doc._doc_Hi Hi>>>文檔字符串第一行應該是關于對象用途的簡介。如果文檔字符串有多行，第二行應該空出來，與接下來的詳細描述明確分離。轉(zhuǎn)義符：'what's up' 等價于"what's up"表示反斜杠本身行末單獨的一個表示在下一行繼續(xù)，而不是新的一行：'aaaaadddd' 等價于'aaaaadddd'原始字符串r如果我們生

3、成一個“原始”字符串，n 序列不會被轉(zhuǎn)義，而且行尾的反斜杠，源碼中的換行符，都成為字符串中的一部分數(shù)據(jù)。>>> hello = r"This is a rather long string containingnserveral lines of text much as you would do in C.">>> print helloThis is a rather long string containingnserveral lines of text much as you would do in C.>>>

4、 hello = "This is a rather long string containingnserveral lines of text much as you would do in C.">>> print helloThis is a rather long string containingserveral lines of text much as you would do in C原始字符串的最后一個字符不能是“”，如果想要讓字符串以單“”結(jié)尾，可以這樣：>>> print r'ee'''

5、;ee如果是print r'ee'則會返回錯誤；如果是print r'ee'則會返回ee字符串可以由 + 操作符連接，可以由 * 操作符重復。相鄰的兩個字符串文本自動連接在一起，它只用于兩個字符串文本，不能用于字符串表達式。>>> 'str '.strip()'str'>>> 'str' 'jkl''strjkl'>>> 'str '.strip() 'jkl'SyntaxError: invali

6、d syntax>>> 'str '.strip() + 'jjj''strjjj'字符串不可變，向字符串文本的某一個索引賦值會引發(fā)錯誤。不過，組合文本內(nèi)容生成一個新文本簡單而高效。>>> word = 'thank'>>> word0't'>>> word0 = 'f'Traceback (most recent call last): File "<pyshell#10>", line 1,

7、in <module> word0 = 'f'TypeError: 'str' object does not support item assignment>>> word :4 + 'g''thang'切片操作有個有用的不變性：i:s + is: 等于i。>>> word:4 + word4:'thank'值被轉(zhuǎn)換為字符串的兩種機制：str、reprstr函數(shù)：把值轉(zhuǎn)換為合理形式的字符串repr：創(chuàng)建一個字符串，以合法的Python表達式的形式來表示值>&g

8、t;> print repr('hello,world!')'hello,world!'>>> print str('hello,world!')hello,world!>>> print repr('1000L')'1000L'>>> print str('1000L')1000Linput與raw_input:>>> raw_input('e:')e:a'a'>>> i

9、nput('e:')e:aTraceback (most recent call last): File "<pyshell#26>", line 1, in <module> input('e:') File "<string>", line 1, in <module>NameError: name 'a' is not defined>>> input('e:')e:'a''a'>&

10、gt;> a = raw_input('e:')e:123>>> type(a)<type 'str'>>>> b = input('e:')e:123.01>>> type(b)<type 'float'>>>> raw_input('e:')e:1 + 2'1 + 2'>>> input('e:')e:1 + 23由上面的例子可以知道，兩個函數(shù)均能接收字符串，區(qū)

11、別是raw_input()直接讀取控制臺的輸入（任何類型的輸入它都可以接收），而input()在接收字符串的時候需要加上引號，否則會引發(fā)錯誤。此外，在接收純數(shù)字方面，input()具有自己的特性，并不是像raw_input()一樣把所有輸入都當做字符串看待。除此之外，input()會接收合法的python表達式1 + 2返回int型的3。字符串大小寫變換：lower() 小寫 upper() 大寫 swapcase() 大小寫互換 capitalize() 首字符大寫 title()只有首字符大寫，其余為小寫。用于轉(zhuǎn)換字符串為標題：>>> 'that's al

12、l,folks'.title()"That'S All,Folks"string模塊的capwords函數(shù)：>>> import string>>> string.capwords('that's all,folks')"That's All,folks"字符串在輸出時候的對齊：ljust(width,fillchar)：左對齊，輸出width個字符，不足部分用filchar補足，默認的為空格。rjust（width，fillchar）：右對齊。center(width,

13、fillchar)：中間對齊。zfill(width)：把字符串變成width長，并在右對齊，不足部分用0補足。>>> string.capwords('what's all,forks.').ljust(20)"What's All,forks. ">>> string.capwords('what's all,forks.').rjust(20)" What's All,forks.">>> string.capwords('

14、what's all,forks.').center(40)" What's All,forks. ">>> string.capwords('what's all,forks.').zfill(20)"000What's All,forks."字符串中的搜索和替換及其他常用方法：find(subsrt,start,end)：返回字符串中第一個出現(xiàn)substr的第一個字母的標號，如果沒有subser則返回-1。start和end的作用相當于在start:end中搜索。 >&g

15、t;> 'srrrtripoopp'.find('trip',-1,-4)-1>>> 'srrrtripoopp'.find('trip')4index(subsrt,start,end)：與find一樣，只是在字符串中沒有substr時，會返回一個運行時錯誤。rfind(subsrt,start,end)：返回字符串中最后出現(xiàn)substr的第一個字母的標號，如果字符串中沒有substr，返回-1.rindex(subsrt,start,end)。count(subsrt,start,end)：計算subs

16、tr在字符串中出現(xiàn)的次數(shù)。replace(oldstr,newstr,count)：把字符串中的oldstr替換為newstr，count為替換的次數(shù)。strip(char)：把字符串中前后有char的字符全部去掉，默認去掉空格：>>> ' aa bb '.strip()'aa bb'>>> '* aaa * bbb * !*'.strip('*')' aaa * bbb * !'當然還有l(wèi)strip(char)、rstrip(char)：>>> 'ts

17、ssssttt'.lstrip('t')'sssssttt'>>> 'tsssssttt'.rstrip('t')'tsssss'>>>join方法用來在隊列中添加元素，但需要添加的隊列元素都必須是字符串：>>> seq = 1,2,3,4,5>>> sep = '+'>>> sep.join(seq) #連接數(shù)字列表Traceback (most recent call last): File &qu

18、ot;<pyshell#38>", line 1, in <module> sep.join(seq)TypeError: sequence item 0: expected string, int found>>> seq = '1','2','3','4','5' #連接字符串列表>>> sep.join(seq)'1+2+3+4+5'>>> dirs = '','usr',&

19、#39;bin','eno'>>> '/'.join(dirs)'/usr/bin/eno'>>> print 'C:' + ''.join(dirs) #注意的轉(zhuǎn)義問題SyntaxError: EOL while scanning string literal>>> print 'C:' + ''.join(dirs)C:usrbinenosplit方法用來將字符串分割成序列：>>> '/usr

20、/bin/env'.split('/')'', 'usr', 'bin', 'env'如果不提供任何分隔符，程序會把所有空格作為分隔符：>>> 'Using the default'.split()'Using', 'the', 'default'translate方法也是替換字符串中的的某些部分，但只處理單個字符。它的優(yōu)勢在于可以同時進行多個替換，有些時候比replace效率高的多。使用translate轉(zhuǎn)換之前，需要完成一

21、張轉(zhuǎn)換表，通過string模塊里的maketrans函數(shù)完成。maketrans函數(shù)接受兩個參數(shù)：兩個等長的字符串，表示第一個字符串中的每個字符都用第二個字符串中的相同位置的字符替換：>>> from string import maketrans>>> table = maketrans('cs','kz')>>> len(table)256 #轉(zhuǎn)換表是包含替換ASC字符集中256個字符的替換字符的字符串>>> table97:123'abkdefghijklmnopqrztuvw

22、xyz'translate的第二個參數(shù)是可選的，用來指定要刪除的字符：>>> 'kz cdds dffg'.translate(table,'f')'kz kddz dg'字符串格式化：%操作符左側(cè)放置一個需要格式化的字符串，這個字符串帶有一個或多個嵌入的轉(zhuǎn)換目標，都可以以%開始。如果需要在格式化字符串里面包括百分號，那么必須使用%。%右邊放置一個或者多個對象，這些對象將會插入到左邊想進行格式化字符串的一個或者多個轉(zhuǎn)換目標位置上。如果要格式化實數(shù)（浮點數(shù)），可以使用f說明符類型，同時提供所需要的精度：一個句點再加上希望所

23、保留的小數(shù)位數(shù)。因為格式化說明符總是一表示類型的字符結(jié)束，所以精度應該放在類型字符前面：%.3f。基本的轉(zhuǎn)化說明符：1%字符：標記轉(zhuǎn)換說明符的開始2轉(zhuǎn)換標志：-（減號）表示左對齊；+表示在轉(zhuǎn)換值之前要加上正負號；“”（空白字符）表示正數(shù)之前保留空格；0表示轉(zhuǎn)換值若位數(shù)不夠則用0補充3最小字段寬度：轉(zhuǎn)化后的字符串至少應該具有該值指定的寬度，如果是*，則寬度會從值元組中讀出4點（.）后跟精度值：如果轉(zhuǎn)換的是實數(shù)，精度值就表示出現(xiàn)在小數(shù)點后的位數(shù)。如果轉(zhuǎn)換的是字符串，那么該數(shù)字就是表示最大字段寬度。如果是*，那么精度就會從元組中讀出字符串格式化轉(zhuǎn)換類型：c：字符 f，F(xiàn)：十進制浮點數(shù)d，i：帶符號的

24、十進制整數(shù) o：不帶符號的八進制 n：不帶符號的十進制 C：單字符（接受整數(shù)或者單字符字符串）x：不帶符號的十六進制（小寫） X：不帶符號的十六進制（大寫）e：科學計數(shù)法表示的浮點數(shù)（小寫） E：科學計數(shù)法表示的浮點數(shù)（大寫）g：如果指數(shù)大于-4或者小于精度值則和e相同，其他情況與f相同G：如果指數(shù)大于-4或者小于精度值則和E相同，其他情況與F相同r：字符串（使用repr轉(zhuǎn)換任意Python對象）s：字符串（使用str轉(zhuǎn)換任意Python對象）一些簡單的轉(zhuǎn)換：>>> 'Price of eggs:$%d' % 42'Price of eggs:$42&

25、#39;>>> 'Hexadecimal price of eggs:%x' % 42'Hexadecimal price of eggs:2a'>>> from math import pi>>> 'Pi:%f.' % pi'Pi:3.141593.'>>> 'Very inexact estimate of pi:%i' % pi'Very inexact estimate of pi:3'>>> '

26、;Using str:%s' % 42L'Using str:42'>>> 'Using repr:%r' % 42L'Using repr:42L'字段寬度和精度：這兩個參數(shù)都是整數(shù)（首先是字段寬度，然后是精度），通過點號（.）分隔：>>> '%10f' % pi' 3.141593'>>> '%10.2f' % pi' 3.14'>>> '%.2f' % pi'3.14'

27、;>>> '%.5s' % 'Guido can Rossum''Guido'可以使用*作為字段寬度或者精度（或者兩者都是用*），此時數(shù)值會從元組參數(shù)中讀出：>>> '%*.*s' % (10,5,'Guido ddds aaa')' Guido'符號，對齊和0填充：>>> '%010.2f' % pi'0000003.14'>>> '%-10.2f' % pi'3.14&

28、gt;>> print '%5d' % 10 + 'n' + '%5d' % -10 #用來對齊正負數(shù) 10 -10>>> print ('%+5d' % 10) + 'n' + ('%+5d' % -10) +10 -10標示符第一個字母只能是字母或者下劃線，其他部分可以有數(shù)字，標示符對字母大小寫是敏感的。比較字符串使用cmp()函數(shù)，當兩個字符串一樣的時候，返回0。當s是t的一部分的時候cmp(s,t)返回-1，相反s長于t的時候返回1。也可以對指定的長度比較cmp

29、(sm:n,tz,p)。模板字符串string模塊提供另外一種格式化值的方法：模板字符串。substitute這個模板方法會用傳遞進來的關鍵字參數(shù)foo替換字符串中的$foo：>>> from string import Template>>> s = Template('$x,glorious $x!')>>> s.substitute(x='slurm')'slurm,glorious slurm!'如果替換字段是單詞的一部分，那么參數(shù)名就必須使用括號括起來，從而準確指明結(jié)尾：>&g

30、t;> s = Template('It's $xtastic!')>>> s.substitute(x='slurm')"It's slurmtastic!"可以使用$插入美元符號。除了關鍵字參數(shù)外，還可以使用字典變量提供鍵/值對：>>> s = Template('A $thing must never $action.')>>> d = >>> d'thing' = 'gentleman'>

31、>> d'action' = 'show his socks'>>> s.substitute(d)'A gentleman must never show his socks.'數(shù)據(jù)結(jié)構(gòu)數(shù)據(jù)結(jié)構(gòu)基本上就是用來存儲一組相關數(shù)據(jù)的。Python有一種名為容器的數(shù)據(jù)結(jié)構(gòu)，容器基本上是包含其他對象的任意對象。序列（Python有6種內(nèi)建序列：列表、元組、字符串、Unicode字符串、buffer對象、xrange對象）和映射（例如字典）是兩類主要容器。序列中的每個元素都有自己的編號，而映射中的每個元素則有一個名字（也稱為鍵

32、）。既不是序列也不是映射的容器類型，集合（set）就是個例子。列表list是處理一組有序項目的數(shù)據(jù)結(jié)構(gòu)，列表是可變的數(shù)據(jù)類型（可以修改元素），支持原處修改對象操作。列表的元素不必是同一類型。但列表和字符串是無法連接在一起的，兩種相同類型的序列才能進行連接操作。索引與分片的賦值是原地進行的，是對列表的直接修改，而不是產(chǎn)生新的列表作為結(jié)果。列表方法：append(x)：把一個元素添加到列表的結(jié)尾extend(L)：將L中的所有元素添加到對象列表中insert(i, x)：在指定位置插入一個元素remove(x)：刪除列表中值為x的第一個元素，如果沒有這樣的元素，就會返回一個錯誤。pop()從列表中

33、刪除指定位置的元素，并將其返回。a.pop()默認返回（刪除）最后一個元素。index(x)返回列表中第一個值為x的元素的索引，如果沒有匹配的元素就會返回一個錯誤。sort()對列表中的元素就地進行排序（直接修改了調(diào)用它的對象）。reverse()就地倒排列表中的元素。count(x)返回x在鏈表中出現(xiàn)的次數(shù)。sort方法詳解：>>> x = 4,6,2,1,7,9>>> x.sort()>>> x1, 2, 4, 6, 7, 9為了得到一個排好序的副本，且保持原列表不變，下面的方法是錯誤的：>>> y = x.sort(

34、)>>> print yNone因為x.sort()返回的是None，并不是一個排序好的列表，sort()方法只是進行了“原地”操作。正確的做法是：>>> x = 4,6,2,1,7,9>>> y = x:>>> y.sort()>>> x4, 6, 2, 1, 7, 9>>> y1, 2, 4, 6, 7, 9只是簡單的把x賦值給y是沒用的，因為這樣就讓x、y指向了同一個列表了：>>> y = x>>> y.sort()>>> y1

35、, 2, 4, 6, 7, 9>>> x1, 2, 4, 6, 7, 9另一種獲取已排序的列表副本的方法是，sorted函數(shù)：>>> x = 4,6,2,1,7,9>>> y = sorted(x)>>> x4, 6, 2, 1, 7, 9>>> y1, 2, 4, 6, 7, 9這個函數(shù)可以用于任何序列，卻總是返回一個列表：>>> sorted('Python')'P', 'h', 'n', 'o', &#

36、39;t', 'y'>>> sorted('2351')'1', '2', '3', '5'高級排序cmp、key、reverse參數(shù)都可用于sort()函數(shù)：1. cmp參數(shù)：>>> n = 5,2,9,7>>> n.sort(cmp)>>> n2, 5, 7, 92. key參數(shù)：>>> x = 'aaaawt','ert','j'>>&g

37、t; x.sort(key=len)>>> x'j', 'ert', 'aaaawt'3. reverse參數(shù)：>>> x = 4,6,2,1,7,9>>> x.sort(reverse=True)>>> x9, 7, 6, 4, 2, 1雙端隊列：把列表當隊列使用（先進先出）：雙端隊列（Double-ended queue或稱deque）在需要按元素增加的順序來移除元素時非常有用。collections模塊中的deque類型（它為在首尾兩端快速插入和刪除而設計）。雙端隊列通

38、過可迭代對象（比如集合）創(chuàng)建，而且有些非常用用的方法，如下所示：>>> from collections import deque>>> q = deque(range(5)>>> q.append(5)>>> q.appendleft(6)>>> qdeque(6, 0, 1, 2, 3, 4, 5)>>> q.pop()5>>> q.popleft()6>>> q.rotate(3) #右移3次>>> qdeque(2, 3, 4

39、, 0, 1)>>> q.rotate(-1) #左移一次>>> qdeque(3, 4, 0, 1, 2)雙端隊列好用的原因是它能有效地在開頭（左側(cè)）增加和彈出元素，這是在列表中無法實現(xiàn)的。除此之外，它還能夠有效地旋轉(zhuǎn)（rotate）元素（也就是將它們左移或右移，使頭尾相連）。對于列表來講，有三個內(nèi)置函數(shù)非常有用：fileter,map,reducefilter(function, sequence)返回一個序列，包括了給定序列中所有調(diào)用function(item)后返回值為True的元素（如果可能的話，會返回相同的類型）。如果該序列是一個字符串或者元組，

40、它返回值必定是同一類型，否側(cè)，它總是list。例如，以下程序可以計算部分素數(shù)：>>> def f(x):return x % 2 !=0 and x %3 !=0>>> filter(f,range(2,25)5, 7, 11, 13, 17, 19, 23map(function, sequence) 為每一個元素依次調(diào)用 function(item) 并將返回值 組成一個鏈表返回。例如，以下程序計算立方：>>> def cube(x):return x * x * x>>> map(cube,range(1,11)1,

41、 8, 27, 64, 125, 216, 343, 512, 729, 1000可以傳入多個序列，函數(shù)也必須要有對應數(shù)量的參數(shù)，執(zhí)行時會依次用各序列上對應的元素來調(diào)用函數(shù)（如果某些序列比其它的短，就用 None 來代替）。如果把 None做為一個函數(shù)傳入，則直接返回參數(shù)做為替代。例如：>>> s = 'a','b','c','d'>>> t = 'a','b','c','l'>>> d = 'a'

42、,'b','c','j'>>> map(add,s,t,d)'aaa', 'bbb', 'ccc', 'dlj'>>> map(None,s,t,d)('a', 'a', 'a'), ('b', 'b', 'b'), ('c', 'c', 'c'), ('d', 'l', &

43、#39;j')reduce(func, sequence) 返回一個單值，它是這樣構(gòu)造的：首先以序列的前兩個元素調(diào)用函數(shù) function，再以返回值和第三個參數(shù)調(diào)用，依次執(zhí)行下去。例如：>>> def add(x,y):return x + y>>> reduce(add,range(1,101)5050如果序列中只有一個元素，就返回它，如果序列是空的，就拋出一個異常。列表推導式：列表推導式提供了一個創(chuàng)建鏈表的簡單途徑，無需使用map()，filter()以及 lambda。以定義方式得到列表通常要比使用構(gòu)造函數(shù)創(chuàng)建這些列表更清晰。每一個列表推導式

44、包括在一個for語句之后的表達式，零或多個for或if語句。返回值是由for或if子句之后的表達式得到的元素組成的列表。如果想要得到一個元組，必須要加上括號。>>> freshfruit = 'banana', 'loganberry ', 'passion fruit '>>> weapon.strip() for weapon in freshfruit'banana', 'loganberry', 'passion fruit'>>> ve

45、c = 2, 4, 6>>> 3*x for x in vec6, 12, 18>>> 3*x for x in vec if x > 312, 18>>> 3*x for x in vec if x < 2>>> x,x*2 for x in vec2, 4, 4, 16, 6, 36>>> x, x*2 for x in vec# error - parens required for tuplesFile "<stdin>", line 1, in ?x,

46、 x*2 for x in vecSyntaxError: invalid syntax>>> (x, x*2) for x in vec(2, 4), (4, 16), (6, 36)>>> vec1 = 2, 4, 6>>> vec2 = 4, 3, -9>>> x*y for x in vec1 for y in vec28, 6, -18, 16, 12, -36, 24, 18, -54>>> x+y for x in vec1 for y in vec26, 5, -7, 8, 7, -5,

47、10, 9, -3>>> vec1i*vec2i for i in range(len(vec1)8, 12, -54嵌套的列表推導式：考慮以下3X3矩陣的例子，一個列表包含了三個列表，每個一行：>>> mat = 1, 2, 3, 4, 5, 6, 7, 8, 9, 現(xiàn)在，如果你想交換行和列，可以用列表推導式：>>> print rowi for row in mat for i in 0, 1, 21, 4, 7, 2, 5, 8, 3, 6, 9為了不被嵌套的列表推導式搞暈，從右往左讀。接下來有一個更容易讀的版本：>>&g

48、t; for i in 0,1,2:for raw in mat:print rawi,print實用中，你可以利用內(nèi)置函數(shù)完成復雜的流程語句。函數(shù) zip() 在這個例子中可以搞定大量的工作：>>> zip(*mat)(1, 4, 7), (2, 5, 8), (3, 6, 9)刪除語句：有個方法可以從列表中按給定的索引而不是值來刪除一個子項：del 語句。它不同于有返回值的pop()方法。語句del還可以從列表中刪除切片或清空整個列表。例如：>>> a = -1, 1, 66.25, 333, 333, 1234.5>>> del a0

49、>>> a1, 66.25, 333, 333, 1234.5>>> del a2:4>>> a1, 66.25, 1234.5>>> del a:>>> adel 也可以刪除整個變量：>>> del a #此后再引用命名 a 會引發(fā)錯誤（直到另一個值賦給它為止）。當兩個變量同時引用一個列表的時候：它們的確是同時引用了同一個列表。如果想避免出現(xiàn)這種情況，可以復制一個列表的副本。當在序列中做切片的時候，返回的切片總是一個副本。因此，如果你復制了整個列表的切片，將會達到一個副本：>&g

50、t;> names = 'Mrs.Entity','Mrs.Thing'>>> n = names>>> n is namesTrue>>> n = namesTrue>>> n0 = 'Mr.D'>>> n'Mr.D', 'Mrs.Thing'>>> names'Mr.D', 'Mrs.Thing'>>> m = names:>>>

51、m is namesFalse>>> m = namesTrue>>> m0 = 'Ms.P'>>> m'Ms.P', 'Mrs.Thing'>>> names'Mr.D', 'Mrs.Thing'>>> n'Mr.D', 'Mrs.Thing'y = x:與y = x不同，前者是得到完全復制x后的另一個列表y，后者是x與y指的同一個列表。元組元組通常用在使語句或者用戶定義的函數(shù)能夠安全的采用一

52、組值的時候，即被使用的元祖的值不會改變。元組也是一個序列。一個元組由數(shù)個逗號分隔的值組成，例如：>>> t = 12345, 54321, 'hello!'>>> t012345>>> t(12345, 54321, 'hello!')>>>u = t, (1, 2, 3, 4, 5) # 元組可以嵌套>>> u(12345, 54321, 'hello!'), (1, 2, 3, 4, 5)tuple函數(shù)：以一個序列作為參數(shù)并把它轉(zhuǎn)換為元組。>>

53、;> tuple(1,2,3)(1, 2, 3)>>> tuple('abs')('a', 'b', 's')>>> tuple(1,2,3)(1, 2, 3)元組在輸出時總是有括號的，以便于正確表達嵌套結(jié)構(gòu)。在輸入時可以沒有括號，不過經(jīng)常括號都是必須的（如果元組是一個更大的表達式的一部分）。元組就像字符串，不可改變：不能給元組的一個獨立的元素賦值（盡管你可以通過聯(lián)接和切割來模擬）。還可以創(chuàng)建包含可變對象的元組，例如列表。一個特殊的問題是構(gòu)造包含零個或一個元素的元組：為了適應這種情況，語法

54、上有一些額外的改變。一對空的括號可以創(chuàng)建空元組；要創(chuàng)建一個單元素元組可以在值后面跟一個逗號（在括號中放入一個單值不夠明確），丑陋，但是有效。例如：>>> empty = ()>>> singleton = 'hello',>>> singleton('hello',)語句t = 12345, 54321, 'hello!'是元組封裝（tuple packing）的一個例子：值12345，54321和'hello!'被封裝進元組。其逆操作可能是這樣：x, y, z = t這個調(diào)用

55、等號右邊可以是任何線性序列，稱之為“序列拆封”非常恰當。“序列拆封”要求左側(cè)的變量數(shù)目與序列的元素個數(shù)相同。要注意的是可變參數(shù)（multiple assignment）其實只是元組封裝和序列拆封的一個結(jié)合。序列列表和元組都是序列。序列的兩個主要特點是可以進行索引操作（從序列中抓取一個特定的項目）和切片操作（序列的一部分）以及加、乘、成員資格。len()、max()、min()也可以用于序列。list:返回整個序列的拷貝；list:-1則得到一個反轉(zhuǎn)的序列。在序列中循環(huán)時，索引位置和對應值可以使用 enumerate() 函數(shù)同時得 到。>>> for i, v in enum

56、erate('tic', 'tac', 'toe'):print i, v0 tic1 tac2 toe同時循環(huán)兩個或更多的序列，可以使用 zip() 整體打包。>>> questions = 'name', 'quest', 'favorite color'>>> answers = 'lancelot', 'the holy grail', 'blue'>>> for q, a in zip(q

57、uestions, answers):print 'What is your 0?It is 1.'.format(q, a)What is your name? It is lancelot.What is your quest? It is the holy grail.What is your favorite color? It is blue.需要逆向循環(huán)序列的話，先正向定位序列，然后調(diào)用 reversed() 函數(shù)：>>> for i in reversed(range(1,10,2):print i,9 7 5 3 1要按排序后的順序循環(huán)序列的話

58、，使用 sorted() 函數(shù)，它不改動原序列，而是生成一個新的已排序的序列：>>> basket = 'apple', 'orange', 'apple', 'pear', 'orange', 'banana'>>> for f in sorted(set(basket):print fapplebananaorangepear字典只能使用不可變的對象（例如字符串）來作為字典的鍵，但可以把可變或者不可變的對象作為字典的值?；旧蟻碚f，你應該使用簡單的對象作為鍵。

59、如：d = key1:value1,key2:value2,鍵值對是沒有順序的。序列是以連續(xù)的整數(shù)為索引，與此不同的是，字典以關鍵字為索引，關鍵字可以是任意不可變類型，通常用字符串或數(shù)值。如果元組中只包含字符串和數(shù)字，它可以做為關鍵字，如果它直接或間接的包含了可變對象，就不能當做關鍵字。不能用列表做關鍵字，因為鏈表可以用索引、切割或者 append()和extend() 等方法改變?？梢园炎值淇醋鰺o序的“鍵值”對（key:value pairs）集合，鍵必須是互不相同的。一對大括號創(chuàng)建一個空的字典： 。字典的主要操作是依據(jù)鍵來存儲和析取值。也可以用del 來刪除“鍵值”對（key:value）

60、。如果你用一個已經(jīng)存在的關鍵字存儲值，以前為該關鍵字分配的值就會被遺忘。試圖從一個不存在的鍵中取值會導致錯誤，但可以為一個不存在的鍵賦值。字典的keys()方法返回由所有關鍵字組成的列表，該列表的順序不定（如果你需要它有序，只能調(diào)用關鍵字鏈表的sort()方法）。可以用 in 關鍵字檢查字典中是否存在某一關鍵字。這里有個字典用法的小例子：>>> tel = 'jack': 4098, 'sape': 4139>>> tel'guido' = 4127>>> tel'sape':

61、 4139, 'guido': 4127, 'jack': 4098>>> tel'jack'4098>>> del tel'sape'>>> tel'irv' = 4127>>> tel'guido': 4127, 'irv': 4127, 'jack': 4098>>> tel.keys()'guido', 'irv', 'jack&#

62、39;>>> 'guido' in telTrue創(chuàng)建字典：如果可以事先拼出整個字典，這種方法就很簡單：>>> d = 如果需要第一次動態(tài)建立字典的一個字段，第二種比較合適：>>> d'name' = 'wisdom'>>> d'age' = 45第三種關鍵字形式所需的代碼是比較少，但必須都是字符節(jié)才行：>>> dict(name='wisdom',age=45)'age': 45, 'name'

63、;: 'wisdom'如果需要在程序運行時把鍵和值逐步建成序列：>>> dict('name','wisdom'),('age',45)'age': 45, 'name': 'wisdom'字典方法舉例：clear方法，清除字典中所有的項，這是個原地操作所以無返回值（或者說返回None），例一：>>> x = >>> y = x>>> x'key' = 'value'>>

64、;> y'key': 'value'>>> x = >>> y'key': 'value'例二：>>> x = >>> y = x>>> x'key' = 'value'>>> y'key': 'value'>>> x.clear()>>> y在兩個例子中，x和y最初對應同一個字典，在一中，通過將x關聯(lián)到一個新的空字典來

65、“清除”它，這對于y沒有任何影響，y仍然關聯(lián)到原先的字典。這可能是所需要的行為，但是如果真的想要清空原始字典中所有的元素，必須使用clear方法。正如例二中看到的，y隨后也被清空了。copy方法，返回一個具有相同鍵-值對的新字典（這個方法實現(xiàn)的是淺復制（shallow copy），因為值本身就是相同的，而不是副本）：>>> x = 'username':'admin','machines':'foo','bar','baz'>>> y = x.copy()>

66、>> y'username' = 'mln'>>> y'machines'.remove('bar')>>> y'username': 'mln', 'machines': 'foo', 'baz'>>> x'username': 'admin', 'machines': 'foo', 'baz'可以看到，當

67、在副本中替換值得時候，原始字典不受影響，但是，如果修改了某個值（原地修改，而不是替換），原始的字典也會改變，因為同樣的值也存儲在原字典中。避免這個問題的一種方法就是使用深復制（deep copy），復制其包含的所有的值。可以使用copy模塊的deepcopy函數(shù)來完成操作。>>> from copy import deepcopy>>> d = >>> d'names' = 'Alfred','Bertrand'>>> c = d.copy()>>> dc

68、= deepcopy(d)>>> d'names'.append('Clirc')>>> c'names': 'Alfred', 'Bertrand', 'Clirc'>>> d'names': 'Alfred', 'Bertrand', 'Clirc'>>> dc'names': 'Alfred', 'Bertrand

69、9;fromkeys方法，使用給定的鍵建立新的字典，每個鍵默認對應的值為None：>>> .fromkeys('name','age')'age': None, 'name': None也可以直接在所有字典的類型dict上面調(diào)用方法：>>> dict.fromkeys('name','age')'age': None, 'name': None如果不想使用None作為默認參數(shù)，也可以自己提供默認值：>>> dict

70、.fromkeys('name','age','unknown')'age': '(unknown)', 'name': 'unknown'get方法，使用get訪問一個不存在的鍵時，沒有任何異常，而得到了None值。還可以自定義默認值，替換None：>>> d = >>> print d.get('name')None>>> print d.get('name','a')a>

71、>> print d.get('name','ann')ann>>> d # get方法并沒有創(chuàng)建鍵-值如果鍵存在，get用起來就像普通的字典查詢一樣：>>> d'name' = 'Dick'>>> d.get('name')'Dick'setdefault方法，類似get，能夠獲得與給定鍵相關聯(lián)的值，除此之外，setdefault還能在字典中不含有給定鍵的情況下設定相應的鍵-值，并相應的更新字典，默認值為None：>>&

72、gt; d = >>> d.setdefault('name')>>> d'name': None #默認值為None>>> d.setdefault('name','N')>>> d'name': None #說明通過setdefault不能為已存在的鍵改變值>>> d.setdefault('tt','N')'N' #為不存在的鍵設置值>>> d'tt': 'N', 'name&