簡介

Python 是一種功能豐富的高級編程語言。它有通用的標準庫，支持多種編程語言范式，還有許多內部的透明度。如果你愿意，還可以查看 Python 的底層并修改，甚至能在程序運行的時候直接修改運行時。

我最近注意到一個有經驗的 Python 程序員使用 Python 的新方法。就像許多 Python 新手一樣，我在第一次看到 Python 時喜歡它的簡單易懂的基本循環、函數和類定義的語法。在掌握了基礎語法之后，我開始對高級功能感興趣，如繼承、生成器、元編程等。但是，我不太清楚它們的使用方法，經常會在不恰當的地方使用。有一段時間里我寫的代碼復雜又難理解。后來我反復修改，特別是需要長期在同一段代碼上工作時，最終會將大部分代碼慢慢改回使用基本的函數、循環、單例類。

盡管如此，那些高級功能一定有其存在的理由，它們也一定是非常重要的工具。很明顯，“怎樣編寫優秀的代碼”是個非常廣泛的話題，甚至沒有唯一的正確答案！相反，這篇文章的目標是一個特定的話題：Python 中函數式編程的應用。我將討論函數式是什么，怎樣在 Python 中使用，并根據我的經驗介紹最佳使用方法。

什么是函數式編程？

函數式編程（簡稱 FP）是一種編程范式，其中最基本的元素是不可修改的值，以及不與其他函數共享狀態的“純函數”。純函數對于給定的輸入永遠返回同樣的輸出，而且不會修改任何數據，也不會造成副作用。因此，純函數經常與數學運算比較。例如，3+4 永遠等于 7，不管同時進行了其他任何數學運算，也不管之前進行了多少次加法運算。

有了純函數和不可修改的值，程序員就可以創建邏輯結構了。迭代可以用遞歸代替，因為遞歸才是讓同一個動作多次執行的“函數式”做法。函數使用新的輸入調用自己，直到參數滿足某個終止條件。此外，還有高階函數，它的輸入是其他函數，返回另一個函數。我稍后會介紹這個概念。

盡管函數式編程從上世紀五十年代就出現了，而且許多語言也都實現了它，但它并沒有完全地描述一門語言。Clojure、Common Lisp、Haskell 和 OCaml 都是以函數式為主的語言，也都融合了其他不同的編程語言概念，如類型系統、嚴格或懶惰求值等。大多數語言還用某種方法支持副作用，如寫入文件、讀取文件等，通常這些副作用都被仔細地標記為“不純凈”。

人們通常都認為函數式很深奧，而且與可實踐性相比，它更看重優雅和簡潔。大公司很少會在大規模項目上依賴于函數式為主的語言，即使要用也是在較小的范圍內，遠遠不如其他 C++、Java、Python 等語言流行。但是，FP 實際上只是一種框架，一種考慮邏輯流的方式，它本身也有優點和缺點，而且也能與其他編程范式配合使用。

Python 支持什么？

盡管Python并不是以函數式為主的語言，但對它來說支持函數式編程也相對比較容易，因為Python中的一切都是對象。這意味著函數定義也可以賦給變量并傳遞。 

def add(a, b):  
 return a + b  
plus = add  
plus(3, 4) # returns 7 

Lambda

通過 Lambda 表達式的語法，可以用聲明式的方式創建函數。關鍵字 lambda 來自希臘字母，經常在正式的數學邏輯中用來描述函數和變量的虛擬綁定，即“lambda 演算”，它的歷史比函數式編程還要久遠。這一概念的另一個術語叫做“匿名函數”，因為 lambda 函數可以直接嵌入到行內使用，不需要事先指定名稱。將匿名函數賦值給變量后，它的行為與正常函數完全一樣。 

(lambda a, b: a + b)(3, 4) # returns 7  
addition = lambda a, b: a + b  
addition(3, 4) # returns 7 

lambda 函數最常見的用法就是提供給那些接受可調用對象作為參數的函數。“可調用對象”是任何能夠通過括號調用的東西，具體來說有類、函數和方法。其中最常見的用法就是在對數據結構進行排序時，通過參數的鍵指定排序的相對順序。 

authors = ['Octavia Butler', 'Isaac Asimov', 'Neal Stephenson', 'Margaret Atwood', 'Usula K Le Guin', 'Ray Bradbury']  
sorted(authors, key=len) # Returns list ordered by length of author name  
sorted(authors, key=lambda name: name.split()[-1]) # Returns list ordered alphabetically by last name. 

