2. 程式人生 > >Python的函數式編程

Python的函數式編程

阿新 • • 發佈：2018-12-12
元素 ret 程序員 操作 version 而已 raise 遞歸 兩種

Contents

  1. 1. 目標
  2. 2. 命令式編程 & 函數式編程
  3. 3. Python函數式編程的基本單元
    1. 3.1. lambda
    2. 3.2. map()
    3. 3.3. reduce()
    4. 3.4. filter()
  4. 4. 替換條件控制語句
  5. 5. 替換循環控制語句
    1. 5.1. 替換for循環
    2. 5.2. 替換while循環
  6. 6. 更多示例
  7. 7. 總結
  8. 8. 參考鏈接

很早以前就聽說過了函數式編程，印象中是一種很晦澀難懂的編程模式，但卻一直沒有去進行了解。

恰好這周組內的周會輪到我主持，一時也沒想到要分享什麽。靈光一閃，就選定函數式編程這個主題吧，反正組裏的同事都沒有學過，只需要講解入門方面的知識就好，也正好可以借這個機會逼迫自己去學習下這種新的編程方式。

經過初步了解，發現支持函數式編程的語言挺多的，除了像Lisp、Scheme、Haskell、Erlang這樣專用的函數式編程語言，我們常用的好多通用型編程語言（如Java、Python、Ruby、Javascript等）都支持函數式編程模式。考慮了下實際情況，最終還是選擇Python作為函數式編程的入門語言，因為組內同事都熟悉Python，以此作為切入點不會產生太大困難。

經過查詢資料和初步學習，對函數式編程有了些概念，經過整理，便形成了分享PPT。

以下便是這次分享的內容。

目標

通常，我們在新學習一門技術或者編程語言的時候，通常都會先從相關概念和特性入手。對於新接觸函數式編程的人來說，可能會想知道如下幾點：

  • 什麽是函數式編程？
  • 函數式編程的特點？
  • 函數式編程的用途？
  • 函數式編程相比於命令式編程和面向對象編程的優缺點？

但是我這次分享卻沒有按照這個思路，因為我感覺在一開始就向聽眾灌輸太多概念性的東西，反倒會讓聽眾感到迷糊。因為經過查詢資料發現，對於什麽是函數化編程，很難能有一個協調一致的定義。而且由於我也是新接觸，自身的理解可能會存在較大的偏差。

因此，我決定分享內容盡量從大家熟悉的命令式編程切入，通過大量實例來向聽眾展現函數式編程思維方式的不同之處。在這之後，再回過頭看這幾個問題，相信聽眾應該都會有更深刻的理解。

考慮到實際情況，本次分享希望能達成的目標是：

  • 了解函數式編程與命令式編程的主要區別
  • 掌握Python語言函數式編程的基本函數和算子
  • 會將簡單的命令式編程語句轉換為函數式編程

命令式編程 & 函數式編程

首先從大家熟悉的命令式編程開始，我們先回顧下平時在寫代碼時主要的情景。

其實，不管我們的業務代碼有多復雜，都離不開以下幾類操作：

  • 函數定義：def
  • 條件控制：if, elif, else
  • 循環控制：for, break, continue, while

當然，這只是部分操作類型，除此之外還應該有類和模塊、異常處理等等。但考慮到是入門，我們就先只關註上面這三種最常見的操作。

對應地，函數式編程也有自己的關鍵字。在Python語言中，用於函數式編程的主要由3個基本函數和1個算子。

  • 基本函數：map()、reduce()、filter()
  • 算子(operator)：lambda

令人驚訝的是，僅僅采用這幾個函數和算子就基本上可以實現任意Python程序。

當然，能實現是一回事兒，實際編碼時是否這麽寫又是另外一回事兒。估計要真只采用這幾個基本單元來寫所有代碼的話，不管是在表達上還是在閱讀上應該都挺別扭的。不過，嘗試采用這幾個基本單元來替代上述的函數定義、條件控制、循環控制等操作，對理解函數式編程如何通過函數和遞歸表達流程控制應該會很有幫助。

在開始嘗試將命令式編程轉換為函數式編程之前，我們還是需要先熟悉下這幾個基本單元。

Python函數式編程的基本單元

lambda

lambda這個關鍵詞在很多語言中都存在。簡單地說，它可以實現函數創建的功能。

如下便是lambda的兩種使用方式。

1 2 3 func1 = lambda : <expression()> func2 = lambda x : <expression(x)> func3 = lambda x,y : <expression(x,y)>

