Python 3 學習筆記2

教程連接：http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000

高級特性

切片

取一個list或tuple的部分元素是很是常見的操做。好比，一個list以下：

>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']

取前3個元素，應該怎麼作？

笨辦法：

>>> [L[0], L[1], L[2]]
['Michael', 'Sarah', 'Tracy']

之因此是笨辦法是由於擴展一下，取前N個元素就沒轍了。

取前N個元素，也就是索引爲0-(N-1)的元素，能夠用循環：

>>> r = []
>>> n = 3
>>> for i in range(n):
...     r.append(L[i])
... 
>>> r
['Michael', 'Sarah', 'Tracy']

對這種常常取指定索引範圍的操做，用循環十分繁瑣，所以，Python提供了切片（Slice）操做符，能大大簡化這種操做。

對應上面的問題，取前3個元素，用一行代碼就能夠完成切片：

>>> L[0:3]
['Michael', 'Sarah', 'Tracy']

L[0:3]表示，從索引0開始取，直到索引3爲止，但不包括索引3。即索引0，1，2，正好是3個元素。

若是第一個索引是0，還能夠省略：

>>> L[:3]
['Michael', 'Sarah', 'Tracy']

也能夠從索引1開始，取出2個元素出來：

>>> L[1:3]
['Sarah', 'Tracy']

相似的，既然Python支持L[-1]取倒數第一個元素，那麼它一樣支持倒數切片，試試：

>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1]
['Bob']

記住倒數第一個元素的索引是-1。

切片操做十分有用。咱們先建立一個0-99的數列：

>>> L = list(range(100))
>>> L
[0, 1, 2, 3, ..., 99]

能夠經過切片輕鬆取出某一段數列。好比前10個數：

>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

後10個數：

>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

前11-20個數：

>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

前10個數，每兩個取一個：

>>> L[:10:2]
[0, 2, 4, 6, 8]

全部數，每5個取一個：

>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

甚至什麼都不寫，只寫[:]就能夠原樣複製一個list：

>>> L[:]
[0, 1, 2, 3, ..., 99]

tuple也是一種list，惟一區別是tuple不可變。所以，tuple也能夠用切片操做，只是操做的結果還是tuple：

>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)

字符串'xxx'也能夠當作是一種list，每一個元素就是一個字符。所以，字符串也能夠用切片操做，只是操做結果還是字符串：

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

在不少編程語言中，針對字符串提供了不少各類截取函數（例如，substring），其實目的就是對字符串切片。Python沒有針對字符串的截取函數，只須要切片一個操做就能夠完成，很是簡單。

小結

有了切片操做，不少地方循環就再也不須要了。Python的切片很是靈活，一行代碼就能夠實現不少行循環才能完成的操做。

L=list(range(10))
# L中的元素是0-9
一、L[n1:n2:n3]
n1表明開始元素下標
n2表明結束元素下標
n3表明切片間隔以及切片方向
L中每一個元素都有正負兩種下標，例如L[0]和L[-10]指的同一個元素都是0
二、L[::1]與L[::-1]
在L[::1]中n1是0(-10)，n2是9(-1)
在L[::-1]中n1是9(-1),n2是0(-10)
三、L[-1:1]是多少？
答案是[]，由於L[-1:1]的徹底表示方式是L[-1:1:1],翻譯出來就是
：從下標爲-1的元素開始，以正方向切片到下標爲1的元素。可是python從下標爲-1的元素以正方向切片到列表結束也沒有發現下標爲1的元素，那麼L[-1:1]的計算結果就是[].
四、L[-1:1:-1]是多少？
答案是[9, 8, 7, 6, 5, 4, 3, 2]，python將這個表達式解釋爲：
從下標爲-1的元素開始，以反方向切片到下標爲1的元素。那麼ok，python能夠找到這一段子序列，結果就是[9, 8, 7, 6, 5, 4, 3, 2]

例子：

L = [1,2,3,4,5,6,7,8,9]
print(L[::1])#------>[1, 2, 3, 4, 5, 6, 7, 8, 9]
print(L[:8:1])#----->[1, 2, 3, 4, 5, 6, 7, 8]
print(L[:9:1])#----->[1, 2, 3, 4, 5, 6, 7, 8, 9]
print(L[:15:1])#---->[1, 2, 3, 4, 5, 6, 7, 8, 9] ,即便超出遊標也不影響
print(L[-2::1])#---->[8, 9]
print(L[-2::-1])#--->[8, 7, 6, 5, 4, 3, 2, 1]
print(L[-2:0:-1])#-->[8, 7, 6, 5, 4, 3, 2] 
print(L[-2:0:-2])#-->[8, 6, 4, 2]
print(L[-2:4:-2])#-->[8, 6]
print(L[-2:4:-1])#-->[8, 7, 6]
print(L[-2:4])#----->[]

說明：

1.sequence[a:b]輸出下標a到b-1的序列

（例子：L = [1,2,3,4,5,6,7,8,9]

L[0:9]#-->[1, 2, 3, 4, 5, 6, 7, 8, 9]

L[1:9]#-->[2, 3, 4, 5, 6, 7, 8, 9]

若是是倒序，例如：[-2:0:-1]，是從倒數第2（沒有-0位）個開始

L[-2:0:-1]#-->[8, 7, 6, 5, 4, 3, 2] ）

2.sequence[:b]輸出從開使下標0到b-1的序列

3.sequence[::-1]翻轉操做.

4.sequence[::2]隔一個取一個

注:sequence的下標: 從0  1  2  3......(n-3)  (n-2)  (n-1)

                                對應:(-n)  -(n-1)  -(n-2)  ......... -3  -2  -1

迭代

若是給定一個list或tuple，咱們能夠經過for循環來遍歷這個list或tuple，這種遍歷咱們稱爲迭代（Iteration）。

在Python中，迭代是經過for ... in來完成的，而不少語言好比C或者Java，迭代list是經過下標完成的，好比Java代碼：

for (i=0; i<list.length; i++) {
    n = list[i];
}

能夠看出，Python的for循環抽象程度要高於Java的for循環，由於Python的for循環不只能夠用在list或tuple上，還能夠做用在其餘可迭代對象上。

list這種數據類型雖然有下標，但不少其餘數據類型是沒有下標的，可是，只要是可迭代對象，不管有無下標，均可以迭代，好比dict就能夠迭代：

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
c
b

由於dict的存儲不是按照list的方式順序排列，因此，迭代出的結果順序極可能不同。