行內嵌入式 lambda 函數的缺點在于它不會在棧跟蹤中顯示名稱，可能會給調試帶來麻煩。

Functools

高階函數是函數式編程的精華，部分由 Python 直接提供，部分通過 functools 函數庫提供。你可能在大規模分布式數據分析方面聽說過 map 和 reduce，但實際上它們也是最重要的兩個高階函數。map 在給定序列的每個元素上執行函數，然后返回結果的序列；reduce 使用一個函數收集序列中的每個元素，然后返回單個值。 

val = [1, 2, 3, 4, 5, 6]  
# Multiply every item by two  
list(map(lambda x: x * 2, val)) # [2, 4, 6, 8, 10, 12]  
# Take the factorial by multiplying the value so far to the next item  
reduce(lambda: x, y: x * y, val, 1) # 1 * 1 * 2 * 3 * 4 * 5 * 6 

還有許多高階函數能用其他方式操作函數，其中最值得一提的就是 partial，它能鎖定函數的一部分參數。這種方式也叫做“currying”，這個術語來自函數式編程的先驅者 Haskell Curry： 

def power(base, exp):  
 return base ** exp  
cube = partial(power, exp=3)  
cube(5) # returns 125 

關于 Python 中的 FP 概念的具體介紹，以及怎樣優先使用函數式進行編程，我推薦 Mary Rose Cook 的這篇文章（https://maryrosecook.com/blog/post/a-practical-introduction-to-functional-programming）。

這些函數可以將許多行的循環轉變成極其精簡的一行代碼。但是，一般的程序員也很難理解這些代碼，特別是 Python 原本與英語十分類似的語法流。個人經驗，我永遠都記不住參數的順序，以及每個函數的功能，盡管我查了這么多次手冊。但我強烈建議嘗試一下這些函數，以了解一些 FP 的概念，而且有時候我認為它們才是正確的選擇，如下一節的例子所示。

修飾器

高階函數也以修飾器的形式融入了日常的 Python 編程中。定義修飾器的方法就反映了這一點，而@符號實際上只是個語法糖，將被修飾的函數傳遞給修飾器作為參數。下面就定義了一個簡單的修飾器，它會將給定的代碼重試三次，返回第一個成功的值，或者在三次嘗試都失敗之后放棄并拋出最后的異常。 

