函數式程式設計到底是什麼？本文将詳解其概念，同時分享怎樣在 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。冒号後面的一切都是對輸入的操作，然後它會自動傳回操作的結果。
這樣我們的求平方的代碼可以簡化成一行：
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 = []
if num < 0:
new_list.append(num)
使用過濾可以寫成這樣：
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()
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 次方的所有函數。
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]])
可以看到，我們給清單中的每個元素應用了一個函數。那麼怎樣才能實作過濾呢？先來看看之前的這段代碼：
print(all_less_than_zero)
可以将它轉換成下面這種使用清單解析式的方式：
all_less_than_zero = [num for num in x if num < 0]
像這樣，清單解析式支援 if 語句。這樣就不需要寫一堆函數來實作了。實際上，如果你需要生成某種清單，那麼很有可能使用清單解析式更友善、更簡潔。
如果想求所有小于 0 的數字的平方呢？使用 Lambda、映射和過濾可以寫成：
all_less_than_zero = list(map(lambda num: num * num, list(filter(lambda num: num < 0, x))))
看上去似乎很長，而且有點複雜。用清單解析式隻需寫成：
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 中使用函數式的模型，不過大家可以根據自己的喜好，記得用最好的工具完成工作。