默認狀況下，dict迭代的是key。若是要迭代value，能夠用for value in d.values()，若是要同時迭代key和value，能夠用for k, v in d.items()。

因爲字符串也是可迭代對象，所以，也能夠做用於for循環：

>>> for ch in 'ABC':
...     print(ch)
...
A
B
C

因此，當咱們使用for循環時，只要做用於一個可迭代對象，for循環就能夠正常運行，而咱們不太關心該對象到底是list仍是其餘數據類型。

那麼，如何判斷一個對象是可迭代對象呢？方法是經過collections模塊的Iterable類型判斷：

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整數是否可迭代
False

最後一個小問題，若是要對list實現相似Java那樣的下標循環怎麼辦？Python內置的enumerate函數能夠把一個list變成索引-元素對，這樣就能夠在for循環中同時迭代索引和元素自己：

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

上面的for循環裏，同時引用了兩個變量，在Python裏是很常見的，好比下面的代碼：

>>> for x, y in [(1, 1), (2, 4), (3, 9)]:
...     print(x, y)
...
1 1
2 4
3 9

小結

任何可迭代對象均可以做用於for循環，包括咱們自定義的數據類型，只要符合迭代條件，就可使用for循環。

列表生成式

列表生成式即List Comprehensions，是Python內置的很是簡單卻強大的能夠用來建立list的生成式。

舉個例子，要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]能夠用list(range(1, 11))：

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

但若是要生成[1x1, 2x2, 3x3, ..., 10x10]怎麼作？方法一是循環：

>>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
...
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

可是循環太繁瑣，而列表生成式則能夠用一行語句代替循環生成上面的list：

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

寫列表生成式時，把要生成的元素x * x放到前面，後面跟for循環，就能夠把list建立出來，十分有用，多寫幾回，很快就能夠熟悉這種語法。

for循環後面還能夠加上if判斷，這樣咱們就能夠篩選出僅偶數的平方：

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

還可使用兩層循環，能夠生成全排列：

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

三層和三層以上的循環就不多用到了。

運用列表生成式，能夠寫出很是簡潔的代碼。例如，列出當前目錄下的全部文件和目錄名，能夠經過一行代碼實現：

>>> import os # 導入os模塊，模塊的概念後面講到
>>> [d for d in os.listdir('.')] # os.listdir能夠列出文件和目錄
['.emacs.d', '.ssh', '.Trash', 'Adlm', 'Applications', 'Desktop', 'Documents', 'Downloads', 'Library', 'Movies', 'Music', 'Pictures', 'Public', 'VirtualBox VMs', 'Workspace', 'XCode']

for循環其實能夠同時使用兩個甚至多個變量，好比dict的items()能夠同時迭代key和value：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> for k, v in d.items():
...     print(k, '=', v)
...
y = B
x = A
z = C

所以，列表生成式也可使用兩個變量來生成list：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

最後把一個list中全部的字符串變成小寫：

>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

練習

若是list中既包含字符串，又包含整數，因爲非字符串類型沒有lower()方法，因此列表生成式會報錯：

>>> L = ['Hello', 'World', 18, 'Apple', None]
>>> [s.lower() for s in L]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <listcomp>
AttributeError: 'int' object has no attribute 'lower'

使用內建的isinstance函數能夠判斷一個變量是否是字符串：

>>> x = 'abc'
>>> y = 123
>>> isinstance(x, str)
True
>>> isinstance(y, str)
False

純輸出小寫字符串答案：

L1 = ['Hello', 'World', 18, 'Apple', None]
L2 = [x.lower() for x in L1 if isinstance(x,str)]
print(L2)

混合輸出小寫字符串（非字符串也輸出）答案：

L1 = ['Hello', 'World', 18, 'Apple', None]
L2 = [x.lower() if isinstance(x,str) else x for x in L1]
print(L2)

上面使用了三目運算符：

true_part if condition else false_part

http://wangye.org/blog/archives/690/

生成器

經過列表生成式，咱們能夠直接建立一個列表。可是，受到內存限制，列表容量確定是有限的。並且，建立一個包含100萬個元素的列表，不只佔用很大的存儲空間，若是咱們僅僅須要訪問前面幾個元素，那後面絕大多數元素佔用的空間都白白浪費了。

因此，若是列表元素能夠按照某種算法推算出來，那咱們是否能夠在循環的過程當中不斷推算出後續的元素呢？這樣就沒必要建立完整的list，從而節省大量的空間。在Python中，這種一邊循環一邊計算的機制，稱爲生成器：generator。

要建立一個generator，有不少種方法。第一種方法很簡單，只要把一個列表生成式的[]改爲()，就建立了一個generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

建立L和g的區別僅在於最外層的[]和()，L是一個list，而g是一個generator。

咱們能夠直接打印出list的每個元素，但咱們怎麼打印出generator的每個元素呢？

若是要一個一個打印出來，能夠經過next()函數得到generator的下一個返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

咱們講過，generator保存的是算法，每次調用next(g)，就計算出g的下一個元素的值，直到計算到最後一個元素，沒有更多的元素時，拋出StopIteration的錯誤。

固然，上面這種不斷調用next(g)實在是太變態了，正確的方法是使用for循環，由於generator也是可迭代對象：

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4
9
16
25
36
49
64
81

因此，咱們建立了一個generator後，基本上永遠不會調用next()，而是經過for循環來迭代它，而且不須要關心StopIteration的錯誤。

generator很是強大。若是推算的算法比較複雜，用相似列表生成式的for循環沒法實現的時候，還能夠用函數來實現。

好比，著名的斐波拉契數列（Fibonacci），除第一個和第二個數外，任意一個數均可由前兩個數相加獲得：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契數列用列表生成式寫不出來，可是，用函數把它打印出來卻很容易：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

注意，賦值語句：

a, b = b, a + b

至關於：

t = (b, a + b) # t是一個tuple
a = t[0]
b = t[1]

但沒必要顯式寫出臨時變量t就能夠賦值。

上面的函數能夠輸出斐波那契數列的前N個數：

>>> fib(6)
1
1
2
3
5
8
'done'

仔細觀察，能夠看出，fib函數其實是定義了斐波拉契數列的推算規則，能夠從第一個元素開始，推算出後續任意的元素，這種邏輯其實很是相似generator。

也就是說，上面的函數和generator僅一步之遙。要把fib函數變成generator，只須要把print(b)改成yield b就能夠了：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