在第一條語句中，采用lambda創建了一個無參的函數func1。這和下面采用def創建函數的效果是相同的。

1 2 def func1(): <expression()>

在第二條和第三條語句中，分別采用lambda創建了需要傳入1個參數的函數func2，以及傳入2個參數的函數func3。這和下面采用def創建函數的效果是相同的。

1 2 3 4 5 def func2(x): <expression(x)> def func3(x,y): <expression(x,y)>

需要註意的是，調用func1的時候，雖然不需要傳入參數，但是必須要帶有括號()，否則返回的只是函數的定義，而非函數執行的結果。這個和在ruby中調用無參函數時有所不同，希望ruby程序員引起註意。

1 2 3 4 5 >>> func = lambda : 123 >>> func <function <lambda> at 0x100f4e1b8> >>> func() 123

另外，雖然在上面例子中都將lambda創建的函數賦值給了一個函數名，但這並不是必須的。從下面的例子中大家可以看到，很多時候我們都是直接調用lambda創建的函數，而並沒有命名一個函數，這也是我們常聽說的匿名函數的由來。

map()

map()函數的常見調用形式如下所示：

1 map(func, iterable)

map()需要兩個必填參數，第一個參數是一個函數名，第二個參數是一個可叠代的對象，如列表、元組等。

map()實現的功能很簡單，就是將第二個參數（iterable）中的每一個元素分別傳給第一個參數（func），依次執行函數得到結果，並將結果組成一個新的list對象後進行返回。返回結果永遠都是一個list。

簡單示例如下：

1 2 3 >>> double_func = lambda s : s * 2 >>> map(double_func, [1,2,3,4,5]) [2, 4, 6, 8, 10]

除了傳入一個可叠代對象這種常見的模式外，map()還支持傳入多個可叠代對象。

1 map(func, iterable1, iterable2)

在傳入多個可叠代對象的情況下，map()會依次從所有可叠代對象中依次取一個元素，組成一個元組列表，然後將元組依次傳給func；若可叠代對象的長度不一致，則會以None進行補上。

通過以下示例應該就比較容易理解。

1 2 3 4 5 6 7 >>> plus = lambda x,y : (x or 0) + (y or 0) >>> map(plus, [1,2,3], [4,5,6]) [5, 7, 9] >>> map(plus, [1,2,3,4], [4,5,6]) [5, 7, 9, 4] >>> map(plus, [1,2,3], [4,5,6,7]) [5, 7, 9, 7]

在上面的例子中，之所以采用x or 0的形式，是為了防止None + int出現異常。

需要註意的是，可叠代對象的個數應該與func的參數個數一致，否則就會出現異常，因為傳參個數與函數參數個數不一致了，這個應該比較好理解。

1 2 3 4 5 >>> plus = lambda x,y : x + y >>> map(plus, [1,2,3]) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: <lambda>() takes exactly 2 arguments (1 given)

另外，map()還存在一種特殊情況，就是func為None。這個時候，map()仍然是從所有可叠代對象中依次取一個元素，組成一個元組列表，然後將這個元組列表作為結果進行返回。

1 2 3 4 5 6 7 8 >>> map(None, [1,2,3,4]) [1, 2, 3, 4] >>> map(None, [1,2,3,4], [5,6,7,8]) [(1, 5), (2, 6), (3, 7), (4, 8)] >>> map(None, [1,2,3,4], [5,6,7]) [(1, 5), (2, 6), (3, 7), (4, None)] >>> map(None, [1,2,3,4], [6,7,8,9], [11,12]) [(1, 6, 11), (2, 7, 12), (3, 8, None), (4, 9, None)]

reduce()

reduce()函數的調用形式如下所示：

1 reduce(func, iterable[, initializer])

reduce()函數的功能是對可叠代對象（iterable）中的元素從左到右進行累計運算，最終得到一個數值。第三個參數initializer是初始數值，可以空置，空置為None時就從可叠代對象（iterable）的第二個元素開始，並將第一個元素作為之前的結果。

文字描述可能不大清楚，看下reduce()的源碼應該就比較清晰了。

1 2 3 4 5 6 7 8 9 10 11 def reduce(function, iterable, initializer=None): it = iter(iterable) if initializer is None: try: initializer = next(it) except StopIteration: raise TypeError(‘reduce() of empty sequence with no initial value‘) accum_value = initializer for x in it: accum_value = function(accum_value, x) return accum_value

再加上如下示例，對reduce()的功能應該就能掌握了。

