函數是Python內建支持的一種封裝，我們通過把大段代碼拆成函數，通過一層一層的函數調用，就可以把復雜任務分解成簡單的任務，這種分解可以稱之為面向過程的程序設計。函數就是面向過程的程序設計的基本單元。
而函數式編程--Functional Programming,雖然也可以歸結到面向過程的程序設計，但其思想更接近數學計算。
我們首先要搞明白計算機（Computer）和計算（Compute）的概念。

在計算機的層次上，CPU執行的是加減乘除的指令代碼，以及各種條件判斷和跳轉指令，所以，匯編語言是最貼近計算機的語言。

而計算則指數學意義上的計算，越是抽象的計算，離計算機硬件越遠。

對應到編程語言，就是越低級的語言，越貼近計算機，抽象程度低，執行效率高，比如C語言；越高級的語言，越貼近計算，抽象程度高，執行效率低，比如Lisp語言。

函數式編程就是一種抽象程度很高的編程范式，純粹的函數式編程語言編寫的函數沒有變量，因此，任意一個函數，只要輸入是確定的，輸出就是確定的，這種純函數我們稱之為沒有副作用。而允許使用變量的程序設計語言，由于函數內部的變量狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數是有副作用的。

函數式編程的一個特點就是，允許把函數本身作為參數傳入另一個函數，還允許返回一個函數！

Python對函數式編程提供部分支持。由于Python允許使用變量，因此，Python不是純函數式編程語言。

1.高階函數

High er-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(-10)
10

• 函數名也是變量
  那么函數名是什么呢？函數名其實就是指向函數的變量！對于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, -10, abs)
15

函數作為參數傳入，這樣的函數稱為高階函數，函數式編程就是指這種高度抽象的編程范式。

1.1 map/reduce

Python 內建了map()和reduce()函數
map()接收兩個參數，一個是函數，一個是Iterable,map將傳入的函數依次作用到序列的每個元素，并把結果作為新的Iterator返回。

舉例說明：
比如我們有一個函數f(x)=x^2，要把這個函數作用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()實現如下：

map_reduce.png

現在，我們用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)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

的確可以，但是，從上面的循環代碼，能一眼看明白“把f(x)作用在list的每一個元素并把結果生成一個新的list”嗎？
所以，map()作為高階函數，事實上它把運算規則抽象了，因此，我們不但可以計算簡單的f(x)=x^2，還可以計算任意復雜的函數，比如，把這個list所有數字轉為字符串：

>>> list(map(str,[1,2,3,4,5]))
['1', '2', '3', '4', '5']

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,2,3,4,5,6])
21
#當然求和運算可以直接用Python內建函數sum()，沒必要動用reduce。
#但是如果要把序列[1, 2, 3, 4, 5, 6]變換成整數123456，reduce就可以派上用場：
>>> def fn(x, y):
...     return x * 10 + y
... 
>>> reduce(fn, [1,2,3,4,5,6])
123456

這個例子本身沒多大用處，但是，如果考慮到字符串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}
...     return digits[s]
... 
>>> reduce(fn, map(char2num, '012'))
12
# 優化成一個函數
>>> DIGITS = {'0':0, '1':1, '2':2}
>>> def str2int(s):
...     def fn(x, y):
...         return x * 10 + y
...     def char2num(s):
...         return DIGITS[s]
...     return reduce(fn, map(char2num, s))
... 
>>> str2int('012')
12
# 繼續優化
>>> def char2num(s):
...     return DIGITS[s]
... 
>>> def str2int(s):
...     return reduce(lambda x, y: x * 10 + y, map(char2num, s))
... 
>>> str2int('012')
12

也就是說，假設Python沒有提供int()函數，你完全可以自己寫一個把字符串轉化為整數的函數，而且只需要幾行代碼！

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

1.2 filter

python內建的filter()函數用于過濾序列。
和map()類似，filter()也接收一個函數和一個序列。和map()不同的是，filter()把傳入的函數依次作用于每個元素。然后根據返回的值是True還是False決定保留還是丟棄該元素。
例如，在一個list中，刪掉偶數，只保留奇數，可以這樣寫：

>>> def is_odd(n):
...     return n%2 == 1
... 
>>> list(filter(is_odd, [1,2,3,4,5,6,7,8,9]))
[1, 3, 5, 7, 9]

可見用filter()這個高階函數，關鍵在于正確實現一個“篩選”函數；
注意到fitter()函數返回的是一個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, 5, 7, 9, 11, 13, 15, 17, 19 ...

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

5, 7, 11, 13, 17, 19 ...

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

7,11,13,17,19...
不斷篩下去，就可以得到所有的素數。
用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
2
3
5
7
11
13
17
...

