Python函數式編程

時間 2019-11-13

標籤 python 函數編程欄目 Python 简体版

原文原文鏈接

轉自http://www.jackyshen.com/2014/10/02/functional-programming-in-Python/

函數式編程

若是程序中的函數僅接受輸入併產生輸出，即輸出只依賴於輸入，內部數據不可變，避免保存程序狀態，用一樣的輸入值反覆調用能夠獲得相同的結果，那麼這種編程範式就稱爲函數式編程(Functional Programming，簡稱FP，又稱泛函編程)。javascript

這種風格也稱聲明式編程(Declarative Programming)，與之相對的是指令式編程(Imperative Programming)，後者中的對象會不斷修改自身狀態。函數式編程強調程序的執行結果比執行過程更重要，倡導利用若干簡單的執行單元讓計算結果不斷漸進，逐層推導複雜的運算，而不是設計一個複雜的執行過程。html

函數編程語言最重要的基礎是λ演算（lambda calculus），函數能夠像數值同樣被賦值於變量，還能夠做爲其餘函數的輸入（引數）和輸出（傳出值）進行傳遞。前端

函數式編程歷史悠久，最古老的例子莫過於1958年被創造出來的LISP了。而隨着程序結構複雜，面向對象編程大行其道。近年來，簡潔並且特別適合計算任務的函數式編程又從新崛起，不只僅是純粹的函數式語言如Haskell、Clojure、Elixir等，各類流行語言javascripts、python、Objective-C、C#、Swift甚至Java都紛紛吸取函數式編程的部分形式。並且，不只僅是計算任務，近年還出現了用FP編寫的UI應用程序，如LightTable等。java

Paul Graham在《黑客與畫家》一書中寫道：一樣功能的程序，極端狀況下，Lisp代碼的長度多是C代碼的二十分之一。python

本文做者@申導主要採用Python語言爲例，是由於它雖然不是純粹的FP，但Python可以勝任各類編程形式，簡潔優雅，通俗易懂，語法接近於Java/C++，特別適合從主流語言轉過來的學習者。shell

純函數(Pure functions)

純函數指的是沒有依賴於外部內存或I/O，函數間無共享變量（與面向對象範式有所不一樣），即不帶有反作用(side-effect)的函數。每次調用函數都會返回新值，而不會修改原來的變量，這也稱爲不變性(Immutable)，想象如下在Java中將每個入參變量都聲明爲final的情景。
這樣的函數沒有隱含指望，也便於進行黑盒測試。express

來看個非函數式的例子，它改變了變量的值。編程

int cnt;
void inc() {
 cnt++;
}

函數式的例子，不改變變量的值，而是返回一個新值。緩存

int cnt;
int inc() {
 return cnt+1;
}

這個特色能夠用來優化代碼。例如，一個無反作用的純函數，其執行結果具備不變性，那麼其執行結果就能夠緩存起來，供下次調用。再好比，兩個互不依賴的純函數，其執行順序能夠互換，甚至並行地執行而無需互斥。數據結構

在python中，不可變的元組(tuple)數據結構特別適合函數式編程。

高階函數(Higher-order functions)

在FP中，首要特色就是將函數視爲一等公民，函數能夠當作參數來進行傳遞，造成所謂的高階函數，形如 z=g(f(x),y)，還能像變量同樣被建立和修改。

讀者若是使用過C語言，必定記得標準庫中的快排函數，其中第4個參數是一個函數指針，用於傳入一個比較(compare)函數，而排序動做被抽象成了一個模板函數。這就是一個典型的高階函數：qsort(compare(items))

1	void qsort(void items, size_t nitems, size_t size, int (compare)(const void , const void));

若是你寫過前端網頁，那麼對如下javascript代碼確定不陌生:

1
2
3

setTimeout(function() {
 alert("Another tick");
}, 1000);

這種形式在非純粹的函數式編程語言裏面多有吸取，用於簡化語法。連最古板的面嚮對象語言Java也終於在Java8中引入了lambda。

lambda(匿名λ函數)

使用lambda能夠定義簡單的單行匿名函數。lambda的語法以下：lambda args: expression

lambda_add = lambda x, y: x + y

def normal_add(x,y):
 return x+y
 
assert lambda_add(2,3) == normal_add(2,3)

匿名λ函數與使用def定義的函數徹底同樣，可使用lambda_add做爲函數名進行調用。然而，提供lambda的目的是爲了編寫偶爾爲之的、簡單的、可預見不會被修改的匿名函數。

reduce函數

考慮一個求和的例子，通常會採用循環：

def my_sum(numbers):
 total = 0
 for x in numbers:
 total = total + x
 return total