1 2 3 4 5 >>> plus = lambda x, y : x + y >>> reduce(plus, [1,2,3,4,5]) 15 >>> reduce(plus, [1,2,3,4,5], 10) 25

filter()

filter()函數的調用形式如下：

1 filter(func, iterable)

filter()有且僅有兩個參數，第一個參數是一個函數名，第二個參數是一個可叠代的對象，如列表、元組等。

filter()函數的調用形式與map()比較相近，都是將第二個參數（iterable）中的每一個元素分別傳給第一個參數（func），依次執行函數得到結果；差異在於，filter()會判斷每次執行結果的bool值，並只將bool值為true的篩選出來，組成一個新的列表並進行返回。

1 2 3 >>> mode2 = lambda x : x % 2 >>> filter(mode2, [1,2,3,4,5,6,7,8,9,10]) [1, 3, 5, 7, 9]

以上便是Python函數式編程基本單元的核心內容。

接下來，我們就開始嘗試采用新學習到的基本單元對命令式編程中的條件控制和循環控制進行轉換。

替換條件控制語句

在對條件控制進行替換之前，我們先來回顧下Python中對布爾表達式求值時進行的“短路”處理。

什麽叫“短路”處理？簡單地講，就是如下兩點：

  • 在f(x) and g(y)中，當f(x)為false時，不會再執行g(y)，直接返回false
  • 在f(x) or g(y)中，當f(x)為true時，不會再執行g(y)，直接返回true

結論是顯然易現的，就不再過多解釋。

那麽，對應到條件控制語句，我們不難理解，如下條件控制語句和表達式是等價的。

1 2 3 4 # flow control statement if <cond1>: func1() elif <cond2>: func2() else: func3()
1 2 # Equivalent "short circuit" expression (<cond1> and func1()) or (<cond2> and func2()) or (func3())

通過這個等價替換，我們就去除掉了if/elif/else關鍵詞，將條件控制語句轉換為一個表達式。那這個表達式和函數式編程有什麽關系呢？

這時我們回顧上面講過的lambda，會發現lambda算子返回的就是一個表達式。

基於這一點，我們就可以采用lambda創建如下函數。

1 2 3 4 5 6 7 8 9 10 >>> pr = lambda s:s >>> print_num = lambda x: (x==1 and pr("one")) \ .... or (x==2 and pr("two")) \ .... or (pr("other")) >>> print_num(1) ‘one‘ >>> print_num(2) ‘two‘ >>> print_num(3) ‘other‘

通過函數調用的結果可以看到，以上函數實現的功能與之前的條件控制語句實現的功能完全相同。

到這裏，我們就實現了命令式條件控制語句向函數式語句的轉換。並且這個轉換的方法是通用的，所有條件控制語句都可以采用這種方式轉換為函數式語句。

替換循環控制語句

接下來我們再看循環控制語句的轉換。在Python中，循環控制是通過for和while這兩種方式實現的。

替換for循環

for循環語句的替換十分簡單，采用map()函數就能輕松實現。這主要是因為for語句和map()原理相同，都是對可叠代對象裏面的每一個元素進行操作，因此轉換過程比較自然。

1 2 3 4 5 # statement-based for loop for e in lst: func(e) # Equivalent map()-based loop map(func, lst)
1 2 3 4 5 6 7 8 9 10 >>> square = lambda x : x * x >>> for x in [1,2,3,4,5]: square(x) ... 1 4 9 16 25 >>> map(square, [1,2,3,4,5]) [1, 4, 9, 16, 25]

替換while循環

while循環語句的替換相比而言就復雜了許多。

下面分別是while循環語句及其對應的函數式風格的代碼。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 # statement-based while loop while <condition>: <pre-suite> if <break_condition>: break else: <suite> # Equivalent FP-style recursive while loop def while_block(): <pre-suite> if <break_condition>: return 1 else: <suite> return 0 while_FP = lambda: <condition> and (while_block() or while_FP()) while_FP()

這裏的難點在於，函數式while_FP循環采用了遞歸的概念。當<condition>為true時，進入循環體，執行while_block()；若<break_condition>為true時，返回1，while_FP()調用結束；若<break_condition>為false時，返回0，會繼續執行or右側的while_FP()，從而實現遞歸調用；若<break_condition>始終為false，則會持續遞歸調用while_FP()，這就實現了while語句中同樣的功能。

為了對函數式的while循環有更深刻的理解，可以再看下如下示例。這個例子是在網上找的，實現的是echo功能：輸入任意非”quit”字符時，打印輸入的字符；輸入”quit”字符時，退出程序。

