函數式程式設計的一個特點就是，允許把函數本身作為參數傳入另一個函數，還允許傳回一個函數！
Python對函數式程式設計提供部分支援。由于Python允許使用變量，是以，Python不是純函數式程式設計語言。
高階函數
什麼是高階函數？我們以實際代碼為例子，一步一步深入概念。
變量可以指向函數
以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
x = -5y = 6f = absf(x) + f(y) ==> abs(-5) + abs(6) ==> 11return 11
編寫高階函數，就是讓函數的參數能夠接收别的函數。
map/reduce
Python内建了
map()
reduce()
函數。
map()
函數接收兩個參數，一個是函數，一個是
Iterable
map
将傳入的函數依次作用到序列的每個元素，并把結果作為新的
Iterator
傳回。
舉例說明，比如我們有一個函數f(x)=x2，要把這個函數作用在一個list
[1, 2, 3, 4, 5, 6, 7, 8, 9]
上，就可以用
map()
實作如下：
f(x) = x * x │ │ ┌───┬───┬───┬───┼───┬───┬───┬───┐ │ │ │ │ │ │ │ │ │ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼[ 1 2 3 4 5 6 7 8 9 ] │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼[ 1 4 9 16 25 36 49 64 81 ]
現在，我們用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):... 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
的函數就是：
from functools import reduceDIGITS = {'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))
假設Python沒有提供
int()
函數，你完全可以自己寫一個把字元串轉化為整數的函數，而且隻需要幾行代碼！
練習
1.利用
map()
函數，把使用者輸入的不規範的英文名字，變為首字母大寫，其他小寫的規範名字。輸入：
['adam', 'LISA', 'barT']
，輸出：
['Adam', 'Lisa', 'Bart']
：
def normalize(s): return s[0].upper()+s[1:].lower()
# 測試:L1 = ['adam', 'LISA', 'barT']L2 = list(map(normalize, L1))print(L2)
2.Python提供的
sum()
函數可以接受一個list并求和，請編寫一個
prod()
函數，可以接受一個list并利用
reduce()
求積：
from functools import reducedef mul(x,y): return x*ydef prod(l): return reduce(mul,l)
print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))if prod([3, 5, 7, 9]) == 945: print('測試成功!')else: print('測試失敗!')
3.利用
map
reduce
編寫一個
str2float
函數，把字元串
'123.456'
轉換成浮點數
123.456
from functools import reducedef num2int(x, y): return x * 10 + ydef str2num(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]def str2float(s): L = s.split('.', 1) L1 = reduce(num2int, map(str2num, L[0])) L2 = reduce(num2int, map(str2num, L[1])) * (0.1 ** len(L[1])) return L1 + L2
print('str2float(\'123.456\') =', str2float('123.456'))if abs(str2float('123.456') - 123.456) < 0.00001: print('測試成功!')else: print('測試失敗!')
filter
Python内建的
filter()
函數用于過濾序列。
map()
類似，
filter()
也接收一個函數和一個序列。和
map()
不同的是，
filter()
把傳入的函數依次作用于每個元素，然後根據傳回值是
True
還是
False
決定保留還是丢棄該元素。
例如，在一個list中，删掉偶數，隻保留奇數，可以這麼寫：
def is_odd(n): return n % 2 == 1list(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']
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
小結
filter()
的作用是從一個序列中篩出符合條件的元素。由于
filter()
使用了惰性計算，是以隻有在取
filter()
結果的時候，才會真正篩選并每次傳回下一個篩出的元素。
回文數是指從左向右讀和從右向左讀都是一樣的數，例如
12321
909
。請利用
filter()
篩選出回文數：
def is_palindrome(m): s=str(m) return s==s[::-1]
# 測試:output = filter(is_palindrome, range(1, 1000))print('1~1000:', list(output))if list(filter(is_palindrome, range(1, 200))) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]: print('測試成功!')else: print('測試失敗!')
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)]
請用
sorted()
對上述清單分别按名字排序：
def by_name(s): return s[0].lower()
L2 = sorted(L, key=by_name)print(L2)
再按成績從高到低排序：
def by_score(s): return -s[1]
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]L3 = sorted(L, key=by_score)print(L3)
傳回函數
函數作為傳回值
高階函數除了可以接受函數作為參數外，還可以把函數作為結果值傳回。
我們來實作一個可變參數的求和。通常情況下，求和的函數是這樣定義的：
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==f2False
f1()
f2()
的調用結果互不影響。
閉包
注意到傳回的函數在其定義内部引用了局部變量
args
，是以，當一個函數傳回了一個函數後，其内部的局部變量還被新函數引用，是以，閉包用起來簡單，實作起來可不容易。
另一個需要注意的問題是，傳回的函數并沒有立刻執行，而是直到調用了
f()
才執行。我們來看一個例子：
def count(): fs = [] for i in range(1, 4): def f(): return i*i fs.append(f) return fsf1, 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函數縮短代碼。
一個函數可以傳回一個計算結果，也可以傳回一個函數。
傳回一個函數時，牢記該函數并未執行，傳回函數中不要引用任何可能會變化的變量。
參考源碼
利用閉包傳回一個計數器函數，每次調用它傳回遞增整數：
def createCounter(): a=[0] def counter(): a[0]+=1 return a[0] return counter
# 測試:counterA = createCounter()print(counterA(), counterA(), counterA(), counterA(), counterA()) # 1 2 3 4 5counterB = createCounter()if [counterB(), counterB(), counterB(), counterB()] == [1, 2, 3, 4]: print('測試通過!')else: print('測試失敗!')
匿名函數
當我們在傳入函數時，有些時候，不需要顯式地定義函數，直接傳入匿名函數更友善。
在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
Python對匿名函數的支援有限，隻有一些簡單的情況下可以使用匿名函數。
請用匿名函數改造下面的代碼：
def is_odd(n): return n % 2 == 1L = list(filter(is_odd, range(1, 20)))
L = list(filter(lambda x:x%2==1, range(1, 20)))
裝飾器
由于函數也是一個對象，而且函數對象可以被指派給變量，是以，通過變量也能調用該函數。
>>> 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置于函數的定義處：
@logdef 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 functoolsdef log(func): @functools.wraps(func) def wrapper(*args, **kw): print('call %s():' % func.__name__) return func(*args, **kw) return wrapper
或者針對帶參數的decorator：
import functoolsdef 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可以增強函數的功能，定義起來雖然有點複雜，但使用起來非常靈活和友善。
請編寫一個decorator，能在函數調用的前後列印出
'begin call'
'end call'
的日志。
請設計一個decorator，它可作用于任何函數上，并列印該函數的執行時間：
import time, functoolsdef metric(fn): @functools.wraps(fn) def wrapper(*args, **kw): start=time.time() fn(*args, **kw) end=time.time() print('%s executed in %s ms' % (fn.__name__, end-start)) return fn(*args, **kw) return wrapper
# 測試@metricdef fast(x, y): time.sleep(0.0012) return x + y;@metricdef slow(x, y, z): time.sleep(0.1234) return x * y * z;f = fast(11, 22)s = slow(11, 22, 33)if f != 33: print('測試失敗!')elif s != 7986: print('測試失敗!')
偏函數
Python的
functools
子產品提供了很多有用的功能，其中一個就是偏函數（Partial function）。要注意，這裡的偏函數和數學意義上的偏函數不一樣。
在介紹函數參數的時候，我們講到，通過設定參數的預設值，可以降低函數調用的難度。而偏函數也可以做到這一點。舉例如下：
int()
函數可以把字元串轉換為整數，當僅傳入字元串時，
int()
函數預設按十進制轉換：
>>> int('12345')12345
但
int()
函數還提供額外的
base
參數，預設值為
10
。如果傳入
base
參數，就可以做N進制轉換成10進制：
>>> 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
，但也可以在函數調用時傳入其他值：
最後，建立偏函數時，實際上可以接收函數對象、
*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)
![TestLink導出用例轉換工具(XML2Excel)[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)