函數(shù)式編程在數(shù)據(jù)處理領(lǐng)域中扮演著重要的角色，其優(yōu)勢在于能以簡潔和直觀的方式處理和轉(zhuǎn)換數(shù)據(jù)。通過將數(shù)據(jù)轉(zhuǎn)換操作封裝在純函數(shù)中，函數(shù)式編程避免了副作用和可變狀態(tài)，提升了代碼的可維護(hù)性和可讀性。在處理數(shù)據(jù)時，函數(shù)式編程提供了強(qiáng)大的工具，如 lambda、map()、filter() 和 reduce()，這些工具允許開發(fā)者高效地應(yīng)用操作、篩選和歸約數(shù)據(jù)集合。利用這些函數(shù)，數(shù)據(jù)處理可以變得更加簡潔、模塊化。這種編程范式不僅有助于編寫更清晰的代碼，還能幫助開發(fā)者應(yīng)對復(fù)雜的數(shù)據(jù)處理任務(wù)，實(shí)現(xiàn)更高效的數(shù)據(jù)流轉(zhuǎn)和分析。

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

純函數(shù)是指輸出值完全由輸入值決定，并且沒有任何可觀察的副作用的函數(shù)。在函數(shù)式編程中，程序主要由純函數(shù)的計(jì)算組成。計(jì)算通過嵌套或組合的函數(shù)調(diào)用進(jìn)行，而不會改變狀態(tài)或可變數(shù)據(jù)。

函數(shù)式編程范式之所以受歡迎，是因?yàn)樗鄬τ谄渌幊谭妒接袔讉€優(yōu)勢。函數(shù)式代碼具有以下特點(diǎn)：

• 高級抽象：您描述的是想要的結(jié)果，而不是明確指定如何一步步達(dá)成這個結(jié)果。單個語句通常簡潔但功能強(qiáng)大。
• 透明性：純函數(shù)的行為可以通過其輸入和輸出來描述，而無需依賴中間值。這消除了副作用的可能性，并有助于調(diào)試。
• 并行化：不引發(fā)副作用的例程可以更容易地彼此并行運(yùn)行。

許多編程語言都在一定程度上支持函數(shù)式編程。在某些語言中，幾乎所有代碼都遵循函數(shù)式編程范式。Haskell 就是這樣的例子。而 Python 則同時支持函數(shù)式編程和其他編程模型。

雖然函數(shù)式編程的詳細(xì)描述確實(shí)較為復(fù)雜，但這里的目標(biāo)并不是提供嚴(yán)格的定義，而是展示如何在 Python 中進(jìn)行函數(shù)式編程。

Python 對函數(shù)式編程的支持如何？

為了支持函數(shù)式編程，如果一種編程語言中的函數(shù)能夠做到以下兩點(diǎn)，將會非常有利：

1. 接受另一個函數(shù)作為參數(shù)
2. 返回另一個函數(shù)給調(diào)用者

Python 在這兩個方面都表現(xiàn)得很好。在 Python 中，一切皆為對象，所有對象在 Python 中的地位基本上是平等的，函數(shù)也不例外。

在 Python 中，函數(shù)是第一類公民。這意味著函數(shù)具有與字符串和數(shù)字等值相同的特性。任何可以對字符串或數(shù)字進(jìn)行的操作，也可以對函數(shù)進(jìn)行。

例如，您可以將一個函數(shù)賦值給一個變量，然后可以像使用該函數(shù)一樣使用該變量：

def func():
    print("I am function func()!")




func()


another_name = func
another_name()

圖片

在第 7 行，通過 another_name = func 這條語句創(chuàng)建了一個新的引用，指向函數(shù) func()，這個引用名為 another_name。隨后，您可以通過 func 或 another_name 這兩個名稱來調(diào)用這個函數(shù)，如第 5 行和第 8 行所示。

您可以使用 print() 將函數(shù)顯示在控制臺上，還可以將函數(shù)作為元素包含在復(fù)合數(shù)據(jù)對象（例如列表）中，甚至可以將其用作字典的鍵：

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() 出現(xiàn)在與值 "cat" 和 42 相同的上下文中，python解釋器都能正常處理它。