def retry(func):  
 def retried_function(*args, **kwargs):  
 exc = None  
 for _ in range(3):  
 try:  
 return func(*args, **kwargs)  
 except Exception as exc:  
 print("Exception raised while calling %s with args:%s, kwargs: %s. Retrying" % (func, args, kwargs).  
 raise exc  
 return retried_function  
@retry  
def do_something_risky():  
 ...  
retried_function = retry(do_something_risky) # No need to use `@` 

這個修飾器的輸入和輸出的類型和值完全一樣，但這并不是必須的。修飾器可以添加或減少參數，也可以改變參數的類型。它們也可以通過本身的參數進行配置。我想指出的是，修飾器本身不一定是“純函數”，它們可以（而且經常會）有副作用，只不過是恰巧使用了高階函數而已。

就像許多中級或高級 Python 技巧一樣，這個功能非常強大，但也很容易造成混亂。你必須使用 functools.wrap 修飾器進行修飾，否則調用的函數和棧跟蹤中看到的函數名字會不一樣。我見過一些修飾器會做一些非常復雜或非常重要的事情，如解析 json blob 中的值，或者處理認證。我還見過同一個函數或方法定義上的多層修飾器，必須掌握修飾器的應用次序才能正確理解。我認為通過利用內置的修飾器如“staticmethod”可以幫助理解，或者編寫最簡單的修飾器來避免大量樣板代碼，但如果你想讓你的代碼符合類型檢查的話，那么盡量不要去修改輸入或輸出的類型。

我的建議

函數式編程很有趣，而且學習舒適區之外的編程范式能夠為你帶來靈活性，而且也可以讓你從另一個角度考慮問題。但是，我不推薦使用 Python 時以函數式為主，特別是在舊的代碼庫中不要這么做。除了上面我提到的那些坑之外，還有下面的理由：

•  開始使用 Python 不需要理解 FP。這樣做很可能會迷惑其他閱讀者，或者迷惑未來的自己。
•  你無法保證任何你依賴的代碼（通過 pip 安裝的模塊，或其他同事的代碼）是函數式的，是純凈的。你也不知道你自己的代碼是否像你想象的那么純凈。與函數式為主的語言不同，Python 的語法或編譯器不會幫你強制純凈，也不會幫你消滅某些 Bug。將副作用和高階函數混合在一起回導致巨大的混亂，因為你需要論證兩種不同的復雜性，其難度是兩者的乘積。
•  使用帶有類型注釋的高階函數是高級技巧。類型簽名通常是又長又笨拙的“Callable”的嵌套。例如，一個簡單的返回輸入函數的高階修飾器，其定義是“F = TypeVar[‘F’, bound=Callable[..., Any]]”，然后標注是“def transparent(func: F) -> F: return func”。也許你懶得研究正確的簽名的寫法，而直接使用“Any”代替了。

那么，我們應該使用函數式編程的哪部分呢？

純函數

只要可能并且合理，就應該盡量保持函數“純凈”，并仔細考慮應當在何處保持改變了的狀態，并仔細地標記好。這樣能讓單元測試變得更容易，你不需要做太多 set-up 和 tear-down，也不需要太多 mocking，而且測試用例不論執行順序如何，都會產生預期中的結果。

下面是個非函數式的例子。 

dictionary = ['fox', 'boss', 'orange', 'toes', 'fairy', 'cup']  
def puralize(words):  
 for i in range(len(words)):  
 word = words[i]  
 if word.endswith('s') or word.endswith('x'):  
 word += 'es'  
 if word.endswith('y'):  
 wordword = word[:-1] + 'ies'  
 else:  
 word += 's'  
 words[i] = word  
def test_pluralize():  
 pluralize(dictionary)  
 assert dictionary == ['foxes', 'bosses', 'oranges', 'toeses', 'fairies', 'cups'] 

第一次運行 test_pluraize 時該測試能夠通過，但以后每次運行都會失敗，因為它會反復添加“s”和“es”。為了讓它變成純函數， 可以這樣寫： 

dictionary = ['fox', 'boss', 'orange', 'toes', 'fairy', 'cup']  
def puralize(words):  
 result = []  
 for word in words:  
 word = words[i]  
 if word.endswith('s') or word.endswith('x'):  
 plural = word + 'es')  
 if word.endswith('y'):  
 plural = word[:-1] + 'ies'  
 else:  
 plural = + 's'  
 result.append(plural)  
 return result  
def test_pluralize():  
 result = pluralize(dictionary)  
 assert result == ['foxes', 'bosses', 'oranges', 'toeses', 'fairies', 'cups'] 

注意這里并沒有使用任何 FP 特有的概念，只是創建并返回了一個新的對象，而不是重用并修改已有的舊對象。這樣輸入的內容也會保持不變。

雖然這個例子像個玩具，但想象一下，如果你傳遞并改變了某個復雜的對象，或者通過數據庫連接進行了某些操作。當編寫很多很多測試用例時就會發現，你必須非常小心地處理測試用例的順序，或者花大量代價在每個測試用例之后清除并重新創建狀態。這些工作應該是在 e2e 集成測試階段的活兒，不應該在比較小的單元測試階段進行。

理解（并避免）可修改性

先來個調查，你認為哪些數據結構是可修改的？

為什么這一點很重要？有些時候列表和元組可以互換使用，因此人們經常會在代碼中隨機使用兩者之一。于是當你試圖修改一個元組（比如給其中一個元素賦值）時就會出錯?；蛘咴噲D用列表作為字典的鍵，也會導致 TypeError，因為列表是可修改的。元組和字符串可以作為字典的鍵使用，因為它們不可修改，可以得到確定的哈希值，而其他數據結構都不行，因為它們的對象標識即使保持不變，值也會改變。

最重要的是，在傳遞字典、列表或集合時，它們可能會在其他上下文中被意料之外地改變。這種問題非常難以調試?？尚薷牡哪J參數就是個經典的例子： 

def add_bar(items=[]):  
 items.append('bar')  
 return items  
l = add_bar() # l is ['bar']  
l.append('foo')  
add_bar() # returns ['bar', 'foo', 'bar'] 