1.3 sorted

排序算法

排序也是經常在程序中常用到的算法。無論使用冒泡排序還是快速排序，排序的核心都是比較兩個元素的大小。如果是數字，我們可以直接比較，但如果是字符串或者兩個dict呢？直接比較數學上的大小是沒有意義的。因此，比較的過程必須通過函數抽象出來。
python內置的sorted()函數就可以對list進行排序：

>>> sorted([34, -2, 32, 20])
[-2, 20, 32, 34]

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

>>> sorted([34, -2, -32, 20], key=abs)
[-2, 20, -32, 34]

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(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']

要進行反向排序，不必改動key函數，可以傳入第三個參數：

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

從上述例子可以看出，高階函數的抽象能力是非常強大的，而且，核心代碼可以保持得非常簡潔。

2.返回函數

函數作為返回值

高階函數除了可以接受函數作為參數外，還可以把函數作為結果返回。
實現一個可變參數的求和，通常情況下，求和的函數定義如下：

>>> 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,2,3,4,5)
>>> f
<function lazy_sum.<locals>.sum at 0x100ca5e18>
# f是一個函數，調用時才能真正計算求和的結果
>>> f()
15

在這個例子中，我們在函數lazy_sum中又定義了函數sum，并且，內部函數sum可以引用外部函數lazy_sum的參數和局部變量，當lazy_sum返回函數sum時，相關參數和變量都保存在返回的函數中，這種稱為“閉包（Closure）”的程序結構擁有極大的威力。

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

>>> f1 = lazy_sum(1,2,3,4,5)
>>> f2 = lazy_sum(1,2,3,4,5)
>>> 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))
...     return fs
... 
>>> f1,f2,f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9

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

3.匿名函數

當我們傳入函數時，有些時候，不需要顯式地定義函數，直接傳入匿名函數更方便。
在python中，對匿名函數提供了有限支持，還是以map()函數為例，計算f(x) = x^2 時，除了定義一個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 0x106d08e18>
>>> f(5)
25

同樣，也可以把匿名函數作為返回值返回，比如：

>>> def build(x, y):
...     return lambda: x * x + y * y
... 
>>> build(2 , 3)
<function build.<locals>.<lambda> at 0x106f36e18>
>>> build(2 , 3)()
13

4.裝飾器

由于函數也是一個對象，而且函數對象可以賦值給變量,所以通過變量也能調用該函數。

>>> def now():
...     print('2018-3-20')
... 
>>> f = now
>>> f()
2018-3-20
>>> 

函數對象有一個__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('2018-08-08')
... 
調用now()函數，不僅會運行now()函數本身，還會在運行now()函數前打印一行日志：
>>> now()
call now():
2018-08-08
>>> 

把@log放到now()函數的定義處，相當于執行了語句：

>>> now = log(now)

由于log()是一個decorator，返回一個函數，所以，原來的now()函數仍然存在，只是現在同名的now變量指向了新的函數，于是調用now()將執行新函數，即在log()函數中返回的wrapper()函數。

wrapper()函數的參數定義是(*args, **kw)，因此，wrapper()函數可以接受任意參數的調用。在wrapper()函數內，首先打印日志，再緊接著調用原始函數。

如果decorator本身需要傳入參數，那就需要編寫一個返回decorator的高階函數，寫出來會更復雜。比如，要自定義log的文本：

5.偏函數

python的functools模塊提供了很多有用的功能，其中一個就是偏函數(Partial function).要注意，這里的偏函數和數學意義上的不一樣，在介紹函數參數的時候，我們講到，通過設定參數的默認值，可以降低函數調用的難度。而偏函數也可以做到這一點。舉例如下：
int()函數可以把字符串轉換為整數，當僅傳入字符串時，int()函數默認按十進制轉換：

>>> int('123')
123

假設要轉換大量的二進制字符串，每次都傳入int(x, base=2)非常麻煩，于是，我們想到，可以定義一個int2()的函數，默認把base=2傳進去：

>>> def int2(x, base=2):
...     return int(x, base)
... 
>>> int2('1000000')
64
>>> int2('101010101')
341

所以，簡單總結functools.partial的作用就是，把一個函數的某些參數給固定住(也就是設置默認值)，返回一個新的函數，調用這個新函數會更簡單。注意到上面的init2函數，僅僅是把base參數重新設定默認值2，但也可以在函數調用時傳入其他值：

>>> int2('100000', base=10)
100000
>>> int2('100000', base=16)
1048576
>>> int2('100000', base=8)
32768

最后，創建偏函數時，實際上可以接收函數對象、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可以創建一個新的函數，這個新函數可以固定住原函數的部分參數，從而在調用時更簡單。