這就是定義generator的另外一種方法。若是一個函數定義中包含yield關鍵字，那麼這個函數就再也不是一個普通函數，而是一個generator：

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

這裏，最難理解的就是generator和函數的執行流程不同。函數是順序執行，遇到return語句或者最後一行函數語句就返回。而變成generator的函數，在每次調用next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。

舉個簡單的例子，定義一個generator，依次返回數字1，3，5：

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

調用該generator時，首先要生成一個generator對象，而後用next()函數不斷得到下一個返回值：

>>> o = odd()
>>> next(o)
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

能夠看到，odd不是普通函數，而是generator，在執行過程當中，遇到yield就中斷，下次又繼續執行。執行3次yield後，已經沒有yield能夠執行了，因此，第4次調用next(o)就報錯。

回到fib的例子，咱們在循環過程當中不斷調用yield，就會不斷中斷。固然要給循環設置一個條件來退出循環，否則就會產生一個無限數列出來。

一樣的，把函數改爲generator後，咱們基本上歷來不會用next()來獲取下一個返回值，而是直接使用for循環來迭代：

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

可是用for循環調用generator時，發現拿不到generator的return語句的返回值。若是想要拿到返回值，必須捕獲StopIteration錯誤，返回值包含在StopIteration的value中：

>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

關於如何捕獲錯誤，後面的錯誤處理還會詳細講解。

練習

楊輝三角定義以下：

          1
        1   1
      1   2   1
    1   3   3   1
  1   4   6   4   1
1   5   10  10  5   1

把每一行看作一個list，試寫一個generator，不斷輸出下一行的list：

答案：

def triangles():
    L = [1]
    while True:
        yield L
        L.append(0)
        L = [L[i - 1] + L[i] for i in range(len(L))]


n = 0
for t in triangles():
    print(t)
    n = n + 1
    if n == 10:
        break

 解析：

楊輝三角/帕斯卡三角形

        1
       1 1
      1 2 1
     1 3 3 1
    1 4 6 4 1
   . . . . . .

雖然看着挺漂亮，但對解題沒有卵幫助。 因而我從右邊猛推了它一把 <---大力猛推。 伴隨着一聲'啊呦'，楊輝三角形一屁股坐進了我精心設計好的牆角里。

row
0    1
1    1 1
2    1 2 1
3    1 3 3 1
4    1 4 6 4 1
------------------
col  0 1 2 3 4

據說，下雨天，笛卡爾座標系(碼農版)和帕斯卡三角形更配哦~ 【某芙廣告部請聯絡我，洽談代言事宜！】

這不是巧了麼？我能夠用T(row,col)來表明楊輝三角形中的每個元素對不對？ 而後你們能夠發現以下幾個事實: 1.col==0 的這一列上的元素老是 1 ， 例如T(0,0),T(1,0),T(4,0) 2.col==row 的這一列上的元素老是 1, 例如 T(0,0),T(1,1),T(4,4) 3.(敲黑板,重點) T(row,col)上的元素等於 T(row-1,col-1)+T(row-1,col)， 例如 T(4,3) == T(3,2)+T(3,3) 即 4 == 3 + 1 例如 T(4,2) == T(3,1)+T(3,2) 即 6 == 3 + 3 雖然講得頗有道理的樣子，然而機智的小夥伴們仍是一眼就看出了破綻。 介紹事實3時候，爲何不拿T(0,0),T(1,0)，T(1,1)這樣的元素舉例？ 按個人分析 T(0,0) == T(-1,-1)+T(-1,0) ,這不翻車了麼。媽蛋的，確實翻車了！

def triangles():
    L = [1] #因此在這個解法裏，做者很機智，直接給第0行初始化一個[1]
    while True:
        yield L  # 生成第0行，問題解決。
        。。。

咱們再來看看第1行的狀況， T(1,0) == T(0,-1)+T(0,0) ,T(0,0)是1，T(0,-1)不存在。 T(1,1) == T(0,0)+T(0,1) ,T(0,0)是1，T(0,1)不存在 根據事實1，事實2 咱們知道T(1,0)和T(1,1)都是1,將已知量帶入咱們的式子. 1 = x+1 得x=0 1 = 1+x 得x=0 發現了沒有，要想讓這個算法進行下去，第0行元素命格不行【八字欠零，五行(xing2)缺零】，一共缺了先後兩個零。

#在假想的狀況下，第0行若是能像圖中這樣補上兩個0，那麼生成第1行的時候就輕鬆愉快了。
#上邊咱們分析過了生成第1行須要的T(0,-1)和T(0,1),如今已經到貨.
r
0 [0 1 0]
1    1 1
2    1 2 1
3    1 3 3 1
4    1 4 6 4 1
------------------
c -1 0 1 2 3 4

那就這樣定了，給第0行補0.

def triangles():
    L = [1]
    while True:
        yield L
        L.append(0) #做者真的給上一行補了0，但是爲何只補了一個0？
        L = [L[i - 1] + L[i] for i in range(len(L))] #生成第1行

這裏真的是巧合了！！！ 學習切片的時候，廖大說過列表倒數第一個元素的索引是-1。 因此，咱們在上圖裏看到的T(0,-1),在python列表裏是繞到後邊去了。 天然界裏的列表[0,1,0],各元素索引依次爲 -1,0,1 python裏的列表[1,0],各元素索引依次爲0,1/-1,就像一個環，兩端粘在了一塊兒。

看代碼
def triangles():
    L = [1]
    while True:
        yield L
        L.append(0) #補完0後L的狀態 [1,0] 
        L = [L[i - 1] + L[i] for i in range(len(L))] #生成第1行

已知 L:[1,0] ,len(L):2 ,range(0,2)不包含2
列表生成式[L[i - 1] + L[i] for i in range(len(L))]會生成什麼鬼？
當i=0時 L[i-1]+L[i] == 0+1 == 1
當i=1時 L[i-1]+L[i] == 1+0 == 1
因此這個列表生成式最終生成了 [1,1],而後將它賦給L。而後yield L.

而後生成第2行：

def triangles():
    L = [1]
    while True:
        yield L #生成第2行時的開局狀態，L:[1,1]
        L.append(0) #補0，[1,1,0]
        L = [L[i - 1] + L[i] for i in range(len(L))] #生成第2行

而後生成第3行。 而後生成第n行。。。

迭代器

咱們已經知道，能夠直接做用於for循環的數據類型有如下幾種：

一類是集合數據類型，如list、tuple、dict、set、str等；