my_sum(range(1, 100))

若是再求乘積呢？

def my_product(numbers):
 total = 1
 for x in numbers:
 total = total * x
 return total

my_product(range(1, 100))

想到DRY原則，上述兩段函數存在了很多重複。咱們看到除了初始值和運算符不一樣，其實總體的流程是差很少的，那麼概括(reduce)一下如何？

def my_reduce(numbers, function, initial):
 total = initial
 for x in numbers:
 total = function(total, x)
 return total
 
my_reduce(range(1, 100), lambda t,x: t+x, 0)
my_reduce(range(1, 100), lambda t,x: t*x, 1)

Python內置的reduce(function, iterable[, initializer])函數已經實現了對列表元素依次概括的場景，而內置的all(),any(),sum(),max(),min()等函數都是基於它衍生而來。

map、zip、filter、sorted函數

Python內置函數還有map(function, iterable, ...)了，它抽象了另外一種情景，即遍歷列表中的每一個元素，對每一個元素執行傳入的函數，並返回包含全部新元素的新列表。

而zip(iterable1, iterable2, ...)函數則對多個列表進行合併，每一個列表的第n個元素組成一個元組(tuple)，而後返回包含這些元組的新列表

filter(function, iterable)函數的功能是遍歷列表，若是以元素做爲參數調用function時返回True的話則將其過濾出來，最後返回包含全部過濾出的元素的新列表。

sorted(iterable, ...)顧名思義，這就是排序函數。排序天生就是一個函數行爲，徹底不必放到什麼類中。

簡化代碼

有了這些內置函數，你的代碼會變得更簡潔，沒有了循環體，數據集，操做，返回值都放到了一塊兒。特別是用了reduce()之後，連for,while循環都省了。例如，下列函數能夠替代for語句來達到循環5次調用f(x)的目的。

def f(a):
 print a

print reduce(lambda _, x: f(x), range(5), 0)

再看個例子，咱們有3輛車比賽，簡單起見，咱們分別給這3輛車有70%的機率能夠往前走一步，一共有5次機會，咱們打出每一次這3輛車的前行狀態。用指令式編程的代碼以下：

from random import random
 
time = 5
car_positions = [1, 1, 1]
 
while time:
 # decrease time
 time -= 1
 
 print ''
 for i in range(len(car_positions)):
 # move car
 if random() > 0.3:
 car_positions[i] += 1
 
 # draw car
 print '-' * car_positions[i]

若是改用函數式或稱指令式編程，則是這樣的：

1
2
3

from random import random
L = [0]*3
reduce(lambda ll,_: map(lambda x:(x+1) if random() > 0.3 else x, ll), range(5), L)

再看看用FP模擬Unix下的echo命令：

def monadic_print(x):
 print x
 return x
 
echo_FP = lambda: monadic_print(raw_input("FP -- "))=='quit' or echo_FP()
echo_FP()

偏函數(Partial function)與柯里化(Currying)

柯里化(Currying)技術是把接受多個參數的函數變換成只接受部分參數（好比原函數的第一個參數）的函數，而且返回接受餘下的參數的新函數，新函數稱爲偏函數。
形如：f(x,y) ==> f(x)(y)，可用於批量生成類似的函數。思考一下：平方函數與立方函數的抽象關係是如何的？

Python不像Scala語言那樣支持Currying。然而稍做變通便可達到生成偏函數的效果：

def add(x, y):
 return x + y

def add_to(n):
 return lambda x: add(n, x)

assert add(3, 2) == add_to(3)(2)

但Python內置的functools模塊提供了一個函數partial，能夠爲任意函數生成偏函數：
functools.partial(func[, *args][, **keywords])

1
2
3

import functools
f3 = functools.partial(add, 3)
assert add(3, 2) == f3(2)

閉包(Closure)

若是一個函數定義在另外一個函數的做用域內，而且引用了外層函數的變量，則該函數稱爲閉包。下例中inner()就是一個閉包，自己是一個函數，並且能夠訪問(在python2.x中是隻讀的)自己以外的變量n。

def f():
 n = 1
 def inner():
 print n
 return inner
 
f()()

函數裝飾器(Decorator)

Python的Decorator(函數裝飾器)在功能上相似Java的函數註解(Annotation)。它首先是個閉包，存放了fn及自定義的變量。而後再返回一個wrapper函數，真正對fn及fn的參數進行AOP處理。若是要使用帶參數的decorator還須要多包裹一層，先返回一個保存着decorator參數的閉包，再返回一個保存了fn的閉包。

