基本是拷貝的內(nèi)容，目的是為了將知識點(diǎn)整理在一起瓦灶。除了一個小結(jié)（裝飾器部分）提供了我自己的解法，其余基本沒有改動過抱完。我很喜歡文章的內(nèi)容描述和代碼贼陶，讓我受益良多。
簡介
函數(shù)是Python內(nèi)建支持的一種封裝巧娱，我們通過把大段代碼拆成函數(shù)碉怔，通過一層一層的函數(shù)調(diào)用，就可以把復(fù)雜任務(wù)分解成簡單的任務(wù)禁添，這種分解可以稱之為面向過程的程序設(shè)計(jì)撮胧。函數(shù)就是面向過程的程序設(shè)計(jì)的基本單元。
而函數(shù)式編程（請注意多了一個“式”字）——Functional Programming老翘，雖然也可以歸結(jié)到面向過程的程序設(shè)計(jì)芹啥，但其思想更接近數(shù)學(xué)計(jì)算。
我們首先要搞明白計(jì)算機(jī)（Computer）和計(jì)算（Compute）的概念铺峭。
在計(jì)算機(jī)的層次上墓怀，CPU執(zhí)行的是加減乘除的指令代碼，以及各種條件判斷和跳轉(zhuǎn)指令卫键，所以傀履，匯編語言是最貼近計(jì)算機(jī)的語言。
而計(jì)算則指數(shù)學(xué)意義上的計(jì)算莉炉，越是抽象的計(jì)算钓账，離計(jì)算機(jī)硬件越遠(yuǎn)。
對應(yīng)到編程語言絮宁，就是越低級的語言梆暮，越貼近計(jì)算機(jī)，抽象程度低羞福，執(zhí)行效率高惕蹄，比如C語言；越高級的語言治专，越貼近計(jì)算卖陵，抽象程度高，執(zhí)行效率低张峰，比如Lisp語言泪蔫。
函數(shù)式編程就是一種抽象程度很高的編程范式，純粹的函數(shù)式編程語言編寫的函數(shù)沒有變量喘批，因此撩荣，任意一個函數(shù)，只要輸入是確定的饶深，輸出就是確定的餐曹，這種純函數(shù)我們稱之為沒有副作用。而允許使用變量的程序設(shè)計(jì)語言敌厘，由于函數(shù)內(nèi)部的變量狀態(tài)不確定台猴，同樣的輸入，可能得到不同的輸出俱两，因此饱狂，這種函數(shù)是有副作用的。
函數(shù)式編程的一個特點(diǎn)就是宪彩，允許把函數(shù)本身作為參數(shù)傳入另一個函數(shù)休讳，還允許返回一個函數(shù)！
Python對函數(shù)式編程提供部分支持尿孔。由于Python允許使用變量俊柔，因此，Python不是純函數(shù)式編程語言活合。
高階函數(shù)
高階函數(shù)英文叫Higher-order function雏婶。什么是高階函數(shù)？我們以實(shí)際代碼為例子芜辕，一步一步深入概念尚骄。
變量可以指向函數(shù)
以Python內(nèi)置的求絕對值的函數(shù)abs()為例，調(diào)用該函數(shù)用以下代碼：
>>> abs(-10)
10
但是侵续，如果只寫abs呢倔丈？
>>> abs
<built-in function abs>
可見，abs(-10)是函數(shù)調(diào)用状蜗，而abs是函數(shù)本身需五。
要獲得函數(shù)調(diào)用結(jié)果，我們可以把結(jié)果賦值給變量：
>>> x = abs(-10)
>>> x
10
但是轧坎，如果把函數(shù)本身賦值給變量呢宏邮？
>>> f = abs
>>> f
<built-in function abs>
結(jié)論：函數(shù)本身也可以賦值給變量，即：變量可以指向函數(shù)。
如果一個變量指向了一個函數(shù)蜜氨，那么械筛，可否通過該變量來調(diào)用這個函數(shù)？用代碼驗(yàn)證一下：
>>> f = abs
>>> f(-10)
10
成功飒炎！說明變量f現(xiàn)在已經(jīng)指向了abs函數(shù)本身埋哟。直接調(diào)用abs()函數(shù)和調(diào)用變量f()完全相同。
函數(shù)名也是變量
那么函數(shù)名是什么呢郎汪？函數(shù)名其實(shí)就是指向函數(shù)的變量赤赊！對于abs()這個函數(shù)，完全可以把函數(shù)名abs看成變量煞赢，它指向一個可以計(jì)算絕對值的函數(shù)抛计！
如果把abs指向其他對象，會有什么情況發(fā)生照筑？
>>> 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)調(diào)用該函數(shù)了！因?yàn)?code>abs這個變量已經(jīng)不指向求絕對值函數(shù)而是指向一個整數(shù)10朦肘！
當(dāng)然實(shí)際代碼絕對不能這么寫饭弓，這里是為了說明函數(shù)名也是變量。要恢復(fù)abs函數(shù)媒抠，請重啟Python交互環(huán)境弟断。
注：由于abs函數(shù)實(shí)際上是定義在import builtins模塊中的，所以要讓修改abs變量的指向在其它模塊也生效趴生，要用import builtins; builtins.abs = 10阀趴。
傳入函數(shù)
既然變量可以指向函數(shù)，函數(shù)的參數(shù)能接收變量苍匆，那么一個函數(shù)就可以接收另一個函數(shù)作為參數(shù)刘急，這種函數(shù)就稱之為高階函數(shù)。
一個最簡單的高階函數(shù)：
def add(x, y, f):
return f(x) + f(y)
當(dāng)我們調(diào)用add(-5, 6, abs)時(shí)浸踩，參數(shù)x叔汁，y和f分別接收-5，6和abs检碗，根據(jù)函數(shù)定義据块，我們可以推導(dǎo)計(jì)算過程為：
x = -5
y = 6
f = abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 11
return 11
map/reduce
Python內(nèi)建了map()和reduce()函數(shù)。
如果你讀過Google的那篇大名鼎鼎的論文“MapReduce: Simplified Data Processing on Large Clusters”折剃，你就能大概明白map/reduce的概念另假。
我們先看map。map()函數(shù)接收兩個參數(shù)怕犁，一個是函數(shù)边篮，一個是Iterable己莺，map將傳入的函數(shù)依次作用到序列的每個元素，并把結(jié)果作為新的Iterator返回戈轿。
舉例說明凌受，比如我們有一個函數(shù)f(x)=x2，要把這個函數(shù)作用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上凶杖，就可以用map()實(shí)現(xiàn)如下：
f(x) = x * x
│
│
┌───┬───┬───┬───┼───┬───┬───┬───┐
│ │ │ │ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼
[ 1 2 3 4 5 6 7 8 9 ]
│ │ │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼
[ 1 4 9 16 25 36 49 64 81 ]
現(xiàn)在胁艰，我們用Python代碼實(shí)現(xiàn)：
>>> 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()傳入的第一個參數(shù)是f款筑，即函數(shù)對象本身智蝠。由于結(jié)果r是一個Iterator，Iterator是惰性序列奈梳，因此通過list()函數(shù)讓它把整個序列都計(jì)算出來并返回一個list杈湾。
你可能會想，不需要map()函數(shù)攘须，寫一個循環(huán)漆撞，也可以計(jì)算出結(jié)果：
L = []
for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
L.append(f(n))
print(L)
的確可以，但是于宙，從上面的循環(huán)代碼浮驳，能一眼看明白“把f(x)作用在list的每一個元素并把結(jié)果生成一個新的list”嗎？
所以捞魁，map()作為高階函數(shù)至会，事實(shí)上它把運(yùn)算規(guī)則抽象了，因此谱俭，我們不但可以計(jì)算簡單的f(x)=x2奉件，還可以計(jì)算任意復(fù)雜的函數(shù)，比如昆著，把這個list所有數(shù)字轉(zhuǎn)為字符串：
>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']
只需要一行代碼县貌。
再看reduce的用法。reduce把一個函數(shù)作用在一個序列[x1, x2, x3, ...]上凑懂，這個函數(shù)必須接收兩個參數(shù)煤痕，reduce把結(jié)果繼續(xù)和序列的下一個元素做累積計(jì)算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
比方說對一個序列求和接谨，就可以用reduce實(shí)現(xiàn)：
>>> from functools import reduce
>>> def add(x, y):
... return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25
當(dāng)然求和運(yùn)算可以直接用Python內(nèi)建函數(shù)sum()摆碉，沒必要動用reduce。
但是如果要把序列[1, 3, 5, 7, 9]變換成整數(shù)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轉(zhuǎn)換為int的函數(shù)：
>>> from functools import reduce
>>> def fn(x, y):
... return x * 10 + y
...
>>> def char2num(s):
... digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
... return digits[s]
...
>>> reduce(fn, map(char2num, '13579'))
13579
整理成一個str2int的函數(shù)就是：
from functools import reduce
DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def str2int(s):
def fn(x, y):
return x * 10 + y
def char2num(s):
return DIGITS[s]
return reduce(fn, map(char2num, s))
還可以用lambda函數(shù)進(jìn)一步簡化成：
from functools import reduce
DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def char2num(s):
return DIGITS[s]
def str2int(s):
return reduce(lambda x, y: x * 10 + y, map(char2num, s))
也就是說，假設(shè)Python沒有提供int()函數(shù)现拒，你完全可以自己寫一個把字符串轉(zhuǎn)化為整數(shù)的函數(shù)英遭，而且只需要幾行代碼双肤！
filter
Python內(nèi)建的filter()函數(shù)用于過濾序列。
和map()類似，filter()也接收一個函數(shù)和一個序列施禾。和map()不同的是，filter()把傳入的函數(shù)依次作用于每個元素傀蓉，然后根據(jù)返回值是True還是False決定保留還是丟棄該元素撩幽。
例如，在一個list中退唠，刪掉偶數(shù)鹃锈，只保留奇數(shù)，可以這么寫：
def is_odd(n):
return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 結(jié)果: [1, 5, 9, 15]
把一個序列中的空字符串刪掉瞧预，可以這么寫：
def not_empty(s):
return s and s.strip()
list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
# 結(jié)果: ['A', 'B', 'C']
可見用filter()這個高階函數(shù)屎债，關(guān)鍵在于正確實(shí)現(xiàn)一個“篩選”函數(shù)。
注意到filter()函數(shù)返回的是一個Iterator垢油，也就是一個惰性序列盆驹，所以要強(qiáng)迫filter()完成計(jì)算結(jié)果，需要用list()函數(shù)獲得所有結(jié)果并返回list滩愁。
用filter求素?cái)?shù)
計(jì)算素?cái)?shù)的一個方法是埃氏篩法躯喇，它的算法理解起來非常簡單：
首先，列出從2開始的所有自然數(shù)惊楼，構(gòu)造一個序列：
2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取序列的第一個數(shù)2玖瘸，它一定是素?cái)?shù)，然后用2把序列的2的倍數(shù)篩掉：
3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取新序列的第一個數(shù)3檀咙，它一定是素?cái)?shù)雅倒，然后用3把序列的3的倍數(shù)篩掉：
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取新序列的第一個數(shù)5，然后用5把序列的5的倍數(shù)篩掉：
7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
不斷篩下去弧可，就可以得到所有的素?cái)?shù)蔑匣。
用Python來實(shí)現(xiàn)這個算法，可以先構(gòu)造一個從3開始的奇數(shù)序列：
def _odd_iter():
n = 1
while True:
n = n + 2
yield n
注意這是一個生成器棕诵，并且是一個無限序列裁良。
然后定義一個篩選函數(shù)：
def _not_divisible(n):
return lambda x: x % n > 0
最后，定義一個生成器校套，不斷返回下一個素?cái)?shù)：
def primes():
yield 2
it = _odd_iter() # 初始序列
while True:
n = next(it) # 返回序列的第一個數(shù)
yield n
it = filter(_not_divisible(n), it) # 構(gòu)造新序列
這個生成器先返回第一個素?cái)?shù)2价脾，然后，利用filter()不斷產(chǎn)生篩選后的新的序列笛匙。
由于primes()也是一個無限序列侨把，所以調(diào)用時(shí)需要設(shè)置一個退出循環(huán)的條件：
# 打印1000以內(nèi)的素?cái)?shù):
for n in primes():
if n < 1000:
print(n)
else:
break
注意到Iterator是惰性計(jì)算的序列犀变，所以我們可以用Python表示“全體自然數(shù)”，“全體素?cái)?shù)”這樣的序列秋柄，而代碼非常簡潔获枝。
sorted
排序也是在程序中經(jīng)常用到的算法。無論使用冒泡排序還是快速排序骇笔，排序的核心是比較兩個元素的大小省店。如果是數(shù)字，我們可以直接比較笨触，但如果是字符串或者兩個dict呢懦傍？直接比較數(shù)學(xué)上的大小是沒有意義的，因此旭旭，比較的過程必須通過函數(shù)抽象出來谎脯。
Python內(nèi)置的sorted()函數(shù)就可以對list進(jìn)行排序：
>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]
此外，sorted()函數(shù)也是一個高階函數(shù)持寄，它還可以接收一個key函數(shù)來實(shí)現(xiàn)自定義的排序，例如按絕對值大小排序：
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
key指定的函數(shù)將作用于list的每一個元素上娱俺，并根據(jù)key函數(shù)返回的結(jié)果進(jìn)行排序稍味。對比原始的list和經(jīng)過key=abs處理過的list：
list = [36, 5, -12, 9, -21]
keys = [36, 5, 12, 9, 21]
然后sorted()函數(shù)按照keys進(jìn)行排序，并按照對應(yīng)關(guān)系返回list相應(yīng)的元素：
keys排序結(jié)果 => [5, 9, 12, 21, 36]
| | | | |
最終結(jié)果 => [5, 9, -12, -21, 36]
我們再看一個字符串排序的例子：
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']
默認(rèn)情況下荠卷，對字符串排序模庐，是按照ASCII的大小比較的，由于'Z' < 'a'油宜，結(jié)果掂碱，大寫字母Z會排在小寫字母a的前面。
現(xiàn)在慎冤，我們提出排序應(yīng)該忽略大小寫疼燥，按照字母序排序。要實(shí)現(xiàn)這個算法蚁堤，不必對現(xiàn)有代碼大加改動醉者，只要我們能用一個key函數(shù)把字符串映射為忽略大小寫排序即可。忽略大小寫來比較兩個字符串披诗，實(shí)際上就是先把字符串都變成大寫（或者都變成小寫）撬即，再比較。
這樣呈队，我們給sorted傳入key函數(shù)剥槐，即可實(shí)現(xiàn)忽略大小寫的排序：
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']
要進(jìn)行反向排序，不必改動key函數(shù)宪摧，可以傳入第三個參數(shù)reverse=True：
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']
從上述例子可以看出粒竖，高階函數(shù)的抽象能力是非常強(qiáng)大的迈喉，而且，核心代碼可以保持得非常簡潔温圆。
小結(jié)
sorted()也是一個高階函數(shù)挨摸。用sorted()排序的關(guān)鍵在于實(shí)現(xiàn)一個映射函數(shù)。
返回函數(shù)
函數(shù)作為返回值
高階函數(shù)除了可以接受函數(shù)作為參數(shù)外岁歉，還可以把函數(shù)作為結(jié)果值返回得运。
我們來實(shí)現(xiàn)一個可變參數(shù)的求和。通常情況下锅移，求和的函數(shù)是這樣定義的：
def calc_sum(*args):
ax = 0
for n in args:
ax = ax + n
return ax
但是熔掺，如果不需要立刻求和，而是在后面的代碼中非剃，根據(jù)需要再計(jì)算怎么辦置逻？可以不返回求和的結(jié)果，而是返回求和的函數(shù)：
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
當(dāng)我們調(diào)用lazy_sum()時(shí)备绽，返回的并不是求和結(jié)果券坞，而是求和函數(shù)：
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>
調(diào)用函數(shù)f時(shí)，才真正計(jì)算求和的結(jié)果：
>>> f()
25
在這個例子中肺素，我們在函數(shù)lazy_sum中又定義了函數(shù)sum恨锚，并且，內(nèi)部函數(shù)sum可以引用外部函數(shù)lazy_sum的參數(shù)和局部變量倍靡，當(dāng)lazy_sum返回函數(shù)sum時(shí)猴伶，相關(guān)參數(shù)和變量都保存在返回的函數(shù)中，這種稱為“閉包（Closure）”的程序結(jié)構(gòu)擁有極大的威力塌西。
請?jiān)僮⒁庖稽c(diǎn)他挎，當(dāng)我們調(diào)用lazy_sum()時(shí)，每次調(diào)用都會返回一個新的函數(shù)捡需，即使傳入相同的參數(shù)：
>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False
f1()和f2()的調(diào)用結(jié)果互不影響办桨。
閉包
注意到返回的函數(shù)在其定義內(nèi)部引用了局部變量args，所以栖忠，當(dāng)一個函數(shù)返回了一個函數(shù)后崔挖，其內(nèi)部的局部變量還被新函數(shù)引用，所以庵寞，閉包用起來簡單狸相，實(shí)現(xiàn)起來可不容易。
另一個需要注意的問題是捐川，返回的函數(shù)并沒有立刻執(zhí)行脓鹃，而是直到調(diào)用了f()才執(zhí)行。我們來看一個例子：
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()
在上面的例子中古沥，每次循環(huán)瘸右，都創(chuàng)建了一個新的函數(shù)娇跟，然后，把創(chuàng)建的3個函數(shù)都返回了太颤。
你可能認(rèn)為調(diào)用f1()苞俘，f2()和f3()結(jié)果應(yīng)該是1，4龄章，9吃谣，但實(shí)際結(jié)果是：
>>> f1()
9
>>> f2()
9
>>> f3()
9
全部都是9！原因就在于返回的函數(shù)引用了變量i做裙，但它并非立刻執(zhí)行岗憋。等到3個函數(shù)都返回時(shí)，它們所引用的變量i已經(jīng)變成了3锚贱，因此最終結(jié)果為9仔戈。
返回閉包時(shí)牢記一點(diǎn)：返回函數(shù)不要引用任何循環(huán)變量，或者后續(xù)會發(fā)生變化的變量拧廊。
如果一定要引用循環(huán)變量怎么辦监徘？方法是再創(chuàng)建一個函數(shù)，用該函數(shù)的參數(shù)綁定循環(huán)變量當(dāng)前的值卦绣，無論該循環(huán)變量后續(xù)如何更改耐量，已綁定到函數(shù)參數(shù)的值不變：
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)立刻被執(zhí)行，因此i的當(dāng)前值被傳入f()
return fs
再看看結(jié)果：
>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9
缺點(diǎn)是代碼較長滤港，可利用lambda函數(shù)縮短代碼。
匿名函數(shù)
當(dāng)我們在傳入函數(shù)時(shí)趴拧，有些時(shí)候溅漾，不需要顯式地定義函數(shù)，直接傳入匿名函數(shù)更方便著榴。
在Python中添履，對匿名函數(shù)提供了有限支持。還是以map()函數(shù)為例脑又，計(jì)算f(x)=x2時(shí)暮胧，除了定義一個f(x)的函數(shù)外，還可以直接傳入匿名函數(shù)：
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]
通過對比可以看出问麸，匿名函數(shù)lambda x: x * x實(shí)際上就是：
def f(x):
return x * x
關(guān)鍵字lambda表示匿名函數(shù)往衷，冒號前面的x表示函數(shù)參數(shù)。
匿名函數(shù)有個限制严卖，就是只能有一個表達(dá)式席舍，不用寫return，返回值就是該表達(dá)式的結(jié)果哮笆。
用匿名函數(shù)有個好處来颤，因?yàn)楹瘮?shù)沒有名字汰扭，不必?fù)?dān)心函數(shù)名沖突。此外福铅，匿名函數(shù)也是一個函數(shù)對象萝毛，也可以把匿名函數(shù)賦值給一個變量，再利用變量來調(diào)用該函數(shù)：
>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25
同樣滑黔，也可以把匿名函數(shù)作為返回值返回笆包，比如：
def build(x, y):
return lambda: x * x + y * y
裝飾器
由于函數(shù)也是一個對象，而且函數(shù)對象可以被賦值給變量拷沸，所以色查，通過變量也能調(diào)用該函數(shù)。
>>> def now():
... print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25
函數(shù)對象有一個__name__屬性撞芍，可以拿到函數(shù)的名字：
>>> now.__name__
'now'
>>> f.__name__
'now'
現(xiàn)在秧了，假設(shè)我們要增強(qiáng)now()函數(shù)的功能，比如序无，在函數(shù)調(diào)用前后自動打印日志验毡，但又不希望修改now()函數(shù)的定義，這種在代碼運(yùn)行期間動態(tài)增加功能的方式帝嗡，稱之為“裝飾器”（Decorator）晶通。
本質(zhì)上，decorator就是一個返回函數(shù)的高階函數(shù)哟玷。所以狮辽，我們要定義一個能打印日志的decorator，可以定義如下：
def log(func):
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
觀察上面的log巢寡，因?yàn)樗且粋€decorator喉脖，所以接受一個函數(shù)作為參數(shù)，并返回一個函數(shù)抑月。我們要借助Python的@語法树叽，把decorator置于函數(shù)的定義處：
@log
def now():
print('2015-3-25')
調(diào)用now()函數(shù)，不僅會運(yùn)行now()函數(shù)本身谦絮，還會在運(yùn)行now()函數(shù)前打印一行日志：
>>> now()
call now():
2015-3-25
把@log放到now()函數(shù)的定義處题诵，相當(dāng)于執(zhí)行了語句：
now = log(now)
由于log()是一個decorator，返回一個函數(shù)层皱，所以性锭，原來的now()函數(shù)仍然存在，只是現(xiàn)在同名的now變量指向了新的函數(shù)奶甘，于是調(diào)用now()將執(zhí)行新函數(shù)篷店，即在log()函數(shù)中返回的wrapper()函數(shù)。
wrapper()函數(shù)的參數(shù)定義是(*args, **kw)，因此疲陕，wrapper()函數(shù)可以接受任意參數(shù)的調(diào)用方淤。在wrapper()函數(shù)內(nèi)，首先打印日志蹄殃，再緊接著調(diào)用原始函數(shù)携茂。
如果decorator本身需要傳入?yún)?shù)，那就需要編寫一個返回decorator的高階函數(shù)诅岩，寫出來會更復(fù)雜讳苦。比如，要自定義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')
執(zhí)行結(jié)果如下：
>>> now()
execute now():
2015-3-25
和兩層嵌套的decorator相比吩谦，3層嵌套的效果是這樣的：
>>> now = log('execute')(now)
我們來剖析上面的語句鸳谜，首先執(zhí)行log('execute')，返回的是decorator函數(shù)式廷，再調(diào)用返回的函數(shù)咐扭，參數(shù)是now函數(shù)，返回值最終是wrapper函數(shù)滑废。
以上兩種decorator的定義都沒有問題蝗肪，但還差最后一步。因?yàn)槲覀冎v了函數(shù)也是對象蠕趁，它有__name__等屬性薛闪，但你去看經(jīng)過decorator裝飾之后的函數(shù)，它們的__name__已經(jīng)從原來的'now'變成了'wrapper'：
>>> now.__name__
'wrapper'
因?yàn)榉祷氐哪莻€wrapper()函數(shù)名字就是'wrapper'俺陋，所以豁延，需要把原始函數(shù)的__name__等屬性復(fù)制到wrapper()函數(shù)中，否則腊状，有些依賴函數(shù)簽名的代碼執(zhí)行就會出錯术浪。
不需要編寫wrapper.__name__ = func.__name__這樣的代碼，Python內(nèi)置的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
或者針對帶參數(shù)的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是導(dǎo)入functools模塊硕蛹。模塊的概念稍候講解〈继郏現(xiàn)在，只需記住在定義wrapper()的前面加上@functools.wraps(func)即可法焰。
練習(xí)
請編寫一個decorator秧荆，能在函數(shù)調(diào)用的前后打印出'begin call'和'end call'的日志。
再思考一下能否寫出一個@log的decorator埃仪，使它既支持：
@log
def f():
pass
又支持：
@log('execute')
def f():
pass
答案：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def log(text):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('Begin call')
print('calling func: %s' % func.__name__)
r = func(*args, **kw)
print('Eng call')
return r
return wrapper
return decorator if isinstance(text, str) else decorator(text)
@log
def f():
pass
f()
@log('execute')
def g():
pass
g()
偏函數(shù)
Python的functools模塊提供了很多有用的功能乙濒，其中一個就是偏函數(shù)（Partial function）。要注意，這里的偏函數(shù)和數(shù)學(xué)意義上的偏函數(shù)不一樣颁股。
通過設(shè)定參數(shù)的默認(rèn)值么库，可以降低函數(shù)調(diào)用的難度。而偏函數(shù)也可以做到這一點(diǎn)甘有。舉例如下：
int()函數(shù)可以把字符串轉(zhuǎn)換為整數(shù)诉儒，當(dāng)僅傳入字符串時(shí)，int()函數(shù)默認(rèn)按十進(jìn)制轉(zhuǎn)換：
>>> int('12345')
12345
但int()函數(shù)還提供額外的base參數(shù)亏掀，默認(rèn)值為10忱反。如果傳入base參數(shù)，就可以做N進(jìn)制的轉(zhuǎn)換：
>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565
假設(shè)要轉(zhuǎn)換大量的二進(jìn)制字符串滤愕，每次都傳入int(x, base=2)非常麻煩温算，于是，我們想到间影，可以定義一個int2()的函數(shù)注竿，默認(rèn)把base=2傳進(jìn)去：
def int2(x, base=2):
return int(x, base)
這樣，我們轉(zhuǎn)換二進(jìn)制就非常方便了：
>>> int2('1000000')
64
>>> int2('1010101')
85
functools.partial就是幫助我們創(chuàng)建一個偏函數(shù)的宇智，不需要我們自己定義int2()蔓搞，可以直接使用下面的代碼創(chuàng)建一個新的函數(shù)int2：
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85
所以，簡單總結(jié)functools.partial的作用就是随橘，把一個函數(shù)的某些參數(shù)給固定孜狗帧（也就是設(shè)置默認(rèn)值），返回一個新的函數(shù)机蔗，調(diào)用這個新函數(shù)會更簡單蒲祈。
注意到上面的新的int2函數(shù)，僅僅是把base參數(shù)重新設(shè)定默認(rèn)值為2萝嘁，但也可以在函數(shù)調(diào)用時(shí)傳入其他值：
>>> int2('1000000', base=10)
1000000
最后梆掸，創(chuàng)建偏函數(shù)時(shí)，實(shí)際上可以接收函數(shù)對象牙言、*args和**kw這3個參數(shù)*酸钦，當(dāng)傳入：
int2 = functools.partial(int, base=2)
實(shí)際上固定了int()函數(shù)的關(guān)鍵字參數(shù)base，也就是：
int2('10010')
相當(dāng)于：
kw = { 'base': 2 }
int('10010', **kw)
當(dāng)傳入：
max2 = functools.partial(max, 10)
實(shí)際上會把10作為*args的一部分自動加到左邊咱枉，也就是：
max2(5, 6, 7)
相當(dāng)于：
args = (10, 5, 6, 7)
max(*args)
結(jié)果為10卑硫。
小結(jié)
當(dāng)函數(shù)的參數(shù)個數(shù)太多，需要簡化時(shí)蚕断，使用functools.partial可以創(chuàng)建一個新的函數(shù)欢伏，這個新函數(shù)可以固定住原函數(shù)的部分參數(shù)，從而在調(diào)用時(shí)更簡單亿乳。