一類是generator，包括生成器和帶yield的generator function。

這些能夠直接做用於for循環的對象統稱爲可迭代對象：Iterable。

可使用isinstance()判斷一個對象是不是Iterable對象：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

而生成器不但能夠做用於for循環，還能夠被next()函數不斷調用並返回下一個值，直到最後拋出StopIteration錯誤表示沒法繼續返回下一個值了。

能夠被next()函數調用並不斷返回下一個值的對象稱爲迭代器：Iterator。

可使用isinstance()判斷一個對象是不是Iterator對象：

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

生成器都是Iterator對象，但list、dict、str雖然是Iterable，卻不是Iterator。

把list、dict、str等Iterable變成Iterator可使用iter()函數：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

你可能會問，爲何list、dict、str等數據類型不是Iterator？

這是由於Python的Iterator對象表示的是一個數據流，Iterator對象能夠被next()函數調用並不斷返回下一個數據，直到沒有數據時拋出StopIteration錯誤。能夠把這個數據流看作是一個有序序列，但咱們卻不能提早知道序列的長度，只能不斷經過next()函數實現按需計算下一個數據，因此Iterator的計算是惰性的，只有在須要返回下一個數據時它纔會計算。

Iterator甚至能夠表示一個無限大的數據流，例如全體天然數。而使用list是永遠不可能存儲全體天然數的。

小結

凡是可做用於for循環的對象都是Iterable類型；

凡是可做用於next()函數的對象都是Iterator類型，它們表示一個惰性計算的序列；

集合數據類型如list、dict、str等是Iterable但不是Iterator，不過能夠經過iter()函數得到一個Iterator對象。

Python的for循環本質上就是經過不斷調用next()函數實現的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

實際上徹底等價於：

# 首先得到Iterator對象:
it = iter([1, 2, 3, 4, 5])
# 循環:
while True:
    try:
        # 得到下一個值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循環
        break

高階函數

高階函數英文叫Higher-order function。什麼是高階函數？咱們以實際代碼爲例子，一步一步深刻概念。

變量能夠指向函數

以Python內置的求絕對值的函數abs()爲例，調用該函數用如下代碼：

>>> abs(-10)
10

可是，若是隻寫abs呢？

>>> abs
<built-in function abs>

可見，abs(-10)是函數調用，而abs是函數自己。

要得到函數調用結果，咱們能夠把結果賦值給變量：

>>> x = abs(-10)
>>> x
10

可是，若是把函數自己賦值給變量呢？

>>> f = abs
>>> f
<built-in function abs>

結論：函數自己也能夠賦值給變量，即：變量能夠指向函數。

若是一個變量指向了一個函數，那麼，能否經過該變量來調用這個函數？用代碼驗證一下：

>>> f = abs
>>> f(-10)
10

成功！說明變量f如今已經指向了abs函數自己。直接調用abs()函數和調用變量f()徹底相同。

函數名也是變量

那麼函數名是什麼呢？函數名其實就是指向函數的變量！對於abs()這個函數，徹底能夠把函數名abs當作變量，它指向一個能夠計算絕對值的函數！

若是把abs指向其餘對象，會有什麼狀況發生？

>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

把abs指向10後，就沒法經過abs(-10)調用該函數了！由於abs這個變量已經不指向求絕對值函數而是指向一個整數10！

固然實際代碼絕對不能這麼寫，這裏是爲了說明函數名也是變量。要恢復abs函數，請重啓Python交互環境。

注：因爲abs函數其實是定義在import builtins模塊中的，因此要讓修改abs變量的指向在其它模塊也生效，要用import builtins; builtins.abs = 10。

傳入函數

既然變量能夠指向函數，函數的參數能接收變量，那麼一個函數就能夠接收另外一個函數做爲參數，這種函數就稱之爲高階函數。

一個最簡單的高階函數：

def add(x, y, f):
    return f(x) + f(y)

當咱們調用add(-5, 6, abs)時，參數x，y和f分別接收-5，6和abs，根據函數定義，咱們能夠推導計算過程爲：

x = -5
y = 6
f = abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 11
return 11

用代碼驗證一下：

>>> add(-5, 6, abs)
11

編寫高階函數，就是讓函數的參數可以接收別的函數。

小結

把函數做爲參數傳入，這樣的函數稱爲高階函數，函數式編程就是指這種高度抽象的編程範式。

 

map/reduce

Python內建了map()和reduce()函數。

若是你讀過Google的那篇大名鼎鼎的論文「MapReduce: Simplified Data Processing on Large Clusters」，你就能大概明白map/reduce的概念。

咱們先看map。map()函數接收兩個參數，一個是函數，一個是Iterable，map將傳入的函數依次做用到序列的每一個元素，並把結果做爲新的Iterator返回。

舉例說明，好比咱們有一個函數f(x)=x2，要把這個函數做用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就能夠用map()實現以下：

如今，咱們用Python代碼實現：

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

map()傳入的第一個參數是f，即函數對象自己。因爲結果r是一個Iterator，Iterator是惰性序列，所以經過list()函數讓它把整個序列都計算出來並返回一個list。

你可能會想，不須要map()函數，寫一個循環，也能夠計算出結果：

L = []
for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
    L.append(f(n))
print(L)

的確能夠，可是，從上面的循環代碼，能一眼看明白「把f(x)做用在list的每個元素並把結果生成一個新的list」嗎？

因此，map()做爲高階函數，事實上它把運算規則抽象了，所以，咱們不但能夠計算簡單的f(x)=x2，還能夠計算任意複雜的函數，好比，把這個list全部數字轉爲字符串：

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

只須要一行代碼。

再看reduce的用法。reduce把一個函數做用在一個序列[x1, x2, x3, ...]上，這個函數必須接收兩個參數，reduce把結果繼續和序列的下一個元素作累積計算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方說對一個序列求和，就能夠用reduce實現：

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

固然求和運算能夠直接用Python內建函數sum()，不必動用reduce。

可是若是要把序列[1, 3, 5, 7, 9]變換成整數13579，reduce就能夠派上用場：

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

這個例子自己沒多大用處，可是，若是考慮到字符串str也是一個序列，對上面的例子稍加改動，配合map()，咱們就能夠寫出把str轉換爲int的函數：

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> def char2num(s):
...     return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
...
>>> reduce(fn, map(char2num, '13579'))
13579

整理成一個str2int的函數就是：

from functools import reduce

def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
    return reduce(fn, map(char2num, s))

還能夠用lambda函數進一步簡化成：