在當(dāng)前討論的上下文中，關(guān)鍵在于 Python 中的函數(shù)滿足了前面提到的對函數(shù)式編程有利的兩個標(biāo)準(zhǔn)。您可以將一個函數(shù)作為參數(shù)傳遞給另一個函數(shù)：

def inner():
    print("I am function inner()!")


def outer(function):
    function()


outer(inner)

圖片

以上示例的過程如下：

• 在第 7 行中，inner() 被作為參數(shù)傳遞給 outer()。
• 在 outer() 內(nèi)部，Python 將 inner() 綁定到函數(shù)參數(shù) function。
• 然后 outer() 可以直接使用 function 來調(diào)用 inner()。

這被稱為函數(shù)組合。需要注意的是，您傳遞的是函數(shù)對象本身作為參數(shù)。如果您使用括號來調(diào)用函數(shù)對象，那么您傳遞的將不是函數(shù)對象，而是它的返回值。

當(dāng)您將一個函數(shù)傳遞給另一個函數(shù)時，被傳遞的函數(shù)有時被稱為回調(diào)函數(shù)（callback），因?yàn)閷?nèi)部函數(shù)的調(diào)用可以修改外部函數(shù)的行為。

一個很好的例子是 Python 中的 sorted() 函數(shù)。通常，如果您將一個字符串列表傳遞給 sorted()，它會按照字典順序進(jìn)行排序：

圖片

然而，sorted() 接受一個可選的 key 參數(shù)，該參數(shù)指定一個回調(diào)函數(shù)作為排序的依據(jù)。因此，例如，您可以按照字符串的長度進(jìn)行排序：

animals = ["ferret", "vole", "dog", "gecko"]
sorted(animals, key=len)

圖片

sorted() 還可以接受一個可選的參數(shù)，用于指定是否以反向順序排序。但是，您也可以通過定義自己的回調(diào)函數(shù)來實(shí)現(xiàn)相同的效果，例如編寫一個函數(shù)來反轉(zhuǎn) len() 的排序順序：

animals = ["ferret", "vole", "dog", "gecko"]
sorted(animals, key=len, reverse=True)


def reverse_len(s):
    return -len(s)


sorted(animals, key=reverse_len)

圖片

正如您可以將一個函數(shù)作為參數(shù)傳遞給另一個函數(shù)一樣，函數(shù)也可以指定另一個函數(shù)作為其返回值：

def outer():
    def inner():
        print("I am function inner()!")
    # Function outer() returns function inner()
    return inner


function = outer()
print( function )


function()


outer()()

圖片

在這個示例中發(fā)生的過程如下：

• 第 2 到 3 行：outer() 定義了一個局部函數(shù) inner()。
• 第 5 行：outer() 將 inner() 作為返回值返回。
• 第 87行：您將 outer() 的返回值賦給變量 function。
• 之后，您可以通過 function 間接調(diào)用 inner()，如第 10 行所示。也可以通過 outer() 的返回值直接調(diào)用 inner()，如第 12 行所示，無需中間賦值。

如您所見，Python 擁有支持函數(shù)式編程的所有必要組件。但在深入函數(shù)式代碼之前，還有一個概念很有幫助，那就是lambda 表達(dá)式。

使用 lambda 定義匿名函數(shù)

函數(shù)式編程的核心是調(diào)用和傳遞函數(shù)，因此通常涉及大量的函數(shù)定義。您可以像往常一樣使用 def 關(guān)鍵字定義函數(shù)。

有時，能夠在不需要給函數(shù)命名的情況下定義一個匿名函數(shù)會很方便。在 Python 中，您可以使用 lambda 表達(dá)式來實(shí)現(xiàn)這一點(diǎn)。

lambda 表達(dá)式的語法如下：

lambda <parameter_list>: <expression>

以下表格總結(jié)了 lambda 表達(dá)式的各個部分：

lambda 表達(dá)式的值是一個可調(diào)用的函數(shù)，類似于使用 def 關(guān)鍵字定義的函數(shù)。它接受由 <parameter_list> 指定的參數(shù)，并返回由 <expression> 指定的值。

以下是一個簡單的示例：

圖片

第 1 行的語句只是 lambda 表達(dá)式本身。

