Python函數式編程：從入門到走火入魔
很多人都在談論函數式編程（Functional Programming），只是很多人站在不同的角度看到的是完全不一樣的風景。堅持實用主義的 Python 老司機們對待 FP 的態度應該更加包容，雖然他們不相信銀彈，但冥冥中似乎能感覺到 FP 暗合了 Python 教義（The Zen of Python）的某些思想，而且既然 Python 是一門多范式編程語言，并在很大程度上支持函數式編程，那就更沒有理由拒絕它。
函數式編程源自于數學理論，它似乎也更適用于數學計算相關的場景，因此本文以一個簡單的數據處理問題為例，逐步介紹 Python 函數式編程從入門到走火入魔的過程。
問題：計算 N 位同學在某份試卷的 M 道選擇題上的得分（每道題目的分值不同）。
首先來生成一組用于計算的偽造數據：
# @file: data.py
import random
from collections import namedtuple
Student = namedtuple('Student', ['id', 'ans'])
N_Questions = 25
N_Students = 20
def gen_random_list(opts, n):
return [random.choice(opts) for i in range(n)]
# 問題答案 'ABCD' 隨機
ANS = gen_random_list('ABCD', N_Questions)
# 題目分值 1~5 分
SCORE = gen_random_list(range(1,6), N_Questions)
QUIZE = zip(ANS, SCORE)
students = [
# 學生答案為 'ABCD*' 隨機，'*' 代表未作答
Student(_id, gen_random_list('ABCD*', N_Questions))
for _id in range(1, N_Students+1)
]
print(QUIZE)
# [('A', 3), ('B', 1), ('D', 1), ...
print(students)
# [Student(id=1, ans=['C', 'B', 'A', ...
入門
首先來看常規的面向過程編程風格，我們需要遍歷每個學生，然后遍歷每個學生對每道題目的答案并與真實答案進行比較，然后將正確答案的分數累計：
import data
def normal(students, quize):
for student in students:
sid = student.id
score = 0
for i in range(len(quize)):
if quize[i][0] == student.ans[i]:
score += quize[i][1]
print(sid, '\t', score)
print('ID\tScore\n==================')
normal(data.students, data.quize)
"""
ID Score
==================
1 5
2 12
...
"""
如果你覺得上面的代碼非常直觀且合乎邏輯，那說明你已經習慣按照計算機的思維模式進行思考了。通過創建嵌套兩個 for 循環來 遍歷 所有題目答案的判斷和評分，這完全是為計算機服務的思路，雖然說 Python 中的 for 循環已經比 C 語言更進了一步，通常不需要額外的狀態變量來記錄當前循環的次數，但有時候也不得不使用狀態變量，如上例中第二個循環中比較兩個列表的元素。函數式編程的一大特點就是盡量拋棄這種明顯 循環遍歷 的做法，而是把注意集中在解決問題本身，一如在現實中我們批改試卷時，只需要將兩組答案 并列 進行比較即可：
from data import students, QUIZE
student = students[0]
# 將學生答案與正確答案合并到一起
# 然后過濾出答案一致的題目
filtered = filter(lambda x: x[0] == x[1][0], zip(student.ans, QUIZE))
print(list(filtered))
# [('A', ('A', 3)), ('D', ('D', 1)), ...]
然后再將所有正確題目的分數累加起來，即可：
from functools import reduce
reduced = reduce(lambda x, y: x + y[1][1], filtered, 0)
print(reduced)
以上是對一位學生的結果處理，接下來只需要對所有學生進行同樣的處理即可：
def cal(student):
filtered = filter(lambda x: x[0] == x[1][0], zip(student.ans, QUIZE))
reduced = reduce(lambda x, y: x + y[1][1], filtered, 0)
print(student.id, '\t', reduced)
print('ID\tScore\n==================')
# 由于 Python 3 中 map 方法只是組合而不直接執行
# 需要轉換成 list 才能將 cal 方法的的結果打印出來
list(map(cal, students))
"""
ID Score
==================
1 5
2 12
...
"""
上面的示例通過 zip/filter/reduce/map 等函數將數據處理的方法 打包 應用到數據上，實現了基本的函數式編程操作。但是如果你對函數式有更深入的了解，你就會發現上面的 cal 方法中使用了全局變量 QUIZE ，這會導致在相同輸入的條件下，函數可能產生不同的輸出，這是 FP 的大忌，因此需要進行整改：
def cal(quize):
def inner(student):
filtered = filter(lambda x: x[0] == x[1][0], zip(student.ans, quize))
reduced = reduce(lambda x, y: x + y[1][1], filtered, 0)
print(student.id, '\t', reduced)
return inner
map(cal(QUIZE), students)
如此借助閉包（Closure）的方法，就可以維持純凈的 FP 模式啦！
走火（fn.py)
也許看了上面的 FP 寫法，你還是覺得挺啰嗦的，并沒有達到你想象中的結果，這時候就需要呈上一款語法糖利器： fn.py ！ fn.py 封裝了一些常用的 FP 函數及語法糖，可以大大簡化你的代碼！
pip install fn
首先從剛剛的閉包開始，我們可以用更加 FP 的方法來解決這一問題，稱為 柯里化 ，簡單來說就是 允許接受多個參數的函數可以分次執行，每次只接受一個參數 ：
from fn.func import curried
@curried
def sum5(a, b, c, d, e):
return a + b + c + d + e
sum3 = sum5(1,2)
sum4 = sum3(3,4)
print(sum4(5))
# 15
應用到上面的 cal 方法中：
from fn.func import curried
@curried
def cal(quize, student):
filtered = filter(lambda x: x[0] == x[1][0], zip(student.ans, quize))
reduced = reduce(lambda x, y: x + y[1][1], filtered, 0)
print(student.id, '\t', reduced)
map(cal(QUIZE), students)
在 FP 中數據通常被看作是一段數據流在一串函數的管道中傳遞，因此上面的 reduce 和 filter 其實可以合并：
reduce(lambda x, y: x + y[1][1], filter(lambda x: x[0] == x[1][0], zip(student.ans, quize)), 0)
雖然更簡略了，但是這樣會大大降低代碼的可讀性（這也是 FP 容易遭受批評的一點），為此 fn 提供了更高級的函數操作工具：
from fn import F
cal = F() >> (filter, lambda x: x[0]==x[1][0]) >> (lambda r: reduce(_+_[1][1], r, 0))
# 計算一名學生的成績
print(cal(zip(student.ans, QUIZE)))
# 然后組合一下
@curried
def output(quize, student):
cal = F() >> (filter, lambda x: x[0]==x[1][0]) >> (lambda r: reduce(_+_[1][1], r, 0))
print(student.id, '\t', cal(zip(student.ans, quize)))
map(output(QUIZE), students)
入魔（Hy）
如果你覺得上面的代碼已經足夠魔性到看起來不像是 Python 語言了，然而一旦接受了這樣的語法設定感覺也還挺不錯的。如果你興沖沖地拿去給 Lisp 或 Haskell 程序員看，則一定會被無情地鄙視:joy:，于是你痛定思痛下定決心繼續挖掘 Python 函數式編程的奧妙，那么恭喜你，組織歡迎你的加入： Hail Hydra ！
哦不對，說漏了，是 Hi Hy ！
Hy 是基于 Python 的 Lisp 方言，可以與 Python 代碼進行完美互嵌（如果你更偏好 PyPy，同樣也有類似的 Pixie ），除此之外你也可以把它當做一門獨立的語言來看待，它有自己的解釋器，可以當做獨立的腳本語言來使用：
pip install git+https://github.com/hylang/hy.git
首先來看一下它的基本用法，和 Python 一樣，安裝完之后可以通過 hy 命令進入 REPL 環境：
=> (print "Hy!")
Hy!
=> (defn salutationsnm [name] (print (+ "Hy " name "!")))
=> (salutationsnm "YourName")
Hy YourName!
或者當做命令行腳本運行：
#! /usr/bin/env hy
(print "I was going to code in Python syntax, but then I got Hy.")
保存為 awesome.hy ：
chmod +x awesome.hy
./awesome.hy
接下來繼續以上面的問題為例，首先可以直接從 Python 代碼中導入：
(import data)
;; 用于 Debug 的自定義宏
;; 將可迭代對象轉化成列表后打印
(defmacro printlst [it]
`(print (list ~it)))
(setv students data.students)
(setv quize data.QUIZE)
(defn cal [quize]
(fn [student]
(print student.id
(reduce
(fn [x y] (+ x (last (last y))))
(filter
(fn [x] (= (first x) (first (last x))))
(zip student.ans quize))
0
)
)
)
)
(printl (map (cal quize) students))
如果覺得不放心，還可以直接調用最開始定義的方法將結果進行比較：
;; 假設最上面的 normal 方法保存在 fun.py 文件中
(import fun)
(.normal fun students quize)
總結
以一個簡單的數據處理問題為例，我們經歷了 Python 函數式編程從開始嘗試到“走火入魔”的整個過程。也許你還是覺得不夠過癮，想要嘗試更 純粹 的 FP 體驗，那么 Haskell 將是你最好的選擇。FP 將數據看做數據流在不同函數間傳遞，省去不必要的中間變量，保證函數的純粹性…等等這些思想在數據處理過程中還是非常有幫助的（Python 在這一領域的競爭對手 R 語言本身在語法設計上就更多地受到 Lisp 語言的影響，雖然看起來語法也比較奇怪，但這也是它比較適合用于數據處理及統計分析的原因之一）。
參考
來自：http://blog.rainy.im/2016/12/04/fp-with-py/