看一個通俗的計算函數運行時間的例子，其中對於運行時間的統計與原功能作到了分離：

import time
 
def timeit(func):
 def wrapper():
 start = time.clock()
 func()
 end =time.clock()
 print 'used:', end - start
 return wrapper

@timeit
def foo():
 print 'in foo()'
 
foo()

再看一個計算斐波那契數列的例子，每次遞歸都會有重複計算，若是能講中間結果記錄下來就能夠提升性能。(增長了可選的 @warps 是爲了不一些反作用，好比func.name等屬性保持爲原函數的名字而非wrapper，防止採用反射時遇到問題。)

from functools import wraps
def memo(fn):
 cache = {}
 miss = object()
 
 @wraps(fn)
 def wrapper(*args, **kwargs):
 result = cache.get(args, miss)
 if result is miss:
 result = fn(*args)
 cache[args] = result
 return result
 
 return wrapper
 
@memo
def fib(n):
 if n < 2:
 return n
 return fib(n - 1) + fib(n - 2)

實質上，@decorator寫法實際上是高階函數的語法糖，每一次裝飾都生成了一個新的函數。下例中的兩種寫法是等價的：

@decorator_one
@decorator_two
def fn():
 pass
 
func = decorator_one(decorator_two(fn))

@decorator_one(arg1, arg2)
@decorator_two
def fn(param1):
 pass

func = decorator_one(arg1, arg2) (decorator_two (fn) )

遞歸(Recursion)

在FP中，一般經過遞歸來實現循環。遞歸函數會不斷調用自身，直到到達最基本的條件。

看個用線性遞歸代替循環來求和的例子(從1…5循環)：

def lsum(f, a, b):
 if (a>b):
 return 0
 else:
 return f(a)+lsum(f, a+1, b)

print lsum(lambda x:x, 1, 5)

尾遞歸(Tail Recursion)

因爲每次線性遞歸(Linear Recursive)調用都須要維護一個棧(stack)，來保存臨時狀態，所以大量遞歸會帶來性能問題，可是利用尾遞歸(Tail Recursive)能夠進行優化，每次遞歸經過傳參的方式來傳遞狀態，減小stack佔用。若是編譯器支持的話，還能夠將遞歸形式展開優化爲while循環的形式(目前Python編譯器暫不支持該優化)。下例中變量acc在每次遞歸後都會將最新狀態帶入下一次遞歸。

def tsum(f, a, b):
 def loop(a, acc):
 if a>b:
 return acc
 else:
 return loop(a+1, acc+f(a))
 return loop(a,0)

print tsum(lambda x:x, 1, 5)

嚴格與非嚴格求值、惰性求值

FP語言能夠分爲嚴格（及早）求值與非嚴格（惰性）求值(Strict vs. Non-strict evaluation)，區別在於對錶達式求值的時機。看下面這個例子：

1	print len([2+1, 3*2, 1/0, 5-4])

在Python中執行上述語句會報錯，由於以0爲除數是非法的。能夠看出Python對於數值運算是嚴格求值的，而像Haskell的默認方式就是非嚴格求值，於是上述語句的執行結果就是4，即列表的長度。

而Python中也存在惰性求值的語法，好比相對於range(n)函數，xrange(n)是其惰性版本。
再如相對於列表生成器[x+1 for x in range(5)]，惰性版本能夠寫成(x+1 for x in range(5))。你能夠print一下，看看二者的區別。

支持惰性求值的編譯器會像數學家看待代數表達式那樣看待函數式程序：抵消相同項從而避免執行無謂的代碼，安排代碼執行順序從而實現更高的執行效率甚至是減小錯誤。

惰性求值技術容許定義無窮數據結構，由於只有真正會被用到的數纔會被計算出來。

迭代器 (Iterator)

只要實現了__next__()函數的類，均可成爲迭代器，每次調用next()函數，就應當返回序列中的下一個值。內置的數據結構如tuple、list、dict、set等都已經實現了迭代器。

對於列表，for循環一般是以遍歷迭代器的形式，好比要從1~5循環，能夠寫成：

1 2	for i in [1,2,3,4,5]: pass

對於列表，若是還想得到循環的索引，能夠這樣寫：

1 2	for i, index in enumerate([1,2,3,4,5]): pass

對於字典，能夠這樣遍歷：

1 2	for k, v in {'a':1, 'b':2}.items(): pass

內置的itertools庫提供了更有效更豐富的迭代器，包括去重、笛卡爾積、無限迭代、條件迭代。同時還有各類內置函數的惰性版本，好比相對於map()的imap()等。

開源庫Fn.py庫也實現了無限序列等。

列表生成器的解析

