教程 | 十分鐘學會函數式 Python

知識 12-30

源 /

CSDN

文 /

Brandon Skerritt

函數式編程到底是什麼？本文將詳解其概念，同時分享怎樣在 Python 中使用函數式編程。主要內容包括列表解析式和其他形式的解析式。

函數式模型

在命令式模型中，執行程序的方式是給計算機一系列指令讓它執行。執行過程中計算機會改變狀態。例如，比如 A 的初始值是 5，後來改變了 A 的值。那麼 A 就是個變數，而變數的意思就是包含的值會改變。

而在函數式模式中，你不需要告訴計算機做什麼，而是告訴計算機是什麼。比如數字的最大公約數是什麼，1 到 n 的乘積是什麼等等。

因此，變數是不能被改變的。變數一旦被設置，就永遠保持同一個值（注意在純粹的函數式語言中，它們不叫變數）。因此，在函數式模型中，函數沒有副作用。副作用就是函數對函數外的世界做出的改變。來看看下面這段Python代碼的例子：

a =

def

some_func

()

global

a
a =

some_func()
print(a)

代碼的輸出是 5。在函數式模型中，改變變數的值是完全不允許的，讓函數影響函數外的世界也是不允許的。函數唯一能做的就是做一些計算然後返回一個值。

你可能會想：「沒有變數也沒有副作用？這有什麼好的？」好問題。

如果函數使用同樣的參數調用兩次，那麼我們可以保證它會返回同樣的結果。如果你學過數學函數，你肯定知道這樣做的好。這叫做引用透明性（referential transparency）。由於函數沒有副作用，那麼我們可以加速計算某個東西的程序。比如，如果程序知道 func(2)返回 3，那麼可以將這個值保存在表中，這樣就不需要重複運行我們早已知道結果的函數了。

通常，函數式編程不使用循環，而是使用遞歸。遞歸是個數學概念，通常的意思是「把結果作為自己的輸入」。使用遞歸函數，函數可以反覆調用自己。下面就是個使用Python定義的遞歸函數的例子：

def

factorial_recursive

(n)

# Base case: 1! = 1

n ==

return

# Recursive case: n! = n * (n-1)!

else

return

n * factorial_recursive(n

-1

)

函數式編程語言也是懶惰的。懶惰的意思是，除非到最後一刻，否則它們不會執行計算或做任何操作。如果代碼要求計算2+2，那麼函數式程序只有在真正用到計算結果的時候才會去計算。我們馬上就會介紹Python中的這種懶惰。

映射

要理解映射（map），首先需要理解什麼是可迭代對象。可迭代對象（iterable）指任何可以迭代的東西。通常是列表或數組，但 Python 還有許多其他可迭代對象。甚至可以自定義對象，通過實現特定的魔術方法使其變成可迭代對象。魔術方法就像 API 一樣，能讓對象更有 Python 風格。要讓對象變成可迭代對象，需要實現以下兩個魔術方法：

class

Counter

def

__init__

(

self

, low, high)

# set class attributes inside the magic method __init__

# for "inistalise"

self

.current = low

self

.high = high

def

__iter__

(

self

)

# first magic method to make this object iterable

return

self

def

__next__

(

self

)

# second magic method

self

.current >

self

high:

raise StopIteration

else:

self

.current +=

return

self

.current -

第一個魔術方法「__iter__」（雙下劃線iter）返回迭代子，通常在循環開始時調用。__next__則返回迭代的下一個對象。

可以打開命令行試一下下面的代碼：

for

Counter(3, 8):

(c)

這段代碼將會輸出：

3
4
5
6
7
8

在 Python 中，迭代器就是只實現了__iter__魔術方法的對象。也就是說，你可以訪問對象中都包含的位置，但無法遍歷整個對象。一些對象實現了__next__魔術方法，但沒有實現__iter__魔術方法，比如集合（本文稍後會討論）。在本文中，我們假設涉及到的一切對象都是可迭代的對象。

現在我們知道了什麼是可迭代的對象，回過頭來討論下映射函數。映射可以對可迭代對象中的每個元素執行指定的函數。通常，我們對列表中的每個元素執行函數，但要知道映射其實可以針對絕大多數可迭代對象使用。

map(

function

iterable

)

假設有一個列表由以下數字組成：

[

]

我們希望得到每個數字的平方，那麼代碼可以寫成這樣：

x = [

]

def

square

(num)

return

num*num

print(list(map(square, x)))

Python中的函數式函數是懶惰的。如果我們不加「list()」，那麼函數只會將可迭代對象保存下來，而不會保存結果的列表。我們需要明確地告訴Python「把它轉換成列表」才能得到結果。

在Python中一下子從不懶惰的函數求值轉換到懶惰的函數似乎有點不適應。但如果你能用函數式的思維而不是過程式的思維，那麼最終會適應的。

這個「square(num)」的確不錯，但總覺得有點不對勁。難道為了僅使用一次的map就得定義整個函數嗎？其實我們可以使用lambda函數（匿名函數）。

Lambda 表達式

Lambda表達式就是只有一行的函數。比如下面這個lambda表達式可以求出給定數字的平方：

square