from functools import reduce

def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

也就是說，假設Python沒有提供int()函數，你徹底能夠本身寫一個把字符串轉化爲整數的函數，並且只須要幾行代碼！

lambda函數的用法在後面介紹。

練習

利用map()函數，把用戶輸入的不規範的英文名字，變爲首字母大寫，其餘小寫的規範名字。輸入：['adam', 'LISA', 'barT']，輸出：['Adam', 'Lisa', 'Bart']：

def normalize(name):
    new=""
    for n,x in enumerate(name):
        if n==0:
            new += x.upper()
        else:
            new += x.lower()
    return new

L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

Python提供的sum()函數能夠接受一個list並求和，請編寫一個prod()函數，能夠接受一個list並利用reduce()求積：

from functools import reduce

def prod(L):
    def fn(x,y):
        return x*y
    return reduce(fn,L)

print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))

利用map和reduce編寫一個str2float函數，把字符串'123.456'轉換成浮點數123.456：

若是不利用map和reduce,答案：

def str2num(s):
    return{'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[s]
def fn(x,n):
    num=1
    for i in range(n):
        num = x*num
    return num
def str2float(s):
    for n,x in enumerate(s):
        if x=='.':
            front = s[:n]
            end = s[n+1:]
            new = front + end
            return int(new)/fn(10,len(end))

都利用上map和reduce的答案：

from functools import reduce
def char2num(s):
    return {'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'0':0}[s]
def fn(x,n):
    num=1
    for i in range(n):
        num = x*num
    return num
def fn2(x,y):
    return x*10+y
def str2float(s):
    for n,x in enumerate(s):
        if x=='.':
            front=s[:n]
            end=s[n+1:]
            new=front+end
    return reduce(fn2,map(char2num,new))/fn(10,len(end))

print('str2float(\'123.456\') =', str2float('123.456'))

若是以上加上lambda使用：

from functools import reduce
def char2num(s):
    return {'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'0':0}[s]
def fn(x,n):
    num=1
    for i in range(n):
        num = x*num
    return num
def str2float(s):
    for n,x in enumerate(s):
        if x=='.':
            front=s[:n]
            end=s[n+1:]
            new=front+end
    return reduce(lambda x,y:x*10+y,map(char2num,new))/fn(10,len(end))
 
print('str2float(\'123.456\') =', str2float('123.456'))

lambda的使用方法：

http://www.cnblogs.com/evening/archive/2012/03/29/2423554.html

 

filter

Python內建的filter()函數用於過濾序列。

和map()相似，filter()也接收一個函數和一個序列。和map()不一樣的是，filter()把傳入的函數依次做用於每一個元素，而後根據返回值是True仍是False決定保留仍是丟棄該元素。

例如，在一個list中，刪掉偶數，只保留奇數，能夠這麼寫：

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 結果: [1, 5, 9, 15]

把一個序列中的空字符串刪掉，能夠這麼寫：

def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 結果: ['A', 'B', 'C']

可見用filter()這個高階函數，關鍵在於正確實現一個「篩選」函數。

注意到filter()函數返回的是一個Iterator，也就是一個惰性序列，因此要強迫filter()完成計算結果，須要用list()函數得到全部結果並返回list。

用filter求素數

計算素數的一個方法是埃氏篩法，它的算法理解起來很是簡單：

首先，列出從2開始的全部天然數，構造一個序列：

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取序列的第一個數2，它必定是素數，而後用2把序列的2的倍數篩掉：

3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取新序列的第一個數3，它必定是素數，而後用3把序列的3的倍數篩掉：

5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取新序列的第一個數5，而後用5把序列的5的倍數篩掉：

7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

不斷篩下去，就能夠獲得全部的素數。

用Python來實現這個算法，能夠先構造一個從3開始的奇數序列：

def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n

注意這是一個生成器，而且是一個無限序列。

而後定義一個篩選函數：

def _not_divisible(n):
    return lambda x: x % n > 0

最後，定義一個生成器，不斷返回下一個素數：

def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
        n = next(it) # 返回序列的第一個數
        yield n
        it = filter(_not_divisible(n), it) # 構造新序列

這個生成器先返回第一個素數2，而後，利用filter()不斷產生篩選後的新的序列。

因爲primes()也是一個無限序列，因此調用時須要設置一個退出循環的條件：

# 打印1000之內的素數:
for n in primes():
    if n < 1000:
        print(n)
    else:
        break

注意到Iterator是惰性計算的序列，因此咱們能夠用Python表示「全體天然數」，「全體素數」這樣的序列，而代碼很是簡潔。

練習

回數是指從左向右讀和從右向左讀都是同樣的數，例如12321，909。請利用filter()濾掉非回數：

答案：

def is_palindrome(n):
    s = str(n)
    return s==s[::-1]:
        
output = filter(is_palindrome, range(1, 1000))
print(list(output))

小結

filter()的做用是從一個序列中篩出符合條件的元素。因爲filter()使用了惰性計算，因此只有在取filter()結果的時候，纔會真正篩選並每次返回下一個篩出的元素。

sorted

排序算法

排序也是在程序中常常用到的算法。不管使用冒泡排序仍是快速排序，排序的核心是比較兩個元素的大小。若是是數字，咱們能夠直接比較，但若是是字符串或者兩個dict呢？直接比較數學上的大小是沒有意義的，所以，比較的過程必須經過函數抽象出來。

Python內置的sorted()函數就能夠對list進行排序：

>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]

此外，sorted()函數也是一個高階函數，它還能夠接收一個key函數來實現自定義的排序，例如按絕對值大小排序：

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

key指定的函數將做用於list的每個元素上，並根據key函數返回的結果進行排序。對比原始的list和通過key=abs處理過的list：

list = [36, 5, -12, 9, -21]

keys = [36, 5,  12, 9,  21]

而後sorted()函數按照keys進行排序，並按照對應關係返回list相應的元素：

keys排序結果 => [5, 9,  12,  21, 36]
                |  |    |    |   |
最終結果     => [5, 9, -12, -21, 36]

咱們再看一個字符串排序的例子：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']

默認狀況下，對字符串排序，是按照ASCII的大小比較的，因爲'Z' < 'a'，結果，大寫字母Z會排在小寫字母a的前面。

如今，咱們提出排序應該忽略大小寫，按照字母序排序。要實現這個算法，沒必要對現有代碼大加改動，只要咱們能用一個key函數把字符串映射爲忽略大小寫排序便可。忽略大小寫來比較兩個字符串，實際上就是先把字符串都變成大寫（或者都變成小寫），再比較。

這樣，咱們給sorted傳入key函數，便可實現忽略大小寫的排序：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']

要進行反向排序，沒必要改動key函數，能夠傳入第三個參數reverse=True：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

從上述例子能夠看出，高階函數的抽象能力是很是強大的，並且，核心代碼能夠保持得很是簡潔。

小結

sorted()也是一個高階函數。用sorted()排序的關鍵在於實現一個映射函數。

練習

假設咱們用一組tuple表示學生名字和成績：

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

1.請用sorted()對上述列表分別按名字排序：

2.再按成績從高到低排序：

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):
    return t[0]
def by_score(t):
    return t[1]

L1 = sorted(L,key=by_name)
L2 = sorted(L,key=by_score,reverse=True)

print(L1)
print(L2)

返回函數

函數做爲返回值

高階函數除了能夠接受函數做爲參數外，還能夠把函數做爲結果值返回。

咱們來實現一個可變參數的求和。一般狀況下，求和的函數是這樣定義的：

def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return ax

可是，若是不須要馬上求和，而是在後面的代碼中，根據須要再計算怎麼辦？能夠不返回求和的結果，而是返回求和的函數：

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

當咱們調用lazy_sum()時，返回的並非求和結果，而是求和函數：

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>

調用函數f時，才真正計算求和的結果：

>>> f()
25

在這個例子中，咱們在函數lazy_sum中又定義了函數sum，而且，內部函數sum能夠引用外部函數lazy_sum的參數和局部變量，當lazy_sum返回函數sum時，相關參數和變量都保存在返回的函數中，這種稱爲「閉包（Closure）」的程序結構擁有極大的威力。

請再注意一點，當咱們調用lazy_sum()時，每次調用都會返回一個新的函數，即便傳入相同的參數：

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False

f1()和f2()的調用結果互不影響。

閉包

注意到返回的函數在其定義內部引用了局部變量args，因此，當一個函數返回了一個函數後，其內部的局部變量還被新函數引用，因此，閉包用起來簡單，實現起來可不容易。

另外一個須要注意的問題是，返回的函數並無馬上執行，而是直到調用了f()才執行。咱們來看一個例子：

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count() #見註釋

在上面的例子中，每次循環，都建立了一個新的函數，而後，把建立的3個函數都返回了。

你可能認爲調用f1()，f2()和f3()結果應該是1，4，9，但實際結果是：

>>> f1()
9
>>> f2()
9
>>> f3()
9

所有都是9！緣由就在於返回的函數引用了變量i，但它並不是馬上執行。等到3個函數都返回時，它們所引用的變量i已經變成了3，所以最終結果爲9。

返回閉包時牢記的一點就是：返回函數不要引用任何循環變量，或者後續會發生變化的變量。

若是必定要引用循環變量怎麼辦？方法是再建立一個函數，用該函數的參數綁定循環變量當前的值，不管該循環變量後續如何更改，已綁定到函數參數的值不變：

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)馬上被執行，所以i的當前值被傳入f()
    return fs

