一文帶您了解Python的函數式編程：理解lambda、map()、filter()和reduce()
函數式編程在數據處理領域中扮演著重要的角色，其優勢在于能以簡潔和直觀的方式處理和轉換數據。通過將數據轉換操作封裝在純函數中，函數式編程避免了副作用和可變狀態，提升了代碼的可維護性和可讀性。在處理數據時，函數式編程提供了強大的工具，如 lambda、map()、filter() 和 reduce()，這些工具允許開發者高效地應用操作、篩選和歸約數據集合。利用這些函數，數據處理可以變得更加簡潔、模塊化。這種編程范式不僅有助于編寫更清晰的代碼，還能幫助開發者應對復雜的數據處理任務，實現更高效的數據流轉和分析。
什么是函數式編程？
純函數是指輸出值完全由輸入值決定，并且沒有任何可觀察的副作用的函數。在函數式編程中，程序主要由純函數的計算組成。計算通過嵌套或組合的函數調用進行，而不會改變狀態或可變數據。
函數式編程范式之所以受歡迎，是因為它相對于其他編程范式有幾個優勢。函數式代碼具有以下特點：
- 高級抽象：您描述的是想要的結果，而不是明確指定如何一步步達成這個結果。單個語句通常簡潔但功能強大。
- 透明性：純函數的行為可以通過其輸入和輸出來描述，而無需依賴中間值。這消除了副作用的可能性，并有助于調試。
- 并行化：不引發副作用的例程可以更容易地彼此并行運行。
許多編程語言都在一定程度上支持函數式編程。在某些語言中，幾乎所有代碼都遵循函數式編程范式。Haskell 就是這樣的例子。而 Python 則同時支持函數式編程和其他編程模型。
雖然函數式編程的詳細描述確實較為復雜，但這里的目標并不是提供嚴格的定義，而是展示如何在 Python 中進行函數式編程。
Python 對函數式編程的支持如何？
為了支持函數式編程，如果一種編程語言中的函數能夠做到以下兩點，將會非常有利：
- 接受另一個函數作為參數
- 返回另一個函數給調用者
Python 在這兩個方面都表現得很好。在 Python 中，一切皆為對象，所有對象在 Python 中的地位基本上是平等的，函數也不例外。
在 Python 中，函數是第一類公民。這意味著函數具有與字符串和數字等值相同的特性。任何可以對字符串或數字進行的操作，也可以對函數進行。
例如，您可以將一個函數賦值給一個變量，然后可以像使用該函數一樣使用該變量：
def func():
print("I am function func()!")
func()
another_name = func
another_name()
圖片
在第 7 行，通過 another_name = func 這條語句創建了一個新的引用，指向函數 func()，這個引用名為 another_name。隨后，您可以通過 func 或 another_name 這兩個名稱來調用這個函數，如第 5 行和第 8 行所示。
您可以使用 print() 將函數顯示在控制臺上，還可以將函數作為元素包含在復合數據對象（例如列表）中，甚至可以將其用作字典的鍵：
def func():
print("I am function func()!")
print("cat", func, 42)
objects = ["cat", func, 42]
print(objects[1])
objects[1]()
d = {"cat": 1, func: 2, 42: 3}
d[func]
圖片
在這個示例中，func() 出現在與值 "cat" 和 42 相同的上下文中，python解釋器都能正常處理它。
在當前討論的上下文中，關鍵在于 Python 中的函數滿足了前面提到的對函數式編程有利的兩個標準。您可以將一個函數作為參數傳遞給另一個函數：
def inner():
print("I am function inner()!")
def outer(function):
function()
outer(inner)
圖片
以上示例的過程如下：
- 在第 7 行中，inner() 被作為參數傳遞給 outer()。
- 在 outer() 內部，Python 將 inner() 綁定到函數參數 function。
- 然后 outer() 可以直接使用 function 來調用 inner()。
這被稱為函數組合。需要注意的是，您傳遞的是函數對象本身作為參數。如果您使用括號來調用函數對象，那么您傳遞的將不是函數對象，而是它的返回值。
當您將一個函數傳遞給另一個函數時，被傳遞的函數有時被稱為回調函數（callback），因為對內部函數的調用可以修改外部函數的行為。
一個很好的例子是 Python 中的 sorted() 函數。通常，如果您將一個字符串列表傳遞給 sorted()，它會按照字典順序進行排序：
圖片
然而，sorted() 接受一個可選的 key 參數，該參數指定一個回調函數作為排序的依據。因此，例如，您可以按照字符串的長度進行排序：
animals = ["ferret", "vole", "dog", "gecko"]
sorted(animals, key=len)
圖片
sorted() 還可以接受一個可選的參數，用于指定是否以反向順序排序。但是，您也可以通過定義自己的回調函數來實現相同的效果，例如編寫一個函數來反轉 len() 的排序順序：
animals = ["ferret", "vole", "dog", "gecko"]
sorted(animals, key=len, reverse=True)
def reverse_len(s):
return -len(s)
sorted(animals, key=reverse_len)
圖片
正如您可以將一個函數作為參數傳遞給另一個函數一樣，函數也可以指定另一個函數作為其返回值：
def outer():
def inner():
print("I am function inner()!")
# Function outer() returns function inner()
return inner
function = outer()
print( function )
function()
outer()()
圖片
在這個示例中發生的過程如下：
- 第 2 到 3 行：outer() 定義了一個局部函數 inner()。
- 第 5 行：outer() 將 inner() 作為返回值返回。
- 第 87行：您將 outer() 的返回值賦給變量 function。
- 之后，您可以通過 function 間接調用 inner()，如第 10 行所示。也可以通過 outer() 的返回值直接調用 inner()，如第 12 行所示，無需中間賦值。
如您所見，Python 擁有支持函數式編程的所有必要組件。但在深入函數式代碼之前，還有一個概念很有幫助，那就是lambda 表達式。
使用 lambda 定義匿名函數
函數式編程的核心是調用和傳遞函數，因此通常涉及大量的函數定義。您可以像往常一樣使用 def 關鍵字定義函數。
有時，能夠在不需要給函數命名的情況下定義一個匿名函數會很方便。在 Python 中，您可以使用 lambda 表達式來實現這一點。
lambda 表達式的語法如下：
lambda <parameter_list>: <expression>以下表格總結了 lambda 表達式的各個部分：
組件 | 說明 |
lambda | 引入 lambda 表達式的關鍵字 |
| 可選的用逗號分隔的參數名稱列表 |
| 標點符號，用于分隔 |
| 通常涉及 |
lambda 表達式的值是一個可調用的函數，類似于使用 def 關鍵字定義的函數。它接受由 <parameter_list> 指定的參數，并返回由 <expression> 指定的值。
以下是一個簡單的示例：
圖片
第 1 行的語句只是 lambda 表達式本身。
內置的 Python 函數 callable() 如果傳遞給它的參數看起來是可調用的，則返回 True，否則返回 False。第 3 行顯示了 lambda 表達式返回的值實際上是可調用的，就像一個函數應該的那樣。
在這個例子中，參數列表包含一個參數 s。隨后的表達式 s[::-1] 是切片語法，用于以相反的順序返回 s 中的字符。因此，這個 lambda 表達式定義了一個臨時的無名函數，它接受一個字符串參數并返回字符順序顛倒的字符串。
由 lambda 表達式創建的對象是第一類公民，就像標準函數或 Python 中的任何其他對象一樣。您可以將其賦值給一個變量，然后使用該名稱調用函數：
reverse = lambda s: s[::-1]
reverse("I am a string")
圖片
然而，在調用 lambda 表達式定義的函數之前，您不一定需要將其賦值給一個變量。您也可以直接調用由 lambda 表達式定義的函數：
(lambda s: s[::-1])("I am a string")
圖片
您將 lambda 表達式括在括號中以明確其結束位置，然后添加了一組括號，并將 "I am a string" 作為參數傳遞給您的匿名函數。Python 將字符串參數分配給參數 s，然后您的 lambda 函數反轉了字符串并返回結果。
這是另一個示例，基于相同的概念，但因為在 lambda 表達式中使用了多個參數，所以更加復雜：
a= (lambda x1, x2, x3: (x1 + x2 + x3) / 3)(9, 6, 6)
print(a)
(lambda x1, x2, x3: (x1 + x2 + x3) / 3)(1.4, 1.1, 0.5)
圖片
在這個例子中，參數是 x1、x2 和 x3，表達式是 x1 + x2 + x3 / 3。這是一個匿名 lambda 函數，用于計算三個數字的平均值。
使用 lambda 表達式的真正優勢在于它們適用于短小而直接的邏輯。您可以用一個簡潔直接的 lambda 表達式來代替定義 reverse_len：
圖片
lambda 表達式通常會有一個參數列表，但這不是必須的。您可以定義一個沒有參數的 lambda 函數。在這種情況下，返回值不依賴于任何輸入參數：
圖片
lambda 只能用于定義比較簡單的函數。lambda 表達式的返回值只能是一個單一的表達式。lambda 表達式不能包含諸如賦值或 return 的語句，也不能包含控制結構，如 for、while、if、else 或 def。
lambda 函數在編寫函數式代碼時特別方便。Python 提供了兩個內置函數 map() 和 filter()，它們符合函數式編程范式。第三個函數 reduce() 不再是核心語言的一部分，但仍然可以在名為 functools 的模塊中使用。這三個函數中的每一個都將另一個函數作為其參數之一。
使用 map() 對可迭代對象應用函數
第一個要介紹的函數是 map()，這是 Python 的一個內置函數。使用 map()，您可以依次將一個函數應用于可迭代對象中的每個元素。map() 函數將返回一個迭代器，該迭代器生成結果。這可以使代碼變得非常簡潔，因為 map() 語句通常可以替代顯式的循環。
您可以使用一個可迭代對象或多個可迭代對象來調用 map()。接下來，您將查看在單個可迭代對象上調用 map() 的語法。
map(<f>, <iterable>) 返回一個迭代器，該迭代器生成將函數 <f> 應用到 <iterable> 中每個元素的結果。
下面是一個示例。假設您已經定義了 reverse() 函數，該函數接受一個字符串參數，并使用舊友 [::-1] 字符串切片機制返回其反轉結果；如果您有一個字符串列表，可以使用 map() 將 reverse() 應用到列表中的每個元素：
def reverse(s):
return s[::-1]
print( reverse("I am a string") )
animals = ["cat", "dog", "hedgehog", "gecko"]
print( map(reverse, animals) )
list( map(reverse, animals) )
圖片
map() 不會返回一個列表。它返回的是一個 map 對象，這是一個迭代器。
使用多個可迭代對象調用 map()
另一種使用 map() 的方式是，當您在函數參數后傳遞多個可迭代對象時：
map(<f>, <iterable?>, <iterable?>, ..., <iterable?>)在這個例子中，map(<f>, <iterable1>, <iterable2>, ..., <iterablen>) 會將 <f> 應用到每個 <iterablei> 中的元素，并且以并行的方式返回一個迭代器，生成結果。
傳遞給 map() 的 <iterablei> 參數的數量必須與 <f> 預期的參數數量匹配。<f> 作用于每個 <iterablei> 的第一個項目，生成的結果成為返回迭代器的第一個生成項。然后，<f> 作用于每個 <iterablei> 的第二個項目，生成的結果成為第二個生成項，以此類推。
一個詳細的示例可以幫助您更清楚地理解：
def add_three(a, b, c):
return a + b + c
list(map(add_three, [1, 2, 3], [10, 20, 30], [100, 200, 300]))
圖片
第一項是計算 add_three(1, 10, 100),第二項是計算 add_three(2, 20, 200) 的結果，第三項是計算 add_three(3, 30, 300) 的結果。這可以通過以下示意圖來表示：
圖片
使用 filter() 從可迭代對象中選擇元素
filter() 允許您根據給定函數的評估來選擇或過濾可迭代對象中的項。其函數如下：
filter(<f>, <iterable>)filter(<f>, <iterable>) 將函數 <f> 應用到 <iterable> 中的每個元素，并返回一個迭代器，該迭代器生成所有 <f> 結果為真值的項。相反，它會過濾掉所有 <f> 結果為假值的項。
在以下示例中，如果 x > 100，greater_than_100(x) 就會返回真值：
def greater_than_100(x):
return x > 100
list(filter(greater_than_100, [1, 111, 2, 222, 3, 333]))
圖片
在這種情況下，greater_than_100() 對項 111、222 和 333 產生真值，因此這些項會保留，而 filter() 會丟棄 1、2 和 3。與之前的示例一樣，greater_than_100() 是一個簡短的函數，您可以用 lambda 表達式替代它：
圖片
使用 reduce() 將可迭代對象歸約為單一值
reduce() 將一個函數應用于可迭代對象中的項，每次兩個項一同處理，逐步合并它們以生成一個最終結果。
最直接的reduce()調用需要一個函數和一個可迭代對象：
reduce(<f>,<iterable>)在調用 時reduce(<f>, <iterable>)，函數<f>必須是采用兩個參數的函數。然后將使用reduce()逐步組合 中的元素。首先，對 的前兩個元素調用。然后將該結果與第三個元素組合，然后將該結果與第四個元素組合，依此類推，直到列表用盡。然后，返回最終結果。
def f(x, y):
return x + y
from functools import reduce
reduce(f, [1, 2, 3, 4, 5])
圖片
此調用將產生列表的reduce()結果，如下所示：
圖片
這是對列表中的數字求和的一種相當迂回的方法。
函數式編程是一種編程范式，其中主要的計算方法是純函數的求值。盡管 Python 主要不是函數式語言，但您仍然可以按照函數式編程原則編寫 Python。最好熟悉lambda、map()、filter()和reduce()。它們可以幫助您編寫簡潔、高級、可并行的代碼。您可能還會在其他人編寫的代碼中看到這些函數的使用，因此了解它們的工作原理是很好的。
