在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
10分鐘學會python函數式編程
函數式編程不是pythonic
您可能已經注意到了，我們想要在函數式編程中做的很多事情都圍繞著列表。除了reduce函數和閉包之外，您看到的所有函數都會生成列表。 Guido（Python之父）不喜歡Python中的函數式，因為Python已經有了自己生成列表的方法。
如果你在Python的交互環境下寫入”import this“，你將會得到：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
10分鐘學會python函數式編程
函數式編程不是pythonic
您可能已經注意到了，我們想要在函數式編程中做的很多事情都圍繞著列表。除了reduce函數和閉包之外，您看到的所有函數都會生成列表。 Guido（Python之父）不喜歡Python中的函數式，因為Python已經有了自己生成列表的方法。
如果你在Python的交互環境下寫入”import this“，你將會得到：
10分鐘學會python函數式編程
這是Python之禪。這是一首關於Pythonic意味著什麼的詩。我們想要涉及的部分是：
There should be one — and preferably only one — obvious way to do it.（應該儘量找到一種，最好是唯一一種明顯的解決方案）
在Python中，map和filter可以執行與列表推導（下面討論）相同的操作。這打破了Python之禪的一個規則，因此函數式編程的這些部分不被視為“pythonic”。
另一個話題是Lambda。在Python中，lambda函數是一個普通函數。 Lambda是語法糖。這兩種說法是等價的。
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
10分鐘學會python函數式編程
函數式編程不是pythonic
您可能已經注意到了，我們想要在函數式編程中做的很多事情都圍繞著列表。除了reduce函數和閉包之外，您看到的所有函數都會生成列表。 Guido（Python之父）不喜歡Python中的函數式，因為Python已經有了自己生成列表的方法。
如果你在Python的交互環境下寫入”import this“，你將會得到：
10分鐘學會python函數式編程
這是Python之禪。這是一首關於Pythonic意味著什麼的詩。我們想要涉及的部分是：
There should be one — and preferably only one — obvious way to do it.（應該儘量找到一種，最好是唯一一種明顯的解決方案）
在Python中，map和filter可以執行與列表推導（下面討論）相同的操作。這打破了Python之禪的一個規則，因此函數式編程的這些部分不被視為“pythonic”。
另一個話題是Lambda。在Python中，lambda函數是一個普通函數。 Lambda是語法糖。這兩種說法是等價的。
10分鐘學會python函數式編程
普通函數可以執行lambda函數可以執行的所有操作，但它不能以相反的方式工作。 lambda函數不能完成普通函數可以執行的所有操作。
這是一個簡短的論證，為什麼函數式編程不能很好地適應整個Python生態系統。你可能已經注意到我之前提到了列表推導，我們現在將討論它們。
列表推導
前面，我提到過你可以用map或filter做的任何事情，你可以用列表推導。列表推導是一種在Python中生成列表的方法。語法是：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
10分鐘學會python函數式編程
函數式編程不是pythonic
您可能已經注意到了，我們想要在函數式編程中做的很多事情都圍繞著列表。除了reduce函數和閉包之外，您看到的所有函數都會生成列表。 Guido（Python之父）不喜歡Python中的函數式，因為Python已經有了自己生成列表的方法。
如果你在Python的交互環境下寫入”import this“，你將會得到：
10分鐘學會python函數式編程
這是Python之禪。這是一首關於Pythonic意味著什麼的詩。我們想要涉及的部分是：
There should be one — and preferably only one — obvious way to do it.（應該儘量找到一種，最好是唯一一種明顯的解決方案）
在Python中，map和filter可以執行與列表推導（下面討論）相同的操作。這打破了Python之禪的一個規則，因此函數式編程的這些部分不被視為“pythonic”。
另一個話題是Lambda。在Python中，lambda函數是一個普通函數。 Lambda是語法糖。這兩種說法是等價的。
10分鐘學會python函數式編程
普通函數可以執行lambda函數可以執行的所有操作，但它不能以相反的方式工作。 lambda函數不能完成普通函數可以執行的所有操作。
這是一個簡短的論證，為什麼函數式編程不能很好地適應整個Python生態系統。你可能已經注意到我之前提到了列表推導，我們現在將討論它們。
列表推導
前面，我提到過你可以用map或filter做的任何事情，你可以用列表推導。列表推導是一種在Python中生成列表的方法。語法是：
10分鐘學會python函數式編程
讓我們對列表中的每個數字進行平方，例如：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
10分鐘學會python函數式編程
函數式編程不是pythonic
您可能已經注意到了，我們想要在函數式編程中做的很多事情都圍繞著列表。除了reduce函數和閉包之外，您看到的所有函數都會生成列表。 Guido（Python之父）不喜歡Python中的函數式，因為Python已經有了自己生成列表的方法。
如果你在Python的交互環境下寫入”import this“，你將會得到：
10分鐘學會python函數式編程
這是Python之禪。這是一首關於Pythonic意味著什麼的詩。我們想要涉及的部分是：
There should be one — and preferably only one — obvious way to do it.（應該儘量找到一種，最好是唯一一種明顯的解決方案）
在Python中，map和filter可以執行與列表推導（下面討論）相同的操作。這打破了Python之禪的一個規則，因此函數式編程的這些部分不被視為“pythonic”。
另一個話題是Lambda。在Python中，lambda函數是一個普通函數。 Lambda是語法糖。這兩種說法是等價的。
10分鐘學會python函數式編程
普通函數可以執行lambda函數可以執行的所有操作，但它不能以相反的方式工作。 lambda函數不能完成普通函數可以執行的所有操作。
這是一個簡短的論證，為什麼函數式編程不能很好地適應整個Python生態系統。你可能已經注意到我之前提到了列表推導，我們現在將討論它們。
列表推導
前面，我提到過你可以用map或filter做的任何事情，你可以用列表推導。列表推導是一種在Python中生成列表的方法。語法是：
10分鐘學會python函數式編程
讓我們對列表中的每個數字進行平方，例如：
10分鐘學會python函數式編程
我們可以看到如何將函數應用於列表中的每一項。我們如何應用filter呢？看看前面的代碼：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
10分鐘學會python函數式編程
函數式編程不是pythonic
您可能已經注意到了，我們想要在函數式編程中做的很多事情都圍繞著列表。除了reduce函數和閉包之外，您看到的所有函數都會生成列表。 Guido（Python之父）不喜歡Python中的函數式，因為Python已經有了自己生成列表的方法。
如果你在Python的交互環境下寫入”import this“，你將會得到：
10分鐘學會python函數式編程
這是Python之禪。這是一首關於Pythonic意味著什麼的詩。我們想要涉及的部分是：
There should be one — and preferably only one — obvious way to do it.（應該儘量找到一種，最好是唯一一種明顯的解決方案）
在Python中，map和filter可以執行與列表推導（下面討論）相同的操作。這打破了Python之禪的一個規則，因此函數式編程的這些部分不被視為“pythonic”。
另一個話題是Lambda。在Python中，lambda函數是一個普通函數。 Lambda是語法糖。這兩種說法是等價的。
10分鐘學會python函數式編程
普通函數可以執行lambda函數可以執行的所有操作，但它不能以相反的方式工作。 lambda函數不能完成普通函數可以執行的所有操作。
這是一個簡短的論證，為什麼函數式編程不能很好地適應整個Python生態系統。你可能已經注意到我之前提到了列表推導，我們現在將討論它們。
列表推導
前面，我提到過你可以用map或filter做的任何事情，你可以用列表推導。列表推導是一種在Python中生成列表的方法。語法是：
10分鐘學會python函數式編程
讓我們對列表中的每個數字進行平方，例如：
10分鐘學會python函數式編程
我們可以看到如何將函數應用於列表中的每一項。我們如何應用filter呢？看看前面的代碼：
10分鐘學會python函數式編程
我們可以將其轉換成一個列表推導，像這樣：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
10分鐘學會python函數式編程
函數式編程不是pythonic
您可能已經注意到了，我們想要在函數式編程中做的很多事情都圍繞著列表。除了reduce函數和閉包之外，您看到的所有函數都會生成列表。 Guido（Python之父）不喜歡Python中的函數式，因為Python已經有了自己生成列表的方法。
如果你在Python的交互環境下寫入”import this“，你將會得到：
10分鐘學會python函數式編程
這是Python之禪。這是一首關於Pythonic意味著什麼的詩。我們想要涉及的部分是：
There should be one — and preferably only one — obvious way to do it.（應該儘量找到一種，最好是唯一一種明顯的解決方案）
在Python中，map和filter可以執行與列表推導（下面討論）相同的操作。這打破了Python之禪的一個規則，因此函數式編程的這些部分不被視為“pythonic”。
另一個話題是Lambda。在Python中，lambda函數是一個普通函數。 Lambda是語法糖。這兩種說法是等價的。
10分鐘學會python函數式編程
普通函數可以執行lambda函數可以執行的所有操作，但它不能以相反的方式工作。 lambda函數不能完成普通函數可以執行的所有操作。
這是一個簡短的論證，為什麼函數式編程不能很好地適應整個Python生態系統。你可能已經注意到我之前提到了列表推導，我們現在將討論它們。
列表推導
前面，我提到過你可以用map或filter做的任何事情，你可以用列表推導。列表推導是一種在Python中生成列表的方法。語法是：
10分鐘學會python函數式編程
讓我們對列表中的每個數字進行平方，例如：
10分鐘學會python函數式編程
我們可以看到如何將函數應用於列表中的每一項。我們如何應用filter呢？看看前面的代碼：
10分鐘學會python函數式編程
我們可以將其轉換成一個列表推導，像這樣：
10分鐘學會python函數式編程
列表支持if這樣的語句。您不再需要將一百萬個函數應用於某些東西以獲得您想要的東西。事實上，如果你想嘗試生成某種列表，那麼使用列表推導看起來會更清晰，更容易。如果我們想要將列表中每個0以下的數字平方怎麼辦？有了lambda，map和filter你會寫：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
10分鐘學會python函數式編程
函數式編程不是pythonic
您可能已經注意到了，我們想要在函數式編程中做的很多事情都圍繞著列表。除了reduce函數和閉包之外，您看到的所有函數都會生成列表。 Guido（Python之父）不喜歡Python中的函數式，因為Python已經有了自己生成列表的方法。
如果你在Python的交互環境下寫入”import this“，你將會得到：
10分鐘學會python函數式編程
這是Python之禪。這是一首關於Pythonic意味著什麼的詩。我們想要涉及的部分是：
There should be one — and preferably only one — obvious way to do it.（應該儘量找到一種，最好是唯一一種明顯的解決方案）
在Python中，map和filter可以執行與列表推導（下面討論）相同的操作。這打破了Python之禪的一個規則，因此函數式編程的這些部分不被視為“pythonic”。
另一個話題是Lambda。在Python中，lambda函數是一個普通函數。 Lambda是語法糖。這兩種說法是等價的。
10分鐘學會python函數式編程
普通函數可以執行lambda函數可以執行的所有操作，但它不能以相反的方式工作。 lambda函數不能完成普通函數可以執行的所有操作。
這是一個簡短的論證，為什麼函數式編程不能很好地適應整個Python生態系統。你可能已經注意到我之前提到了列表推導，我們現在將討論它們。
列表推導
前面，我提到過你可以用map或filter做的任何事情，你可以用列表推導。列表推導是一種在Python中生成列表的方法。語法是：
10分鐘學會python函數式編程
讓我們對列表中的每個數字進行平方，例如：
10分鐘學會python函數式編程
我們可以看到如何將函數應用於列表中的每一項。我們如何應用filter呢？看看前面的代碼：
10分鐘學會python函數式編程
我們可以將其轉換成一個列表推導，像這樣：
10分鐘學會python函數式編程
列表支持if這樣的語句。您不再需要將一百萬個函數應用於某些東西以獲得您想要的東西。事實上，如果你想嘗試生成某種列表，那麼使用列表推導看起來會更清晰，更容易。如果我們想要將列表中每個0以下的數字平方怎麼辦？有了lambda，map和filter你會寫：
10分鐘學會python函數式編程
這似乎很長很複雜。通過列表推導，它只是：
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
10分鐘學會python函數式編程
函數式編程不是pythonic
您可能已經注意到了，我們想要在函數式編程中做的很多事情都圍繞著列表。除了reduce函數和閉包之外，您看到的所有函數都會生成列表。 Guido（Python之父）不喜歡Python中的函數式，因為Python已經有了自己生成列表的方法。
如果你在Python的交互環境下寫入”import this“，你將會得到：
10分鐘學會python函數式編程
這是Python之禪。這是一首關於Pythonic意味著什麼的詩。我們想要涉及的部分是：
There should be one — and preferably only one — obvious way to do it.（應該儘量找到一種，最好是唯一一種明顯的解決方案）
在Python中，map和filter可以執行與列表推導（下面討論）相同的操作。這打破了Python之禪的一個規則，因此函數式編程的這些部分不被視為“pythonic”。
另一個話題是Lambda。在Python中，lambda函數是一個普通函數。 Lambda是語法糖。這兩種說法是等價的。
10分鐘學會python函數式編程
普通函數可以執行lambda函數可以執行的所有操作，但它不能以相反的方式工作。 lambda函數不能完成普通函數可以執行的所有操作。
這是一個簡短的論證，為什麼函數式編程不能很好地適應整個Python生態系統。你可能已經注意到我之前提到了列表推導，我們現在將討論它們。
列表推導
前面，我提到過你可以用map或filter做的任何事情，你可以用列表推導。列表推導是一種在Python中生成列表的方法。語法是：
10分鐘學會python函數式編程
讓我們對列表中的每個數字進行平方，例如：
10分鐘學會python函數式編程
我們可以看到如何將函數應用於列表中的每一項。我們如何應用filter呢？看看前面的代碼：
10分鐘學會python函數式編程
我們可以將其轉換成一個列表推導，像這樣：
10分鐘學會python函數式編程
列表支持if這樣的語句。您不再需要將一百萬個函數應用於某些東西以獲得您想要的東西。事實上，如果你想嘗試生成某種列表，那麼使用列表推導看起來會更清晰，更容易。如果我們想要將列表中每個0以下的數字平方怎麼辦？有了lambda，map和filter你會寫：
10分鐘學會python函數式編程
這似乎很長很複雜。通過列表推導，它只是：
10分鐘學會python函數式編程
列表推導僅適用於列表。map,filter適合任何可迭代的對象，那麼這有什麼用呢？你可以對你遇到的任何可迭代對象使用任何推導。
其他推導
你可以為任何可迭代對象創建一個推導。
可以使用推導生成任何可迭代的對象。從Python 2.7開始，您甚至可以生成字典（hashmap）。
如果它是可迭代的，則可以生成它。讓我們看一下最後一組的例子。
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
10分鐘學會python函數式編程
函數式編程不是pythonic
您可能已經注意到了，我們想要在函數式編程中做的很多事情都圍繞著列表。除了reduce函數和閉包之外，您看到的所有函數都會生成列表。 Guido（Python之父）不喜歡Python中的函數式，因為Python已經有了自己生成列表的方法。
如果你在Python的交互環境下寫入”import this“，你將會得到：
10分鐘學會python函數式編程
這是Python之禪。這是一首關於Pythonic意味著什麼的詩。我們想要涉及的部分是：
There should be one — and preferably only one — obvious way to do it.（應該儘量找到一種，最好是唯一一種明顯的解決方案）
在Python中，map和filter可以執行與列表推導（下面討論）相同的操作。這打破了Python之禪的一個規則，因此函數式編程的這些部分不被視為“pythonic”。
另一個話題是Lambda。在Python中，lambda函數是一個普通函數。 Lambda是語法糖。這兩種說法是等價的。
10分鐘學會python函數式編程
普通函數可以執行lambda函數可以執行的所有操作，但它不能以相反的方式工作。 lambda函數不能完成普通函數可以執行的所有操作。
這是一個簡短的論證，為什麼函數式編程不能很好地適應整個Python生態系統。你可能已經注意到我之前提到了列表推導，我們現在將討論它們。
列表推導
前面，我提到過你可以用map或filter做的任何事情，你可以用列表推導。列表推導是一種在Python中生成列表的方法。語法是：
10分鐘學會python函數式編程
讓我們對列表中的每個數字進行平方，例如：
10分鐘學會python函數式編程
我們可以看到如何將函數應用於列表中的每一項。我們如何應用filter呢？看看前面的代碼：
10分鐘學會python函數式編程
我們可以將其轉換成一個列表推導，像這樣：
10分鐘學會python函數式編程
列表支持if這樣的語句。您不再需要將一百萬個函數應用於某些東西以獲得您想要的東西。事實上，如果你想嘗試生成某種列表，那麼使用列表推導看起來會更清晰，更容易。如果我們想要將列表中每個0以下的數字平方怎麼辦？有了lambda，map和filter你會寫：
10分鐘學會python函數式編程
這似乎很長很複雜。通過列表推導，它只是：
10分鐘學會python函數式編程
列表推導僅適用於列表。map,filter適合任何可迭代的對象，那麼這有什麼用呢？你可以對你遇到的任何可迭代對象使用任何推導。
其他推導
你可以為任何可迭代對象創建一個推導。
可以使用推導生成任何可迭代的對象。從Python 2.7開始，您甚至可以生成字典（hashmap）。
如果它是可迭代的，則可以生成它。讓我們看一下最後一組的例子。
10分鐘學會python函數式編程
set是一個元素列表，在該列表中沒有元素重複兩次。
set中的元素沒有順序。
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
10分鐘學會python函數式編程
函數式編程不是pythonic
您可能已經注意到了，我們想要在函數式編程中做的很多事情都圍繞著列表。除了reduce函數和閉包之外，您看到的所有函數都會生成列表。 Guido（Python之父）不喜歡Python中的函數式，因為Python已經有了自己生成列表的方法。
如果你在Python的交互環境下寫入”import this“，你將會得到：
10分鐘學會python函數式編程
這是Python之禪。這是一首關於Pythonic意味著什麼的詩。我們想要涉及的部分是：
There should be one — and preferably only one — obvious way to do it.（應該儘量找到一種，最好是唯一一種明顯的解決方案）
在Python中，map和filter可以執行與列表推導（下面討論）相同的操作。這打破了Python之禪的一個規則，因此函數式編程的這些部分不被視為“pythonic”。
另一個話題是Lambda。在Python中，lambda函數是一個普通函數。 Lambda是語法糖。這兩種說法是等價的。
10分鐘學會python函數式編程
普通函數可以執行lambda函數可以執行的所有操作，但它不能以相反的方式工作。 lambda函數不能完成普通函數可以執行的所有操作。
這是一個簡短的論證，為什麼函數式編程不能很好地適應整個Python生態系統。你可能已經注意到我之前提到了列表推導，我們現在將討論它們。
列表推導
前面，我提到過你可以用map或filter做的任何事情，你可以用列表推導。列表推導是一種在Python中生成列表的方法。語法是：
10分鐘學會python函數式編程
讓我們對列表中的每個數字進行平方，例如：
10分鐘學會python函數式編程
我們可以看到如何將函數應用於列表中的每一項。我們如何應用filter呢？看看前面的代碼：
10分鐘學會python函數式編程
我們可以將其轉換成一個列表推導，像這樣：
10分鐘學會python函數式編程
列表支持if這樣的語句。您不再需要將一百萬個函數應用於某些東西以獲得您想要的東西。事實上，如果你想嘗試生成某種列表，那麼使用列表推導看起來會更清晰，更容易。如果我們想要將列表中每個0以下的數字平方怎麼辦？有了lambda，map和filter你會寫：
10分鐘學會python函數式編程
這似乎很長很複雜。通過列表推導，它只是：
10分鐘學會python函數式編程
列表推導僅適用於列表。map,filter適合任何可迭代的對象，那麼這有什麼用呢？你可以對你遇到的任何可迭代對象使用任何推導。
其他推導
你可以為任何可迭代對象創建一個推導。
可以使用推導生成任何可迭代的對象。從Python 2.7開始，您甚至可以生成字典（hashmap）。
如果它是可迭代的，則可以生成它。讓我們看一下最後一組的例子。
10分鐘學會python函數式編程
set是一個元素列表，在該列表中沒有元素重複兩次。
set中的元素沒有順序。
10分鐘學會python函數式編程
您可能會注意到set（集合）與dict（字典）具有相同的花括號。 Python非常聰明。根據你是否為dict提供值，它會知道你是在寫dict推導還是set推導。
最後給大家分享一套Python400集視頻教程➕電子書籍。
獲取方式：轉發本文、然後來私信小編“學習”即可免費領取哦！
在這篇文章裡，你將學會什麼是函數範式以及如何使用Python進行函數式編程。你也將瞭解列表推導和其它形式的推導。
函數範式
在命令式範式中，通過為計算機提供一系列指令然後執行它們來完成任務。在執行這些指令時，可以改變某些狀態。例如，假設你最初將A設置為5，然後更改A的值。這時在變量內部值的意義上，你改變了A的狀態。
在函數式範式中，你不用告訴計算機做什麼而是告訴他這個東西是什麼。比如數字的最大公約數是什麼，從1到n的乘積是什麼等等。
因此，變量不能變化。一旦你設置了一個變量，它就永遠保持這種狀態（注意，在純函數式語言中，它們不是變量）。因此，函數式編程沒有副作用。副作用指的是函數改變它自己以外的東西。讓我們看一些典型Python代碼的示例：
10分鐘學會python函數式編程
這段代碼的輸出是5。在函數式範式中，改變變量是一個很大的禁忌，並且具有影響其範圍之外事物的功能也是一個很大的禁忌。函數唯一能做的就是計算一些東西並將其作為結果返回。
現在你可能會想：“沒有變量，沒有副作用？為什麼這樣好？“這個問題問得好，我相信大多數人對此感到疑惑。
如果使用相同的參數調用函數兩次，則保證返回相同的結果。如果你已經學習了數學函數，你就會知道這個好處。這稱為參照透明度。由於函數沒有副作用，如果你正在構建一個計算某些事情的程序，你可以加速程序。如果每次調用func(2)都返回3，我們可以將它存儲在表中，這可以防止程序重複運行相同的功能。
通常，在函數式編程中，我們不使用循環。我們使用遞歸。遞歸是一個數學概念，通常意味著“自我調用”。使用遞歸函數，該函數將其自身作為子函數重複調用。這是Python中遞歸函數的一個很好的例子：
10分鐘學會python函數式編程
有些編程語言也具有惰性。這意味著他們直到最後一秒才計算或做任何事情。如果你編寫一些代碼來執行2 + 2，函數程序只會在你真正需要使用結果時計算出來。我們很快就會在Python中探索惰性。
Map
為了理解，我們先來看看迭代是什麼。通常可以迭代的對象是列表或數組，但Python有許多不同的類型可以迭代。你甚至可以創建自己的對象，這些對象可以通過實現魔術方法進行迭代。魔術方法就像是一個API，可以幫助你的對象變得更加Pythonic。您需要實現2個魔術方法才能使對象成為可迭代的：
10分鐘學會python函數式編程
第一個魔術方法“iter”（注：這裡是雙下劃線）返回迭代對象，這通常在循環開始時使用。”next“返回下一個對象。
讓我們快速進入一個終端調用上面的代碼：
10分鐘學會python函數式編程
運行將會打印出
10分鐘學會python函數式編程
在Python中，迭代器是一個只有iter魔術方法的對象。這意味著您可以訪問對象中的位置，但不能遍歷該對象。一些對象將具有魔術方法next而不是iter魔術方法，例如集合（在本文後面討論）。對於本文，我們假設我們接觸的所有內容都是可迭代的對象。
現在我們知道什麼是可迭代對象了，讓我們回到map函數。 map函數允許我們將函數應用於iterable中的每一項。 Map需要2個輸入，它們分別是要應用的函數和可迭代對象。
10分鐘學會python函數式編程
假設我們有一個數字列表，如下所示：
10分鐘學會python函數式編程
我們想要對每個數字進行平方，我們可以編寫如下代碼：
10分鐘學會python函數式編程
Python中函數式的函數是具有惰性的。如果我們不使用“list”，該函數將存儲iterable的定義，而不是列表本身。我們需要明確告訴Python“把它變成一個列表”供我們使用。
在Python中突然從非惰性求值轉向惰性求值有點奇怪。如果你在函數式思維方式中考慮得更多，而不是命令式思維方式，那麼你最終會習慣它。
現在寫一個像“square(num)”這樣的普通函數雖然很好，但卻是不對的。我們必須定義一個完整的函數才能在map中使用它？好吧，我們可以使用lambda（匿名）函數在map中定義一個函數。
Lambda表達式
lambda表達式是一個只有一行的函數。舉個例子，這個lambda表達式對給定的數字進行平方：
10分鐘學會python函數式編程
讓我們運行它：
10分鐘學會python函數式編程
這看起來不像一個函數嗎？
嗯，這有點令人困惑，但可以解釋。我們將一些東西分配給變量“square”。那這個呢：
10分鐘學會python函數式編程
告訴Python這是一個lambda函數，輸入叫做x。冒號之後的任何內容都是您對輸入所做的操作，它會自動返回結果。
簡化我們的square程序到只有一行代碼，我們可以這樣做：
10分鐘學會python函數式編程
所以在lambda表達式中，所有參數都在左邊，你要用它們做的東西在右邊。它有點亂。但事實是，編寫只有其他函數式程序員才能閱讀的代碼會有一定的樂趣。此外，使用一個函數並將其轉換為一行代碼是非常酷的。
Reduce
Reduce是一個將迭代變成一個東西的函數。通常，你可以在列表上使用reduce函數執行計算以將其減少到一個數字。 Reduce看起來像這樣：
10分鐘學會python函數式編程
我們經常會使用lambda表達式作為函數。
列表的乘積是每個單獨的數字相乘。要做到這一點你將編寫如下代碼：
10分鐘學會python函數式編程
但是使用reduce你可以這樣寫：
10分鐘學會python函數式編程
獲得相同的功能，代碼更短，並且在使用函數式編程的情況下更整潔。（注：reduce函數在Python3中已不是內置函數，需要從functools模塊中導入）
Filter
filter函數採用可迭代的方式，並過濾掉你在該可迭代中不需要的所有內容。
通常，filter需要一個函數和一個列表。它將函數應用於列表中的每一項，如果該函數返回True，則不執行任何操作。如果返回False，則從列表中刪除該項。
語法如下：
10分鐘學會python函數式編程
讓我們看一個小例子，沒有filter我們會寫：
10分鐘學會python函數式編程
使用filter，可以這樣寫：
10分鐘學會python函數式編程
高階函數
高階函數可以將函數作為參數並返回函數。一個非常簡單的例子如下：
10分鐘學會python函數式編程
第二個返回函數的例子：
10分鐘學會python函數式編程
開頭我說過純函數式編程語言沒有變量。更高階的函數使這變得更容易。
Python中的所有函數都是一等公民。一等公民被定義為具有以下一個或多個特徵：
在運行時創建
在數據結構中分配變量或元素
作為函數的參數傳遞
作為函數的結果返回
Python中的所有函數都可以用作高階函數。
Partial application
Partial application（也稱為閉包）有點奇怪，但非常酷。您可以在不提供所需的所有參數的情況下調用函數。讓我們在一個例子中看到這一點。我們想要創建一個函數，它接受2個參數，一個基數和一個指數，並返回指數冪的基數，如下所示：
10分鐘學會python函數式編程
現在我們想要一個專用的平方函數，使用冪函數計算出數字的平方：
10分鐘學會python函數式編程
這有效，但如果我們想要一個立方體功能呢？或者求四次方的功能呢？我們可以繼續寫下它們嗎？好吧，你可以。但程序員很懶的。如果你一遍又一遍地重複同樣的事情，這表明有一種更快的方法來加快速度，這將使你不再重複。我們可以在這裡使用閉包。讓我們看一個使用閉包的square函數的示例：
10分鐘學會python函數式編程
是不是很酷！我們可以只使用1個參數來調用需要2個參數的函數。
我們還可以使用一個循環來生成一個冪函數，該函數實現從立方體一直到1000的冪。
10分鐘學會python函數式編程
函數式編程不是pythonic
您可能已經注意到了，我們想要在函數式編程中做的很多事情都圍繞著列表。除了reduce函數和閉包之外，您看到的所有函數都會生成列表。 Guido（Python之父）不喜歡Python中的函數式，因為Python已經有了自己生成列表的方法。
如果你在Python的交互環境下寫入”import this“，你將會得到：
10分鐘學會python函數式編程
這是Python之禪。這是一首關於Pythonic意味著什麼的詩。我們想要涉及的部分是：
There should be one — and preferably only one — obvious way to do it.（應該儘量找到一種，最好是唯一一種明顯的解決方案）
在Python中，map和filter可以執行與列表推導（下面討論）相同的操作。這打破了Python之禪的一個規則，因此函數式編程的這些部分不被視為“pythonic”。
另一個話題是Lambda。在Python中，lambda函數是一個普通函數。 Lambda是語法糖。這兩種說法是等價的。
10分鐘學會python函數式編程
普通函數可以執行lambda函數可以執行的所有操作，但它不能以相反的方式工作。 lambda函數不能完成普通函數可以執行的所有操作。
這是一個簡短的論證，為什麼函數式編程不能很好地適應整個Python生態系統。你可能已經注意到我之前提到了列表推導，我們現在將討論它們。
列表推導
前面，我提到過你可以用map或filter做的任何事情，你可以用列表推導。列表推導是一種在Python中生成列表的方法。語法是：
10分鐘學會python函數式編程
讓我們對列表中的每個數字進行平方，例如：
10分鐘學會python函數式編程
我們可以看到如何將函數應用於列表中的每一項。我們如何應用filter呢？看看前面的代碼：
10分鐘學會python函數式編程
我們可以將其轉換成一個列表推導，像這樣：
10分鐘學會python函數式編程
列表支持if這樣的語句。您不再需要將一百萬個函數應用於某些東西以獲得您想要的東西。事實上，如果你想嘗試生成某種列表，那麼使用列表推導看起來會更清晰，更容易。如果我們想要將列表中每個0以下的數字平方怎麼辦？有了lambda，map和filter你會寫：
10分鐘學會python函數式編程
這似乎很長很複雜。通過列表推導，它只是：
10分鐘學會python函數式編程
列表推導僅適用於列表。map,filter適合任何可迭代的對象，那麼這有什麼用呢？你可以對你遇到的任何可迭代對象使用任何推導。
其他推導
你可以為任何可迭代對象創建一個推導。
可以使用推導生成任何可迭代的對象。從Python 2.7開始，您甚至可以生成字典（hashmap）。
如果它是可迭代的，則可以生成它。讓我們看一下最後一組的例子。
10分鐘學會python函數式編程
set是一個元素列表，在該列表中沒有元素重複兩次。
set中的元素沒有順序。
10分鐘學會python函數式編程
您可能會注意到set（集合）與dict（字典）具有相同的花括號。 Python非常聰明。根據你是否為dict提供值，它會知道你是在寫dict推導還是set推導。
最後給大家分享一套Python400集視頻教程➕電子書籍。
獲取方式：轉發本文、然後來私信小編“學習”即可免費領取哦！