內(nèi)置的 Python 函數(shù) callable() 如果傳遞給它的參數(shù)看起來是可調(diào)用的，則返回 True，否則返回 False。第 3 行顯示了 lambda 表達(dá)式返回的值實(shí)際上是可調(diào)用的，就像一個函數(shù)應(yīng)該的那樣。

在這個例子中，參數(shù)列表包含一個參數(shù) s。隨后的表達(dá)式 s[::-1] 是切片語法，用于以相反的順序返回 s 中的字符。因此，這個 lambda 表達(dá)式定義了一個臨時的無名函數(shù)，它接受一個字符串參數(shù)并返回字符順序顛倒的字符串。

由 lambda 表達(dá)式創(chuàng)建的對象是第一類公民，就像標(biāo)準(zhǔn)函數(shù)或 Python 中的任何其他對象一樣。您可以將其賦值給一個變量，然后使用該名稱調(diào)用函數(shù)：

reverse = lambda s: s[::-1]
reverse("I am a string")

圖片

然而，在調(diào)用 lambda 表達(dá)式定義的函數(shù)之前，您不一定需要將其賦值給一個變量。您也可以直接調(diào)用由 lambda 表達(dá)式定義的函數(shù)：

(lambda s: s[::-1])("I am a string")

圖片

您將 lambda 表達(dá)式括在括號中以明確其結(jié)束位置，然后添加了一組括號，并將 "I am a string" 作為參數(shù)傳遞給您的匿名函數(shù)。Python 將字符串參數(shù)分配給參數(shù) s，然后您的 lambda 函數(shù)反轉(zhuǎn)了字符串并返回結(jié)果。

這是另一個示例，基于相同的概念，但因?yàn)樵?nbsp;lambda 表達(dá)式中使用了多個參數(shù)，所以更加復(fù)雜：

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)

圖片

在這個例子中，參數(shù)是 x1、x2 和 x3，表達(dá)式是 x1 + x2 + x3 / 3。這是一個匿名 lambda 函數(shù)，用于計(jì)算三個數(shù)字的平均值。

使用 lambda 表達(dá)式的真正優(yōu)勢在于它們適用于短小而直接的邏輯。您可以用一個簡潔直接的 lambda 表達(dá)式來代替定義 reverse_len：

圖片

lambda 表達(dá)式通常會有一個參數(shù)列表，但這不是必須的。您可以定義一個沒有參數(shù)的 lambda 函數(shù)。在這種情況下，返回值不依賴于任何輸入?yún)?shù)：

圖片

lambda 只能用于定義比較簡單的函數(shù)。lambda 表達(dá)式的返回值只能是一個單一的表達(dá)式。lambda 表達(dá)式不能包含諸如賦值或 return 的語句，也不能包含控制結(jié)構(gòu)，如 for、while、if、else 或 def。

lambda 函數(shù)在編寫函數(shù)式代碼時特別方便。Python 提供了兩個內(nèi)置函數(shù) map() 和 filter()，它們符合函數(shù)式編程范式。第三個函數(shù) reduce() 不再是核心語言的一部分，但仍然可以在名為 functools 的模塊中使用。這三個函數(shù)中的每一個都將另一個函數(shù)作為其參數(shù)之一。

使用 map() 對可迭代對象應(yīng)用函數(shù)

第一個要介紹的函數(shù)是 map()，這是 Python 的一個內(nèi)置函數(shù)。使用 map()，您可以依次將一個函數(shù)應(yīng)用于可迭代對象中的每個元素。map() 函數(shù)將返回一個迭代器，該迭代器生成結(jié)果。這可以使代碼變得非常簡潔，因?yàn)?nbsp;map() 語句通?？梢蕴娲@式的循環(huán)。

您可以使用一個可迭代對象或多個可迭代對象來調(diào)用 map()。接下來，您將查看在單個可迭代對象上調(diào)用 map() 的語法。

map(<f>, <iterable>) 返回一個迭代器，該迭代器生成將函數(shù) <f> 應(yīng)用到 <iterable> 中每個元素的結(jié)果。