= lambda x: x * x

運行下面的代碼：

> square(

)

你肯定在問：「參數去哪兒了？這究竟是啥意思？看起來根本不像函數啊？」

嗯，的確是不太容易懂……但還是應該能夠理解的。我們上面的代碼把什麼東西賦給了變數「square」。就是這個東西：

lambda

它告訴Python這是個lambda函數，輸入的名字為x。冒號後面的一切都是對輸入的操作，然後它會自動返回操作的結果。

這樣我們的求平方的代碼可以簡化成一行：

x = [

]

(list(map(lambda

num

, x)))

有了lambda表達式，所有參數都放在左邊，操作都放在右邊。雖然看上去有點亂，但不能否認它的作用。實際上能寫出只有懂得函數式編程的人才能看懂的代碼還是有點小興奮的。而且把函數變成一行也非常酷。

歸納

歸納（reduce）是個函數，它把一個可迭代對象變成一個東西。通常，我們在列表上進行計算，將列表歸納成一個數字。歸納的代碼看起來長這樣：

reduce(

function

list

)

上面的函數可以使用lambda表達式。

列表的乘積就是把所有數字乘到一起。可以這樣寫代碼：

product = 1
x = [1, 2, 3, 4]
for num in x:
product = product * num

但使用歸納，可以寫成這樣：

from

functools

import

reduce

product = reduce((

lambda

x, y: x * y),[

])

這樣能得到同樣的結果。這段代碼更短，而且藉助函數式編程，這段代碼更簡潔。

過濾

過濾（filter）函數接收一個可迭代對象，然後過濾掉對象中一切不需要的東西。

通常過濾接收一個函數和一個列表。它會針對列表中的每個元素執行函數，如果函數返回True，則什麼都不做。如果函數返回False，則從列表中去掉那個元素。

語法如下：

filter(

function

list

)

我們來看一個簡單的例子。沒有過濾，代碼要寫成這樣：

x = range(

-5

)
new_list = []

for

num

:
new_list.append(

num

)

使用過濾可以寫成這樣：

= range(-

)

all_less_than_zero

= list(filter(lambda num: num <

, x))

高階函數

高階函數接收函數作為參數，返回另一個函數。一個非常簡單的例子如下所示：

def

summation

(nums)

return

sum(nums)

def

action

(func, numbers)

return

func(numbers)

print(action(summation, [

]))

# Output is 6

或者更簡單「返回函數」的例子：

def

rtnBrandon

()

return

"brandon"

def

rtnJohn

()

return

"john"

def

rtnPerson

()

age = int(input(

"What"s your age?"

))

age ==

return

rtnBrandon()

else

return

rtnJohn()

還記得之前說過函數式編程語言沒有變數嗎？實際上高階函數能很容易做到這一點。如果你只需要在一系列函數中傳遞數據，那麼數據根本不需要保存到變數中。

Python 中的所有函數都是頂級對象。頂級對象是擁有一個或多個以下特徵的對象：

在運行時生成

賦值給某個數據結構中的變數或元素

作為參數傳遞給函數

作為函數的結果返回

所以，所有 Python 中的函數都是對象，都可以用作高階函數。

部分函數

部分函數有點難懂，但非常酷。通過它，你不需要提供完整的參數就能調用函數。我們來看個例子。我們要創建一個函數，它接收兩個參數，一個是底，另一個是指數，然後返回底的指數次冪，代碼如下：

def

power

(base, exponent)

return

base ** exponent

現在我們需要一個求平方的函數，可以這麼寫：

def

square

(base)

return

power(base,

)

這段代碼沒問題，但如果需要立方函數怎麼辦？或者四次方函數呢？是不是得一直定義新的函數？這樣做也行，但是程序員總是很懶的。如果需要經常重複一件事情，那就意味著一定有辦法提高速度，避免重複。我們可以用部分函數實現這一點。下面是使用部分函數求平方的例子：

from

functools

import

partial

square = partial(power, exponent=

)

(square(

))

# output is 4

這是不是很苦？我們事先告訴 Python 第二個參數，這樣只需要提供一個參數就能調用需要兩個參數的函數了。

還可以使用循環來生成直到能計算 1000 次方的所有函數。

from functools import partial

powers = []
for x in range(2, 1001):
powers.append(partial(power, exponent = x))

print(powers[

](

))

# output is 9

函數式編程不夠 Python

你也許注意到了，我們這裡許多函數式編程都用到了列表。除了歸納和部分函數之外，所有其他函數都生成列表。Guido（Python發明人）不喜歡在 Python 中使用函數式的東西，因為 Python 有自己的方法來生成列表。

在 Python IDLE 中敲「import this」，可以看到下面的內容：

>>> import this
The Zen

Python, by Tim Peters
Beautiful

better than ugly.
Explicit

better than implicit.
Simple

better than complex.
Complex

better than complicated.
Flat

better than nested.
Sparse

better than dense.
Readability counts.
Special cases aren』t special enough

break

the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.

the face

ambiguity, refuse the temptation

guess.
There should be one —

and

preferably only one — obvious way

it.
Although that way may

not

be obvious at first unless you』re Dutch.
Now