字典、集合和列表很強大、效率很高、非常 Python，而且非常有用。寫代碼時完全不使用它們是不明智的。但即使如此，我永遠會在默認參數的位置使用元組或 None（代替空字典或空列表），并且在缺乏足夠的防御代碼的情況下，避免將可修改的數據結構在不同的上下文中傳遞。

減少類的使用

類（及其實例）的可修改性是把雙刃劍。隨著寫的 Python 代碼越來越多，我開始傾向于僅在絕對必要時才使用類，而且我幾乎從不使用可修改的類屬性。對于那些高度面向對象的語言（如 Java）的程序員來說這一點可能很難做到，但許多其他語言中在類層面完成的東西，在 Python 可以在模塊層面完成。例如，如果需要將函數或常量或命名空間分組，那么可以把它們一起放到另一個 .py 文件中。

我經?？吹揭恍╊惖哪康氖潜４鎺讉€命名變量的值，這種情況下 namedtuple（其類型是 typing.NamedTuple）就足夠，而且還是不可改變的。 

from collections import namedtuple  
VerbTenses = namedtuple('VerbTenses', ['past', 'present', 'future'])  
# versus  
class VerbTenses(object):  
 def __init__(self, past, present, future):  
 self.past = past,  
 self.present = present  
 self.future = future 

如果確實需要狀態的來源，而且多個視圖都需要改變該狀態，那么類是絕佳的選擇。此外，與靜態方法相比，我更傾向于單例純函數，這樣它們能在其他上下文中組合使用。

可修改的類屬性非常危險，因為它們屬于類定義而不是類實例，因此可能會不小心修改到同一個類的多個實例中的狀態！ 

class Bus(object):  
 passengers = set()  
 def add_passenger(self, person):  
 self.passengers.add(person)  
bus1 = Bus()  
bus2 = Bus()  
bus1.add_passenger('abe')  
bus2.add_passenger('bertha')  
bus1.passengers # returns ['abe', 'bertha']  
bus2.passengers # also ['abe', 'bertha'] 

冪等性

任何實際的大規模復雜系統都可能會失敗，而失敗就要重試。矩陣代數中的“冪等性”的概念也存在于 API 設計中，但對于函數式編程來說，傳遞之前的輸出給冪等函數，永遠會返回相同的值。因此，重做某件事情會收斂到相同的值。因此，上述 pluralize 函數更理想的寫法為：，首先檢查輸入是否已是復數，再考慮怎樣計算出復數形式。

lambda 和高階函數使用上的注意點

我發現，在進行短小的操作（如獲取排序的鍵供 sort 使用）時使用 lambda 非常方便。但如果 lambda 超過一行，那么使用普通的函數定義可能更好。通常傳遞函數可以避免重復，但我在使用時經常提醒自己，額外的結構是否會讓代碼清晰度下降。通常，將其分解成更小的輔助函數會更清晰。

在需要時使用生成器和高階函數

有時候你會遇到抽象的生成器和迭代器，它們可能會返回巨大或者無限的序列。一個例子就是 range。在 Python 3 中，range 默認是生成器（相當于Python 2 中的 xrange），避免在迭代大數字時出現內存不足的錯誤，如range(10 ** 10)。如果要在一個可能很大的生成器的每個元素上執行某個操作，那么使用 map、filter 之類的工具可能是最好的選擇。

與此相似，如果不知道你新寫的迭代器可能會返回多少結果，但可能會很大，那就應該定義一個生成器。但是，并不是每個人都愿意去使用生成器，他們可能更希望使用列表解析式（list comprehension），從而導致你一開始想要避免的內存不足錯誤。生成器是 Python 對于流式編程的實現，它也不一定是函數式的，所以它也有其他 Python 編程方式擁有的安全性缺陷。

結論

通過瀏覽功能、庫和內部代碼來理解自己選擇的編程語言，毫無疑問能幫你在調試和閱讀代碼方面提高速度。理解其他語言或編程語言理論方面的思想也很有意思，而且能讓你成為更強大、無所不通的程序員。但是，成為Python的高級程序員意味著你不僅要知道能做什么，更要理解哪種才是最有效的方式。在Python中應用函數式編程可能很容易。為了保持優雅，特別是在共享的代碼中保持優雅，我認為最好是使用純粹的函數式思想，讓代碼更容易預測，從而更容易維護，并且具有冪等性。