1 2 3 4 5 6 7 8 9 10 11 12 ? PythonFP python pyecho.py IMP -- 1 1 IMP -- 2 2 IMP -- abc abc IMP -- 1 + 1 1 + 1 IMP -- quit quit ? PythonFP

如下便是分別采用過程式和函數式語句實現的”echo”功能。

1 2 3 4 5 6 7 8 9 # imperative version of "echo()" def echo_IMP(): while 1: x = raw_input("IMP -- ") print x if x == ‘quit‘: break echo_IMP()
1 2 3 4 5 6 7 def monadic_print(x): print x return x # FP version of "echo()" echo_FP = lambda: monadic_print(raw_input("FP -- "))==‘quit‘ or echo_FP() echo_FP()

更多示例

到此為止，我們對函數式編程總算有了點認識，到達之前設定的目標應該是沒有問題了，看來函數式編程也並沒有想象中的那麽難懂。

然而，這都只是函數式編程的皮毛而已，不信？再看下如下示例。

這個示例也是在網上找的，實現的是兩個列表笛卡爾積的篩選功能，找出笛卡爾積元組集合中兩個元素之積大於25的所有元組。

1 2 3 4 5 6 7 bigmuls = lambda xs,ys: filter(lambda (x,y):x*y > 25, combine(xs,ys)) combine = lambda xs,ys: map(None, xs*len(ys), dupelms(ys,len(xs))) dupelms = lambda lst,n: reduce(lambda s,t:s+t, map(lambda l,n=n: [l]*n, lst)) print bigmuls([1,2,3,4],[10,15,3,22]) [(3, 10), (4, 10), (2, 15), (3, 15), (4, 15), (2, 22), (3, 22), (4, 22)]

雖然這個例子中lambda/map/reduce/filter都是我們已經比較熟悉了的基本單元，但是經過組合後，理解起來還是會比較吃力。

總結

看到這裏，有的同學就開玩笑說我這標題名稱非常貼切，《Python的函數式編程–從入門到?放棄?》，因為以後在工作中應該也不會再嘗試使用函數式編程了，^_^。

不過，我還是覺得函數式編程挺有意思的，更高級的特性後面值得再繼續學習。即使代碼不用寫成pure函數式風格，但在某些時候局部使用lambda/map/reduce/filter也能大大簡化代碼，也是一個不錯的選擇。

另外，通過此次分享，再次切身體會到了教授是最好的學習方式，只有當你真正能將一個概念講解清楚的時候，你才算是掌握了這個概念。

參考鏈接

http://www.ibm.com/developerworks/linux/library/l-prog/index.html

Python的函數式編程

相關推薦

python函數式編程，列表生成式

value cti 函數編程 列表 fun zhang 導入 集合 過濾 1.python 中常見的集中存儲數據的結構： 　　列表 　　集合 　　字典 　　元組 　　字符串 　　雙隊列 　　堆 其中最常見的就是列表，字典。 2.下面講一些運用循環獲取字典列表的元素 1 &

python函數式編程（轉）

square 定義 每次 相加 匿名函數 是把 div spa 邏輯 函數式編程是使用一系列函數去解決問題，按照一般編程思維，面對問題時我們的思考方式是“怎麽幹”，而函數函數式編程的思考方式是我要“幹什麽”。 至於函數式編程的特點暫不總結，我們直接拿例子來體會什麽是函數式編

【人生苦短 PYTHON當歌】——PYTHON函數式編程03

遞歸 返回 blog div color lam round str python函數 Python遞歸 如果一個函數在內部調

Python 函數式編程和面向對象編程

cti get 函數名 self. string 結果 沒有 當前 ade 函數式編程 函數：function。函數式：functional，一種編程範式。函數式編程是一種抽象計算機的編程模式。函數！= 函數式（如計算！=計算機） 如下是不同語言的抽象 層次不同

python函數式編程之匿名函數、裝飾器、偏函數

返回 cor com art 顯式 python 偏函數 裝飾器 限制 匿名函數 當我們在傳入函數時，有些時候，不需要顯式的定義函數，直接傳入匿名函數就行。如下面 lambda x: x*x 在python中，關鍵字lambda表示匿名函數，冒號前面的x表示函數參數 匿名函

Python 函數式編程

每次 構造 高級 轉換成 偏函數 sort 結果 變為首字母大寫 ext 4.函數式編程 4.11高級函數 map接收2個參數，1個是函數對象本身，一個是Iterable list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])) ##red

