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

函式式模型

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

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

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

a = 3
def some_func():
 global a
 a = 5
some_func()
print(a)

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

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

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

通常，函數語言程式設計不使用迴圈，而是使用遞迴。遞迴是個數學概念，通常的意思是“把結果作為自己的輸入”。使用遞迴函式，函式可以反覆呼叫自己。下面就是個使用Python定義的遞迴函式的例子：

def factorial_recursive(n):
 # Base case: 1! = 1
 if n == 1:
 return 1
 # 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
 if self.current > self.high:
 raise StopIteration
 else:
 self.current += 1
 return self.current - 1

第一個魔術方法“__iter__”（雙下劃線iter）返回迭代子，通常在迴圈開始時呼叫。__next__則返回迭代的下一個物件。

可以開啟命令列試一下下面的程式碼：

for c in Counter(3, 8):
 print(c)

這段程式碼將會輸出：

3
4
5
6
7
8

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

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

map(function, iterable)

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

[1, 2, 3, 4, 5]

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

x = [1, 2, 3, 4, 5]
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(3)
9

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

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

lambda x:

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

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

x = [1, 2, 3, 4, 5]
print(list(map(lambda num: num * 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),[1, 2, 3, 4])

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

過濾

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

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

語法如下：

filter(function, list)

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

x = range(-5, 5)
new_list = []
for num in x:
 if num < 0:
 new_list.append(num)

使用過濾可以寫成這樣：

x = range(-5, 5)
all_less_than_zero = list(filter(lambda num: num < 0, x))

高階函式

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

def summation(nums):
 return sum(nums)
def action(func, numbers):
 return func(numbers)
print(action(summation, [1, 2, 3]))
# Output is 6

或者更簡單“返回函式”的例子：

def rtnBrandon():
 return "brandon"
def rtnJohn():
 return "john"
def rtnPerson():
 age = int(input("What's your age?"))
 if age == 21:
 return rtnBrandon()
 else:
 return rtnJohn()

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

Python 中的所有函式都是頂級物件。頂級物件是擁有一個或多個以下特徵的物件：

• 在執行時生成
•  
• 賦值給某個資料結構中的變數或元素
•  
• 作為引數傳遞給函式
•  
• 作為函式的結果返回

所以，所有 Python 中的函式都是物件，都可以用作高階函式。

部分函式

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

def power(base, exponent):
 return base ** exponent

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

def square(base):
 return power(base, 2)

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

from functools import partial
square = partial(power, exponent=2)
print(square(2))
# output is 4

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

還可以使用迴圈來生成直到能計算 1000 次方的所有函式。

from functools import partial
powers = []
for x in range(2, 1001):
 powers.append(partial(power, exponent = x))
print(powers[0](3))
# output is 9

函數語言程式設計不夠 Python

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

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

>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one — and preferably only one — obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea — let’s do more of 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 a: 2
def foo(a):
 return 2

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

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

列表解析式

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

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

[function for item in iterable]

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

print([x * x for x in [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, 5)
all_less_than_zero = [num for num in x if num < 0]

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

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

x = range(-5, 5)
all_less_than_zero = list(map(lambda num: num * num, list(filter(lambda num: num < 0, x))))

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

x = range(-5, 5)
all_less_than_zero = [num * num for num in x if num < 0]

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

其他解析式

可以在任何可迭代物件上使用解析式。

任何可迭代物件都可以用解析式生成。從 Python 2.7 開始，甚至可以用解析式生成字典（雜湊表）。

# Taken from page 70 chapter 3 of Fluent Python by Luciano Ramalho
DIAL_CODES = [
 (86, 'China'),
 (91, 'India'),
 (1, 'United States'),
 (62, 'Indonesia'),
 (55, 'Brazil'),
 (92, 'Pakistan'),
 (880, 'Bangladesh'),
 (234, 'Nigeria'),
 (7, 'Russia'),
 (81, 'Japan'),
 ]
>>> country_code = {country: code for code, country in DIAL_CODES}
>>> country_code
{'Brazil': 55, 'Indonesia': 62, 'Pakistan': 92, 'Russia': 7, 'China': 86, 'United States': 1, 'Japan': 81, 'India': 91, 'Nigeria': 234, 'Bangladesh': 880}
>>> {code: country.upper() for country, code in country_code.items() if code < 66}
{1: 'UNITED STATES', 7: 'RUSSIA', 62: 'INDONESIA', 55: '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 i in range(32, 256) if 'SIGN' in 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 中使用函式式的模型，不過大家可以根據自己的喜好，記得用最好的工具完成工作。