再看看結果：

>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9

缺點是代碼較長，可利用lambda函數縮短代碼。

小結

一個函數能夠返回一個計算結果，也能夠返回一個函數。

返回一個函數時，牢記該函數並未執行，返回函數中不要引用任何可能會變化的變量。

註釋: 

f1,f2,f3 = count()

python 支持這種賦值方式

a,b,c=[1,2,3]

a,b,c=(1,2,3)

a,b,c=1,2,3

主要是python的賦值方式.前面的章節絕對沒有講解過.對小白的我產生了很大的困惑.

count函數運行完之後， fs = [f, f, f]

f1, f2, f3 = count() 至關於 [f1, f2, f3] = [f, f, f] 至關於 f1 = f f2 = f f3 = f f函數返回的是i的平方，i是3，因此返回9, 9, 9

匿名函數

當咱們在傳入函數時，有些時候，不須要顯式地定義函數，直接傳入匿名函數更方便。

在Python中，對匿名函數提供了有限支持。仍是以map()函數爲例，計算f(x)=x2時，除了定義一個f(x)的函數外，還能夠直接傳入匿名函數：

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

經過對比能夠看出，匿名函數lambda x: x * x實際上就是：

def f(x):
    return x * x

關鍵字lambda表示匿名函數，冒號前面的x表示函數參數。

匿名函數有個限制，就是隻能有一個表達式，不用寫return，返回值就是該表達式的結果。

用匿名函數有個好處，由於函數沒有名字，沒必要擔憂函數名衝突。此外，匿名函數也是一個函數對象，也能夠把匿名函數賦值給一個變量，再利用變量來調用該函數：

>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

一樣，也能夠把匿名函數做爲返回值返回，好比：

def build(x, y):
    return lambda: x * x + y * y

詳解：

#!/usr/bin/python
# -*- coding: utf-8 -*-

# 匿名函數lambda使用，上節中學習了 「返回函數」 這節學習了 「匿名函數」
# （1）、若是你定義一個有參數的函數，返回函數是一個無參函數，
# 那麼將定義的有參函數賦值給一個變量(賦值後變量指針指向函數，這時變量就是函數的別名)時，
# 須要轉遞參數，調用函數變量就等於執行函數體
# （2）、若是你定義一個無參數的函數，返回函數是一個有參函數，
# 那麼將定義的無參函數賦值給一個變量(賦值後變量指針指向函數，這時變量就是函數的別名)時，
# 不須要轉遞參數，調用函數變量時傳遞參數就等於執行函數體

# 返回函數
def build_return_func1(x, y):
    def g():
        return x**2 + y**2
    return g
# 返回lambda匿名函數
def build_return_lambda1(x, y):
    # 無參數lambda匿名函數
    return lambda: x ** 2 + y ** 2

# 有函數調用
f1 = build_return_func1(1, 2)
f2 = build_return_lambda1(2, 4)
print(f1())
print(f2())

 

5
20

 

# 返回函數
def build_return_func2():
    def g(x, y):
        return x**2 + y**2
    return g
# 返回lambda匿名函數
def build_return_lambda2():
    # 有參數lambda匿名函數
    return lambda x, y: x ** 2 + y ** 2

# 無函數調用
f3 = build_return_func2()
f4 = build_return_lambda2()
print(f3(1, 2))
print(f4(2, 4))

　　

5
20

 

小結

