第六章 函數式編程
1、函數式編程——Functional Programming，雖然也可以歸結到面向過程的程序設計，但其思想更接近數學計算。
2、函數式編程就是一種抽象程度很高的編程範式，純粹的函數式編程語言編寫的函數沒有變量，因此，任意一個函數，只要輸入是確定的，輸出就是確定的，這種純函數我們稱之爲沒有副作用。而允許使用變量的程序設計語言，由於函數內部的變量狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數是有副作用的。
3、函數式編程的一個特點就是，允許把函數本身作爲參數傳入另一個函數，還允許返回一個函數！
4、Python對函數式編程提供部分支持。由於Python允許使用變量，因此，Python不是純函數式編程語言。
6.1 高階函數
高階函數英文叫Higher-orderfunction。
什麼是高階函數？我們以實際代碼爲例子，一步一步深入概念。
1、變量可以指向函數
以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>
【結論】：函數本身也可以賦值給變量，即：變量可以指向函數。
2、如果一個變量指向了一個函數，那麼，可否通過該變量來調用這個函數？【可以】
用代碼驗證一下：
>>> f = abs
>>> f(-10)
10
成功！說明變量f現在已經指向了abs函數本身。
直接調用abs()函數和調用變量f()完全相同。
3、函數名也是變量
那麼函數名是什麼呢？函數名其實就是指向函數的變量！對於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。
4、傳入函數——高階函數
既然變量可以指向函數，函數的參數能接收變量，那麼一個函數就可以接收另一個函數作爲參數，這種函數就稱之爲高階函數。
一個最簡單的高階函數：
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
編寫高階函數，就是讓函數的參數能夠接收別的函數。
【小結】
把函數作爲參數傳入，這樣的函數稱爲高階函數，
函數式編程就是指這種高度抽象的編程範式。
6.2map/reduce
Python內建了map()和reduce()函數。
如果你讀過Google的那篇大名鼎鼎的論文“MapReduce: Simplified Data Processing on Large Clusters”，你就能大概明白map/reduce的概念。
1、我們先看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']
只需要一行代碼。
2、再看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函數的用法在後面介紹。
【練習】
1、 利用map()函數，把用戶輸入的不規範的英文名字，變爲首字母大寫，其他小寫的規範名字。輸入：['adam','LISA', 'barT']，輸出：['Adam', 'Lisa', 'Bart']：
def normalize(name):
name= name[0].upper()+name[1:].lower()
returnname
L1= ['adam','LISTA','bar']
L2= list(map(normalize,L1))
print(L2)
2、 Python提供的sum()函數可以接受一個list並求和，請編寫一個prod()函數，可以接受一個list並利用reduce()求積：
一種方法：
from functools import reduce
def mul(x,y):
returnx*y
def prod(L):
returnreduce(mul,L)
更爲簡潔的一種方法：使用lambda
from functools import reduce
def prod(L):
returnreduce(lambda x，y：x*y,L)
6.3filter
1、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。
2、用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):
returnstr(n)==str(n)[::-1]
自己寫了一個，爲什麼數據（n>2000）一大就不行了呢？？？
def is_palindrome(n):
s =str(n)
fori in range(int(len(s)/2)):
ifs[i] == s[len(s)-1-i]:
returnTrue
else:
returnFalse
output = filter( is_palindrome,range(1,1000) )
print(list(output))
# 測試:
output = filter(is_palindrome, range(1,1000))
print(list(output))
Run
【小結】
（1) filter()的作用是從一個序列中篩出符合條件的元素。
（2) 由於filter()使用了惰性計算，所以只有在取filter()結果的時候，纔會真正篩選並每次返回下一個篩出的元素。
6.4sorted排序算法
1、排序也是在程序中經常用到的算法。無論使用冒泡排序還是快速排序，排序的核心是比較兩個元素的大小。如果是數字，我們可以直接比較，但如果是字符串或者兩個dict呢？直接比較數學上的大小是沒有意義的，因此，比較的過程必須通過函數抽象出來。
2、Python內置的sorted()函數就可以對list進行排序：
>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]
3、此外，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]
4、我們再看一個字符串排序的例子：
>>> 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()對上述列表分別按名字排序：
# -*- coding: utf-8 -*-
L = [('Bob', 75), ('Adam', 92), ('Bart',66), ('Lisa', 88)]
6.5 返回函數
1、函數作爲返回值
高階函數除了可以接受函數作爲參數外，還可以把函數作爲結果值返回。
我們來實現一個可變參數的求和。通常情況下，求和的函數是這樣定義的：
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 at0x101c6ed90>
調用函數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()的調用結果互不影響。
2、閉包
注意到返回的函數在其定義內部引用了局部變量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函數縮短代碼。
【小結】
（1) 一個函數可以返回一個計算結果，也可以返回一個函數。
（2) 返回一個函數時，牢記該函數並未執行，返回函數中不要引用任何可能會變化的變量。
6.6匿名函數（主要是lambda函數）
1、當我們在傳入函數時，有些時候，不需要顯式地定義函數，直接傳入匿名函數更方便。
在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表示函數參數。
2、匿名函數有個限制，就是只能有一個表達式，不用寫return，返回值就是該表達式的結果。
3、用匿名函數有個好處，因爲函數沒有名字，不必擔心函數名衝突。此外，匿名函數也是一個函數對象，也可以把匿名函數賦值給一個變量，再利用變量來調用該函數：
>>> f = lambda x: x * x
>>> f
<function <lambda> at0x101c6ef28>
>>> f(5)
25
同樣，也可以把匿名函數作爲返回值返回，比如：
def build(x, y):
return lambda: x * x + y * y
【小結】
Python對匿名函數的支持有限，只有一些簡單的情況下可以使用匿名函數——lambda函數。
6.7 裝飾器
1、由於函數也是一個對象，而且函數對象可以被賦值給變量，所以，通過變量也能調用該函數。
>>> def now():
... print('2015-3-25')
>>> f = now
>>> f()
2015-3-25
函數對象有一個__name__屬性，可以拿到函數的名字：
>>> now.__name__
'now'
>>> f.__name__
'now'
現在，假設我們要增強now()函數的功能，比如，在函數調用前後自動打印日誌，但又不希望修改now()函數的定義，
2、這種在代碼運行期間動態增加功能的方式，稱之爲“裝飾器”（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()函數內，首先打印日誌，再緊接着調用原始函數。
3、如果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就是幹這個事的，
（ functools.wraps,文檔描敘This is aconvenience function forinvoking partial(update_wrapper, wrapped=wrapped,assigned=assigned, updated=updated) asa function decorator when defining a wrapper function.
其實也就是相當於在調用了partial，使用wraps可以把整個function的屬性都帶上。）所以，一個完整的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)即可。
【小結】
（1) 在面向對象（OOP）的設計模式中，decorator被稱爲裝飾模式。OOP的裝飾模式需要通過繼承和組合來實現，而Python除了能支持OOP的decorator外，直接從語法層次支持decorator。
（2) python的decorator可以用函數實現，也可以用類實現。
（3) decorator可以增強函數的功能，定義起來雖然有點複雜，但使用起來非常靈活和方便。
6.8偏函數
1、Python的functools模塊提供了很多有用的功能，其中一個就是偏函數（Partial function）。要注意，這裏的偏函數和數學意義上的偏函數不一樣。
2、在介紹函數參數的時候，我們講到，通過設定參數的默認值，可以降低函數調用的難度。而偏函數也可以做到這一點。舉例如下：
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
3、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可以創建一個新的函數，這個新函數可以固定住原函數的部分參數，從而在調用時更簡單。
