簡介

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

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

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

什么是函數(shù)式編程？

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

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

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

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

Python 支持什么？

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

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

Lambda

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

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

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

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. 

行內(nèi)嵌入式 lambda 函數(shù)的缺點在于它不會在棧跟蹤中顯示名稱，可能會給調(diào)試帶來麻煩。

Functools

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

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 

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

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

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

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

修飾器

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

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 `@` 

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

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

我的建議

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

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

那么，我們應(yīng)該使用函數(shù)式編程的哪部分呢？

純函數(shù)

只要可能并且合理，就應(yīng)該盡量保持函數(shù)“純凈”，并仔細(xì)考慮應(yīng)當(dāng)在何處保持改變了的狀態(tài)，并仔細(xì)地標(biāo)記好。這樣能讓單元測試變得更容易，你不需要做太多 set-up 和 tear-down，也不需要太多 mocking，而且測試用例不論執(zhí)行順序如何，都會產(chǎn)生預(yù)期中的結(jié)果。

下面是個非函數(shù)式的例子。 

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 時該測試能夠通過，但以后每次運行都會失敗，因為它會反復(fù)添加“s”和“es”。為了讓它變成純函數(shù)， 可以這樣寫： 

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 特有的概念，只是創(chuàng)建并返回了一個新的對象，而不是重用并修改已有的舊對象。這樣輸入的內(nèi)容也會保持不變。

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

理解（并避免）可修改性

先來個調(diào)查，你認(rèn)為哪些數(shù)據(jù)結(jié)構(gòu)是可修改的？

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

最重要的是，在傳遞字典、列表或集合時，它們可能會在其他上下文中被意料之外地改變。這種問題非常難以調(diào)試。可修改的默認(rèn)參數(shù)就是個經(jīng)典的例子： 

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，而且非常有用。寫代碼時完全不使用它們是不明智的。但即使如此，我永遠會在默認(rèn)參數(shù)的位置使用元組或 None（代替空字典或空列表），并且在缺乏足夠的防御代碼的情況下，避免將可修改的數(shù)據(jù)結(jié)構(gòu)在不同的上下文中傳遞。

減少類的使用

類（及其實例）的可修改性是把雙刃劍。隨著寫的 Python 代碼越來越多，我開始傾向于僅在絕對必要時才使用類，而且我?guī)缀鯊牟皇褂每尚薷牡念悓傩?。對于那些高度面向?qū)ο蟮恼Z言（如 Java）的程序員來說這一點可能很難做到，但許多其他語言中在類層面完成的東西，在 Python 可以在模塊層面完成。例如，如果需要將函數(shù)或常量或命名空間分組，那么可以把它們一起放到另一個 .py 文件中。

我經(jīng)?？吹揭恍╊惖哪康氖潜４鎺讉€命名變量的值，這種情況下 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 

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

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

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'] 

冪等性

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

lambda 和高階函數(shù)使用上的注意點

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

在需要時使用生成器和高階函數(shù)

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

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

結(jié)論

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