列表生成器可用來快速生成列表，能夠代替map()或filter()的使用。(注意例子中用的是嚴格求值的方式，不然還須要一次遍歷才能展開列表)

好比下例中的寫法是等價的：

[x+1 for x in range(5)]
map(lambda x:x+1, range(5))

[x for x in range(10) if x%2==0]
filter(lambda x:x%2==0, range(10))

若是是多重循環解析，則能夠寫成：(注意例子中能夠用惰性求值的方式)

1	((x, y) for x in range(3) for y in range(x))

若是是組合循環解析，則能夠寫成：(注意例子中能夠用惰性求值的方式)

1	(x for x in (y.doSomething() for y in lst) if x>0)

生成器(Generator)

生成器是一個特殊的迭代器，須要用到yield關鍵字。包含該關鍵字的函數會自動成爲一個生成器對象。裏面的代碼通常是一個有限或無限循環結構，每當調用該函數時，會執行到yield代碼爲止並返回本次迭代結果。而後凍結(freeze)在這一行，直到外部調用者的下一次調用該函數時，再返回下一次迭代結果。經過這種方式，迭代器能夠實現惰性求值。

看一個用生成器來計算斐波那契數列的例子。其中求值函數是一個無限循環的生成器，而外部調用該生成器時，須要顯式地控制迭代次數。

def fibonacci():
 a = b = 1
 yield a
 yield b
 while True:
 a, b = b, a+b
 yield b

for num in fibonacci(): 
 if num > 100: break
 print num,

另外一例是牛頓法開平方根，而每次迭代都會更加逼近真實值。下例是生成器與尾遞歸兩種寫法的比較，其中生成器內是一個有條件循環。(」_」是合法變量名，用做變量佔位符，最後一行的reduce至關於for循環的做用)

def square(k):
 guess=1
 yield guess
 while abs(guess*guess-k)>0.001:
 guess=(guess+k/guess)/2.0
 yield guess
 return
for z in square(2):
 print z


def improve(guess, k):
 return (guess+k/guess)/2.0
print reduce(lambda guess, _: improve(guess, 2), range(4), 1)

再看一箇中序(inorder)遍歷二叉樹的例子，裏面用到了生成器的遞歸嵌套：

class Tree:
 def __init__(self,left, label, right) :
 self.left = left;
 self.label = label;
 self.right = right;

def inorder(t):
 if t is not None:
 for x in inorder(t.left): yield x
 yield t.label
 for x in inorder(t.right): yield x

def make_tree(array):
 if len(array) == 1:
 return Tree(None, array[0], None)
 return Tree(make_tree(array[0]), array[1], make(array[2]))

tree = make_tree([[['a'], 'b', ['c']], 'd', [['e'], 'f', ['g']]])
print [n for n in inorder(tree)]

管道式表達式

函數嵌套調用，看起來沒有那麼清爽。若是能將數據當作流，函數之間像shell裏面的管道同樣來傳遞數據，結果會更清楚一些。下段代碼示例揭示了其中的原理，經過在裝飾器中重載__ror__運算符(從右向左進行」或」操做)而且返回一個迭代器來作到這一點，因而，函數也就能夠經過|運算符來互相操做了。

class Pipe(object):
 def __init__(self, func):
 self.func = func
 
 def __ror__(self, other):
 def generator():
 for obj in other:
 if obj is not None:
 yield self.func(obj)
 return generator()
 
@Pipe
def even_filter(num):
 return num if num % 2 == 0 else None
 
@Pipe
def multiply_by_three(num):
 return num*3
 
@Pipe
def convert_to_string(num):
 return 'The Number: %s' % num
 
@Pipe
def echo(item):
 print item
 return item
 
def force(sqs):
 for item in sqs: pass
 
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
force(nums | even_filter | multiply_by_three | convert_to_string | echo)

這正是開源庫pipe.py所實現的管道式調用/流式操做。這種方式也比較適合參數校驗、判空等場景。pipe.py的用法更加簡潔一些：

from pipe import * 

range(5) | add

fibonacci() | where(lambda x: x % 2 == 0) | take_while(lambda x: x < 10000) | add

@Pipe
def take_while_idx(iterable, predicate): 
 for idx, x in enumerate(iterable):
 if predicate(idx): yield x
 else: return

fibonacci() | take_while_idx(lambda x: x < 10) | as_list

用pipe和itertools從新實現一下以前的賽車題目：

from random import random
from pipe import *
import itertools

print itertools.count(1) | take(5) | aggregate(lambda ll,_: ll | select(lambda x:(x+1) if random() > 0.3 else x), initializer=[0]*3) | as_list