python入門-4.函數語言程式設計
函數語言程式設計的一個特點就是，允許把函式本身作為引數傳入另一個函式，還允許返回一個函式！
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)
結果為10。
小結
當函式的引數個數太多，需要簡化時，使用functools.partial可以建立一個新的函式，這個新函式可以固定住原函式的部分引數，從而在呼叫時更簡單。