下面是一個示例。假設(shè)您已經(jīng)定義了 reverse() 函數(shù)，該函數(shù)接受一個字符串參數(shù)，并使用舊友 [::-1] 字符串切片機(jī)制返回其反轉(zhuǎn)結(jié)果；如果您有一個字符串列表，可以使用 map() 將 reverse() 應(yīng)用到列表中的每個元素：

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 對象，這是一個迭代器。

使用多個可迭代對象調(diào)用 map()

另一種使用 map() 的方式是，當(dāng)您在函數(shù)參數(shù)后傳遞多個可迭代對象時：

map(<f>, <iterable?>, <iterable?>, ..., <iterable?>)

在這個例子中，map(<f>, <iterable1>, <iterable2>, ..., <iterablen>) 會將 <f> 應(yīng)用到每個 <iterablei> 中的元素，并且以并行的方式返回一個迭代器，生成結(jié)果。

傳遞給 map() 的 <iterablei> 參數(shù)的數(shù)量必須與 <f> 預(yù)期的參數(shù)數(shù)量匹配。<f> 作用于每個 <iterablei> 的第一個項(xiàng)目，生成的結(jié)果成為返回迭代器的第一個生成項(xiàng)。然后，<f> 作用于每個 <iterablei> 的第二個項(xiàng)目，生成的結(jié)果成為第二個生成項(xiàng)，以此類推。

一個詳細(xì)的示例可以幫助您更清楚地理解：

def add_three(a, b, c):
    return a + b + c


list(map(add_three, [1, 2, 3], [10, 20, 30], [100, 200, 300]))

圖片

第一項(xiàng)是計(jì)算 add_three(1, 10, 100),第二項(xiàng)是計(jì)算 add_three(2, 20, 200) 的結(jié)果，第三項(xiàng)是計(jì)算 add_three(3, 30, 300) 的結(jié)果。這可以通過以下示意圖來表示：

圖片

使用 filter() 從可迭代對象中選擇元素

filter() 允許您根據(jù)給定函數(shù)的評估來選擇或過濾可迭代對象中的項(xiàng)。其函數(shù)如下：

filter(<f>, <iterable>)

filter(<f>, <iterable>) 將函數(shù) <f> 應(yīng)用到 <iterable> 中的每個元素，并返回一個迭代器，該迭代器生成所有 <f> 結(jié)果為真值的項(xiàng)。相反，它會過濾掉所有 <f> 結(jié)果為假值的項(xiàng)。

在以下示例中，如果 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() 對項(xiàng) 111、222 和 333 產(chǎn)生真值，因此這些項(xiàng)會保留，而 filter() 會丟棄 1、2 和 3。與之前的示例一樣，greater_than_100() 是一個簡短的函數(shù)，您可以用 lambda 表達(dá)式替代它：

圖片

使用 reduce() 將可迭代對象歸約為單一值

reduce() 將一個函數(shù)應(yīng)用于可迭代對象中的項(xiàng)，每次兩個項(xiàng)一同處理，逐步合并它們以生成一個最終結(jié)果。

最直接的reduce()調(diào)用需要一個函數(shù)和一個可迭代對象：

reduce(<f>,<iterable>)

在調(diào)用 時reduce(<f>, <iterable>)，函數(shù)<f>必須是采用兩個參數(shù)的函數(shù)。然后將使用reduce()逐步組合 中的元素。首先，對 的前兩個元素調(diào)用。然后將該結(jié)果與第三個元素組合，然后將該結(jié)果與第四個元素組合，依此類推，直到列表用盡。然后，返回最終結(jié)果。

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


from functools import reduce
reduce(f, [1, 2, 3, 4, 5])

圖片

此調(diào)用將產(chǎn)生列表的reduce()結(jié)果，如下所示：

圖片

這是對列表中的數(shù)字求和的一種相當(dāng)迂回的方法。

函數(shù)式編程是一種編程范式，其中主要的計(jì)算方法是純函數(shù)的求值。盡管 Python 主要不是函數(shù)式語言，但您仍然可以按照函數(shù)式編程原則編寫 Python。最好熟悉lambda、map()、filter()和reduce()。它們可以幫助您編寫簡潔、高級、可并行的代碼。您可能還會在其他人編寫的代碼中看到這些函數(shù)的使用，因此了解它們的工作原理是很好的。