better than never.
Although never

often better than *right* now.

the

implementation

hard

explain, it』s a bad idea.

the

implementation

easy

explain, it may be a good idea.
Namespaces are one honking great idea — let』s

those!

這就是Python之禪。這首詩表明了什麼叫做Python風格。我們要指出的是這句話：

There should be one?—?and preferably only one?—?obvious way to do it.

（任何事情應該有一個且只有一個方法解決。）

在 Python 中，映射和過濾能做到的事情，列表解析式（稍後介紹）也能做到。這就打破了 Python 之禪，因此我們說函數式編程的部分不夠「Python」。

另一個常被提及的地方就是lambda。在Python中，lambda函數就是個普通的函數。lambda只是個語法糖。這兩者是等價的：

foo =

lambda

def

foo

(a)

return

普通的函數能做到一切 lambda 能做到的事情，但反過來卻不行。lambda 不能完成普通函數能完成的一切事情。

關於為何函數式編程不適合Python生態系統曾有過一次討論。你也許注意到，我之前提到了列表解析式，我們現在就來介紹下什麼是列表解析式。

列表解析式

之前我說過，任何能用映射或過濾完成的事情都可以用列表解析式完成。這就是我們要學的東西。

列表解析式是 Python 生成列表的方式。語法如下：

[

function

for

item

iterable]

要想求列表中每個數字的平方，可以這麼寫：

([x * x

for

[1, 2, 3, 4]])

可以看到，我們給列表中的每個元素應用了一個函數。那麼怎樣才能實現過濾呢？先來看看之前的這段代碼：

x = range(-5, 5)

all_less_than_zero = list(filter(lambda num: num < 0, x))
print(all_less_than_zero)

可以將它轉換成下面這種使用列表解析式的方式：

x = range(

-5

)

all_less_than_zero = [

num

for

num

]

像這樣，列表解析式支持 if 語句。這樣就不需要寫一堆函數來實現了。實際上，如果你需要生成某種列表，那麼很有可能使用列表解析式更方便、更簡潔。

如果想求所有小於 0 的數字的平方呢？使用 Lambda、映射和過濾可以寫成：

x = range(

-5

)

all_less_than_zero = list(map(lambda

num

, list(filter(lambda

num

, x))))

看上去似乎很長，而且有點複雜。用列表解析式只需寫成：

x = range(

-5

)

all_less_than_zero = [

num

for

num

]

不過列表解析式只能用於列表。映射和過濾能用於一切可迭代對象。那為什麼還要用列表解析式呢？其實，解析式可以用在任何可迭代的對象上。

其他解析式

可以在任何可迭代對象上使用解析式。

任何可迭代對象都可以用解析式生成。從 Python 2.7 開始，甚至可以用解析式生成字典（哈希表）。

# Taken from page 70 chapter 3 of Fluent Python by Luciano Ramalho

DIAL_CODES = [
(

"China"

),
(

"India"

),
(

"United States"

),
(

"Indonesia"

),
(

"Brazil"

),
(

"Pakistan"

),
(

880

"Bangladesh"

),
(

234

"Nigeria"

),
(

"Russia"

),
(

"Japan"

),
]

> country_code = {

country:

code for code, country in DIAL_CODES}

> country_code
{

"Brazil"

"Indonesia"

"Pakistan"

"Russia"

"China"

"United States"

"Japan"

"India"

"Nigeria"

234

"Bangladesh"

880

}

> {

code:

country.upper() for country, code in country_code.items() if code <

}
{

"UNITED STATES"

"RUSSIA"

"INDONESIA"

"BRAZIL"

}

只要是可迭代對象，就可以用解析式生成。我們來看個集合的例子。如果你不知道集合是什麼，可以先讀讀這篇（https://medium.com/brandons-computer-science-notes/a-primer-on-set-theory-746cd0b13d13）文章。簡單來說就是：

集合是元素的列表，但列表中沒有重複的元素

元素的順序不重要

# taken from page 87, chapter 3 of Fluent Python by Luciano Ramalho

>>>

from

unicodedata

import

name
>>> {chr(i)

for

range(

256

)

"SIGN"

name(chr(i),

)}
{

"×"

"￥"

"°"

"￡"

"?"

"#"

"?"

"%"

"μ"

">"

"¤"

"±"

"?"

"§"

"<"

"="

"?"

"$"

"÷"

"￠"

"+"

}

可以看到，集合使用字典同樣的大括弧。Python非常聰明。它會查看你是否在大括弧中提供了額外的值，來判斷是集合解析式還是字典解析式。如果想了解更多關於解析式的內容，可以看看這個可視化的指南（http://treyhunner.com/2015/12/python-list-comprehensions-now-in-color/）。如果想了解更多關於解析式和生成器的內容，可以讀讀這篇文章（https://medium.freecodecamp.org/python-list-comprehensions-vs-generator-expressions-cef70ccb49db）。

結論

函數式編程很美、很純凈。函數式代碼可以寫得非常乾淨，但也可以寫得很亂。一些 Python 程序員不喜歡在 Python 中使用函數式的模型，不過大家可以根據自己的喜好，記得用最好的工具完成工作。