Python函數式編程（把函數作為參數傳入）

lis list __name__ 就是 ret func port rgs color map:接受兩個參數（函數，Iterable），map將傳入的函數依次作用於Iterable的每個元素，並且返回新的Iterable def f(x): return x*

Python 函數式編程

編程範式 不同的 抽象 函數式 程序設計語言 副作用 編寫 得到 我們 函數式編程就是一種抽象程度很高的編程範式，純粹的函數式編程語言編寫的函數沒有變量，因此，任意一個函數，只要輸入是確定的，輸出就是確定的， 這種純函數我們稱之為沒有副作用。而允許使用變量的程序設計語言，由

Python-函數式編程-map reduce filter lambda 三元表達式 閉包

閉包 imp and 不能 from one 生成 經驗 結果 lambda 　　匿名函數，核心是作為算子，處理邏輯只有一行但具有函數的特性，核心用於函數式編程中 三元運算符 　　其實本質上是if分支的簡化版，滿足條件返回 if 前面的值，不滿足條件返回 else後面的

Python函數式編程

生成 IV python語言 檢查 trace 參數 返回 二進制 結果 ## 高階函數 　　- 接受函數為參數的函數稱為高階函數 def fn(num): 　　# 接收參數並打印 print(num) def run_fn(fn, num)

Python函數式編程之閉包

問題 cto lob num ret ber 全局變量 bre mil -------------------------函數式編程之*******閉包------------------------ Note： 一：簡介 函數式編程不是程序必須要的，但是對於簡化程序

python基礎13函數以及函數式編程

訪問 完整 多個參數 object spa 返回函數 位置參數 bject 分配 主要內容 函數基本語法及特性 參數與局部變 返回值 4.遞歸 名函數 6.函數式編程介紹 階函數 8.內置函數 函數基本語法及特性 定義 數學函數定義:一般的，在一個變化過程中，如果有

Python進階內容（六）--- 函數式編程

遞歸 斐波那契數列 blog n-1 range 正是 n) 偽代碼 ret 斐波那契數列(Fibonacci)的遞歸與非遞歸實現 費波那契數列由0和1開始，之後的數就由之前的兩數相加 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 1

python學習之4函數式編程（廖雪峰）

報錯 uil str log font abs col 輸出結果 都是 一、高階函數 1、變量可以指向函數 例如，python內置的求絕對值函數abs()： f=abs print(f(-10)) 輸出結果是10 2、函數名也是變量 任何函數名都是變量，如果對其賦值了，

python編程：函數式編程實現登錄和註冊

name def 函數式編程 數據 txt main函數 else if判斷 ima 不知道大家有沒有一種感覺，我明明學會了，為什麽一寫代碼就不知道從何下筆了。 初學函數編程的小夥伴通常需要檢測一下自己的學習成果，我們現在就寫一道通過函數來實現登錄和註冊的小程序 def

python筆記5：函數式編程

res () print 作用 map() 完成 false 逗號 單行函數 5 函數式編程（即高階函數，將函數作為參數傳入） map()： map()函數接收兩個參數，一個是傳入函數，一個是Iterable，map將傳入函數依次作用到序列的每個元素，並把結果作為新的It

Python之函數式編程

函數式編程 turn 排序 如果 冒泡 range tool 由於 對象 一、高階函數 1.map： 用法：map(函數對象，序列) 作用：將序列內每一個對象作用與函數的參數並生成一個新的序列返回 例子：將列表中的名字首字母大寫 其余字母小寫放入列表中 def Order

Python中級 —— 02函數式編程

... while 註意點 實現 惰性 函數的參數 return 並且 post 函數式編程 函數是Python內建支持的一種封裝，而函數式編程通俗說來就是把函數本身作為參數傳入另一個函數，允許返回一個函數。 函數名其實也是變量，也可以被賦值。如果函數名被賦值為其他值，則

Python基礎筆記：函數式編程：高階函數、返回函數、匿名函數、裝飾器、偏函數

iterator 因此 sum() hello 存在 不返回 原因 結構 接受 高階函數 高階函數：一個函數可以接收另一個函數作為參數 或 一個函數可以返回一個函數作為返回值，這種函數稱之為高階函數。 #函數 add 接收 f 函數作為參數 >>> de

Python學習筆記五函數式編程（二）

lis 運行 ast 計數 med tro append 避免 如果 參考教程：廖雪峰官網https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000 一、返回函數 高