Python對匿名函數的支持有限，只有一些簡單的狀況下可使用匿名函數。

 

裝飾器

因爲函數也是一個對象，並且函數對象能夠被賦值給變量，因此，經過變量也能調用該函數。

>>> def now():
...     print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25

函數對象有一個__name__屬性，能夠拿到函數的名字：

>>> now.__name__
'now'
>>> f.__name__
'now'

如今，假設咱們要加強now()函數的功能，好比，在函數調用先後自動打印日誌，但又不但願修改now()函數的定義，這種在代碼運行期間動態增長功能的方式，稱之爲「裝飾器」（Decorator）。

本質上，decorator就是一個返回函數的高階函數。因此，咱們要定義一個能打印日誌的decorator，能夠定義以下：

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

觀察上面的log，由於它是一個decorator，因此接受一個函數做爲參數，並返回一個函數。咱們要藉助Python的@語法，把decorator置於函數的定義處：

@log
def now():
    print('2015-3-25')

調用now()函數，不只會運行now()函數自己，還會在運行now()函數前打印一行日誌：

>>> now()
call now():
2015-3-25

把@log放到now()函數的定義處，至關於執行了語句：

now = log(now)

因爲log()是一個decorator，返回一個函數，因此，原來的now()函數仍然存在，只是如今同名的now變量指向了新的函數，因而調用now()將執行新函數，即在log()函數中返回的wrapper()函數。

wrapper()函數的參數定義是(*args, **kw)，所以，wrapper()函數能夠接受任意參數的調用。在wrapper()函數內，首先打印日誌，再緊接着調用原始函數。

若是decorator自己須要傳入參數，那就須要編寫一個返回decorator的高階函數，寫出來會更復雜。好比，要自定義log的文本：

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

這個3層嵌套的decorator用法以下：

@log('execute')
def now():
    print('2015-3-25')

執行結果以下：

>>> now()
execute now():
2015-3-25

和兩層嵌套的decorator相比，3層嵌套的效果是這樣的：

>>> now = log('execute')(now)

咱們來剖析上面的語句，首先執行log('execute')，返回的是decorator函數，再調用返回的函數，參數是now函數，返回值最終是wrapper函數。

以上兩種decorator的定義都沒有問題，但還差最後一步。由於咱們講了函數也是對象，它有__name__等屬性，但你去看通過decorator裝飾以後的函數，它們的__name__已經從原來的'now'變成了'wrapper'：

>>> now.__name__
'wrapper'

由於返回的那個wrapper()函數名字就是'wrapper'，因此，須要把原始函數的__name__等屬性複製到wrapper()函數中，不然，有些依賴函數簽名的代碼執行就會出錯。

不須要編寫wrapper.__name__ = func.__name__這樣的代碼，Python內置的functools.wraps就是幹這個事的，因此，一個完整的decorator的寫法以下：

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

或者針對帶參數的decorator：

import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

import functools是導入functools模塊。模塊的概念稍候講解。如今，只需記住在定義wrapper()的前面加上@functools.wraps(func)便可。

小結

在面向對象（OOP）的設計模式中，decorator被稱爲裝飾模式。OOP的裝飾模式須要經過繼承和組合來實現，而Python除了能支持OOP的decorator外，直接從語法層次支持decorator。Python的decorator能夠用函數實現，也能夠用類實現。

decorator能夠加強函數的功能，定義起來雖然有點複雜，但使用起來很是靈活和方便。

1.請編寫一個decorator，能在函數調用的先後打印出'begin call'和'end call'的日誌。

2.再思考一下可否寫出一個@log的decorator，使它既支持：

@log
def f():
    pass

又支持：

@log('execute')
def f():
    pass

兩題混寫成一個答案：

def log(text=None):
    def decorator(func):
        def wrapper(*args, **kw):
            print('begin call')
            result = func(*args,**kw)
            print('%s %s();' % (text,func.__name__))
            print('begin call')
            return result
        return wrapper
    return decorator

@log('execute')
def now(x=5):
    return print(x ** 2)

now(7)

偏函數

Python的functools模塊提供了不少有用的功能，其中一個就是偏函數（Partial function）。要注意，這裏的偏函數和數學意義上的偏函數不同。

在介紹函數參數的時候，咱們講到，經過設定參數的默認值，能夠下降函數調用的難度。而偏函數也能夠作到這一點。舉例以下：

int()函數能夠把字符串轉換爲整數，當僅傳入字符串時，int()函數默認按十進制轉換：

>>> int('12345')
12345

但int()函數還提供額外的base參數，默認值爲10。若是傳入base參數，就能夠作N進制的轉換：

>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

假設要轉換大量的二進制字符串，每次都傳入int(x, base=2)很是麻煩，因而，咱們想到，能夠定義一個int2()的函數，默認把base=2傳進去：

def int2(x, base=2):
    return int(x, base)

這樣，咱們轉換二進制就很是方便了：

>>> int2('1000000')
64
>>> int2('1010101')
85

functools.partial就是幫助咱們建立一個偏函數的，不須要咱們本身定義int2()，能夠直接使用下面的代碼建立一個新的函數int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

因此，簡單總結functools.partial的做用就是，把一個函數的某些參數給固定住（也就是設置默認值），返回一個新的函數，調用這個新函數會更簡單。

注意到上面的新的int2函數，僅僅是把base參數從新設定默認值爲2，但也能夠在函數調用時傳入其餘值：

>>> int2('1000000', base=10)
1000000

最後，建立偏函數時，實際上能夠接收函數對象、*args和**kw這3個參數，當傳入：

int2 = functools.partial(int, base=2)

實際上固定了int()函數的關鍵字參數base，也就是：

int2('10010')

至關於：

kw = { 'base': 2 }
int('10010', **kw)

當傳入:

max2 = functools.partial(max, 10)

實際上會把10做爲*args的一部分自動加到左邊，也就是：

max2(5, 6, 7)

至關於：

args = (10, 5, 6, 7)
max(*args)

結果爲10。

小結

當函數的參數個數太多，須要簡化時，使用functools.partial能夠建立一個新的函數，這個新函數能夠固定住原函數的部分參數，從而在調用時更簡單。

 

使用模塊

Python自己就內置了不少很是有用的模塊，只要安裝完畢，這些模塊就能夠馬上使用。

咱們之內建的sys模塊爲例，編寫一個hello的模塊：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

' a test module '

__author__ = 'Michael Liao'

import sys

def test():
    args = sys.argv
    if len(args)==1:
            print('Hello, world!')
    elif len(args)==2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')

if __name__=='__main__':
    test()

第1行和第2行是標準註釋，第1行註釋可讓這個hello.py文件直接在Unix/Linux/Mac上運行，第2行註釋表示.py文件自己使用標準UTF-8編碼；

第4行是一個字符串，表示模塊的文檔註釋，任何模塊代碼的第一個字符串都被視爲模塊的文檔註釋；

第6行使用__author__變量把做者寫進去，這樣當你公開源代碼後別人就能夠瞻仰你的大名；

以上就是Python模塊的標準文件模板，固然也能夠所有刪掉不寫，可是，按標準辦事確定沒錯。

後面開始就是真正的代碼部分。

你可能注意到了，使用sys模塊的第一步，就是導入該模塊：

import sys

導入sys模塊後，咱們就有了變量sys指向該模塊，利用sys這個變量，就能夠訪問sys模塊的全部功能。

sys模塊有一個argv變量，用list存儲了命令行的全部參數。argv至少有一個元素，由於第一個參數永遠是該.py文件的名稱，例如：

運行python3 hello.py得到的sys.argv就是['hello.py']；

運行python3 hello.py Michael得到的sys.argv就是['hello.py', 'Michael]。

最後，注意到這兩行代碼：

if __name__=='__main__':
    test()

當咱們在命令行運行hello模塊文件時，Python解釋器把一個特殊變量__name__置爲__main__，而若是在其餘地方導入該hello模塊時，if判斷將失敗，所以，這種if測試可讓一個模塊經過命令行運行時執行一些額外的代碼，最多見的就是運行測試。

咱們能夠用命令行運行hello.py看看效果：

$ python3 hello.py
Hello, world!
$ python hello.py Michael
Hello, Michael!

若是啓動Python交互環境，再導入hello模塊：

$ python3
Python 3.4.3 (v3.4.3:9b73f1c3e601, Feb 23 2015, 02:52:03) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import hello
>>>

導入時，沒有打印Hello, word!，由於沒有執行test()函數。

調用hello.test()時，才能打印出Hello, word!：

>>> hello.test()
Hello, world!

做用域

在一個模塊中，咱們可能會定義不少函數和變量，但有的函數和變量咱們但願給別人使用，有的函數和變量咱們但願僅僅在模塊內部使用。在Python中，是經過_前綴來實現的。

正常的函數和變量名是公開的（public），能夠被直接引用，好比：abc，x123，PI等；

相似__xxx__這樣的變量是特殊變量，能夠被直接引用，可是有特殊用途，好比上面的__author__，__name__就是特殊變量，hello模塊定義的文檔註釋也能夠用特殊變量__doc__訪問，咱們本身的變量通常不要用這種變量名；

相似_xxx和__xxx這樣的函數或變量就是非公開的（private），不該該被直接引用，好比_abc，__abc等；

之因此咱們說，private函數和變量「不該該」被直接引用，而不是「不能」被直接引用，是由於Python並無一種方法能夠徹底限制訪問private函數或變量，可是，從編程習慣上不該該引用private函數或變量。

private函數或變量不該該被別人引用，那它們有什麼用呢？請看例子：

def _private_1(name):
    return 'Hello, %s' % name

def _private_2(name):
    return 'Hi, %s' % name

def greeting(name):
    if len(name) > 3:
        return _private_1(name)
    else:
        return _private_2(name)

咱們在模塊裏公開greeting()函數，而把內部邏輯用private函數隱藏起來了，這樣，調用greeting()函數不用關心內部的private函數細節，這也是一種很是有用的代碼封裝和抽象的方法，即：

外部不須要引用的函數所有定義成private，只有外部須要引用的函數才定義爲public。

__name__ = '__main__' 的做用解釋：

http://www.jb51.net/article/51892.htm

 

安裝第三方模塊

在Python中，安裝第三方模塊，是經過包管理工具pip完成的。

若是你正在使用Mac或Linux，安裝pip自己這個步驟就能夠跳過了。

若是你正在使用Windows，請參考安裝Python一節的內容，確保安裝時勾選了pip和Add python.exe to Path。

在命令提示符窗口下嘗試運行pip，若是Windows提示未找到命令，能夠從新運行安裝程序添加pip。

注意：Mac或Linux上有可能並存Python 3.x和Python 2.x，所以對應的pip命令是pip3。

如今，讓咱們來安裝一個第三方庫——Python Imaging Library，這是Python下很是強大的處理圖像的工具庫。不過，PIL目前只支持到Python 2.7，而且有年頭沒有更新了，所以，基於PIL的Pillow項目開發很是活躍，而且支持最新的Python 3。

通常來講，第三方庫都會在Python官方的pypi.python.org網站註冊，要安裝一個第三方庫，必須先知道該庫的名稱，能夠在官網或者pypi上搜索，好比Pillow的名稱叫Pillow，所以，安裝Pillow的命令就是：

pip install Pillow

耐心等待下載並安裝後，就可使用Pillow了。

有了Pillow，處理圖片易如反掌。隨便找個圖片生成縮略圖：

>>> from PIL import Image
>>> im = Image.open('test.png')
>>> print(im.format, im.size, im.mode)
PNG (400, 300) RGB
>>> im.thumbnail((200, 100))
>>> im.save('thumb.jpg', 'JPEG')

其餘經常使用的第三方庫還有MySQL的驅動：mysql-connector-python，用於科學計算的NumPy庫：numpy，用於生成文本的模板工具Jinja2，等等。

模塊搜索路徑

當咱們試圖加載一個模塊時，Python會在指定的路徑下搜索對應的.py文件，若是找不到，就會報錯：

>>> import mymodule
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named mymodule

默認狀況下，Python解釋器會搜索當前目錄、全部已安裝的內置模塊和第三方模塊，搜索路徑存放在sys模塊的path變量中：

>>> import sys
>>> sys.path
['', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python34.zip', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/plat-darwin', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/lib-dynload', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/site-packages']

若是咱們要添加本身的搜索目錄，有兩種方法：

一是直接修改sys.path，添加要搜索的目錄：

>>> import sys
>>> sys.path.append('/Users/michael/my_py_scripts')

這種方法是在運行時修改，運行結束後失效。

第二種方法是設置環境變量PYTHONPATH，該環境變量的內容會被自動添加到模塊搜索路徑中。設置方式與設置Path環境變量相似。注意只須要添加你本身的搜索路徑，Python本身自己的搜索路徑不受影響。