Python函數(shù)式編程，從入門到?放棄?

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

恰好這周組內(nèi)的周會(huì)輪到我主持，一時(shí)也沒想到要分享什么。靈光一閃，就選定函數(shù)式編程這個(gè)主題吧，反正組里的同事都沒有學(xué)過，只需要講解入門方面的知識(shí)就好，也正好可以借這個(gè)機(jī)會(huì)逼迫自己去學(xué)習(xí)下這種新的編程方式。

經(jīng)過初步了解，發(fā)現(xiàn)支持函數(shù)式編程的語言挺多的，除了像Lisp、Scheme、Haskell、Erlang這樣專用的函數(shù)式編程語言，我們常用的好多通用型編程語言（如Java、Python、Ruby、Javascript等）都支持函數(shù)式編程模式。考慮了下實(shí)際情況，最終還是選擇Python作為函數(shù)式編程的入門語言，因?yàn)榻M內(nèi)同事都熟悉Python，以此作為切入點(diǎn)不會(huì)產(chǎn)生太大困難。

經(jīng)過查詢資料和初步學(xué)習(xí)，對函數(shù)式編程有了些概念，經(jīng)過整理，便形成了分享PPT。

以下便是這次分享的內(nèi)容。

目標(biāo)

通常，我們在新學(xué)習(xí)一門技術(shù)或者編程語言的時(shí)候，通常都會(huì)先從相關(guān)概念和特性入手。對于新接觸函數(shù)式編程的人來說，可能會(huì)想知道如下幾點(diǎn)：

什么是函數(shù)式編程？

函數(shù)式編程的特點(diǎn)？

函數(shù)式編程的用途？

函數(shù)式編程相比于命令式編程和面向?qū)ο缶幊痰膬?yōu)缺點(diǎn)？

但是我這次分享卻沒有按照這個(gè)思路，因?yàn)槲腋杏X在一開始就向聽眾灌輸太多概念性的東西，反倒會(huì)讓聽眾感到迷糊。因?yàn)榻?jīng)過查詢資料發(fā)現(xiàn)，對于什么是函數(shù)化編程，很難能有一個(gè)協(xié)調(diào)一致的定義。而且由于我也是新接觸，自身的理解可能會(huì)存在較大的偏差。

因此，我決定分享內(nèi)容盡量從大家熟悉的命令式編程切入，通過大量實(shí)例來向聽眾展現(xiàn)函數(shù)式編程思維方式的不同之處。在這之后，再回過頭看這幾個(gè)問題，相信聽眾應(yīng)該都會(huì)有更深刻的理解。

考慮到實(shí)際情況，本次分享希望能達(dá)成的目標(biāo)是：

了解函數(shù)式編程與命令式編程的主要區(qū)別

掌握Python語言函數(shù)式編程的基本函數(shù)和算子

會(huì)將簡單的命令式編程語句轉(zhuǎn)換為函數(shù)式編程

命令式編程 & 函數(shù)式編程

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

其實(shí)，不管我們的業(yè)務(wù)代碼有多復(fù)雜，都離不開以下幾類操作：

函數(shù)定義：def

條件控制：if, elif, else

循環(huán)控制：for, break, continue, while

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

對應(yīng)地，函數(shù)式編程也有自己的關(guān)鍵字。在Python語言中，用于函數(shù)式編程的主要由3個(gè)基本函數(shù)和1個(gè)算子。

基本函數(shù)：map()、reduce()、filter()

算子(operator)：lambda

令人驚訝的是，僅僅采用這幾個(gè)函數(shù)和算子就基本上可以實(shí)現(xiàn)任意Python程序。

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

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

Python函數(shù)式編程的基本單元

lambda

lambda這個(gè)關(guān)鍵詞在很多語言中都存在。簡單地說，它可以實(shí)現(xiàn)函數(shù)創(chuàng)建的功能。

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

func1=lambda: <expression()>

func2=lambdax: <expression(x)>

func3=lambdax,y: <expression(x,y)>

在第一條語句中，采用lambda創(chuàng)建了一個(gè)無參的函數(shù)func1。這和下面采用def創(chuàng)建函數(shù)的效果是相同的。

def func1():

    <expression()>

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

def func2(x):

    <expression(x)>

 

def func3(x,y):

    <expression(x,y)>

需要注意的是，調(diào)用func1的時(shí)候，雖然不需要傳入?yún)?shù)，但是必須要帶有括號(hào)()，否則返回的只是函數(shù)的定義，而非函數(shù)執(zhí)行的結(jié)果。這個(gè)和在ruby中調(diào)用無參函數(shù)時(shí)有所不同，希望ruby程序員引起注意。

>>>func=lambda:123

>>>func

<function<lambda>at0x100f4e1b8>

>>>func()

123

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

map()

map()函數(shù)的常見調(diào)用形式如下所示：

map(func, iterable)

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

map()實(shí)現(xiàn)的功能很簡單，就是將第二個(gè)參數(shù)（iterable）中的每一個(gè)元素分別傳給第一個(gè)參數(shù)（func），依次執(zhí)行函數(shù)得到結(jié)果，并將結(jié)果組成一個(gè)新的list對象后進(jìn)行返回。返回結(jié)果永遠(yuǎn)都是一個(gè)list。

簡單示例如下：

>>>double_func=lambdas:s *2

>>>map(double_func,[1,2,3,4,5])

[2,4,6,8,10]

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

map(func, iterable1, iterable2)

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

通過以下示例應(yīng)該就比較容易理解。

>>>plus=lambdax,y:(xor0)+(yor0)

>>>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出現(xiàn)異常。

需要注意的是，可迭代對象的個(gè)數(shù)應(yīng)該與func的參數(shù)個(gè)數(shù)一致，否則就會(huì)出現(xiàn)異常，因?yàn)閭鲄€(gè)數(shù)與函數(shù)參數(shù)個(gè)數(shù)不一致了，這個(gè)應(yīng)該比較好理解。

>>>plus=lambdax,y:x+y

>>>map(plus,[1,2,3])

Traceback(most recent calllast):

  File"<stdin>",line1,in<module>

TypeError: <lambda>()takesexactly2arguments(1given)

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

>>>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()函數(shù)的調(diào)用形式如下所示：

reduce(func, iterable[, initializer])

reduce()函數(shù)的功能是對可迭代對象（iterable）中的元素從左到右進(jìn)行累計(jì)運(yùn)算，最終得到一個(gè)數(shù)值。第三個(gè)參數(shù)initializer是初始數(shù)值，可以空置，空置為None時(shí)就從可迭代對象（iterable）的第二個(gè)元素開始，并將第一個(gè)元素作為之前的結(jié)果。

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

def reduce(function,iterable,initializer=None):

    it=iter(iterable)

    ifinitializerisNone:

        try:

            initializer=next(it)

        exceptStopIteration:

            raise TypeError('reduce() of empty sequence with no initial value')

    accum_value=initializer

    forxinit:

        accum_value=function(accum_value,x)

    returnaccum_value

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

>>>plus=lambdax,y:x+y

>>>reduce(plus,[1,2,3,4,5])

15

>>>reduce(plus,[1,2,3,4,5],10)

25

filter()

filter()函數(shù)的調(diào)用形式如下：

filter(func, iterable)

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

filter()函數(shù)的調(diào)用形式與map()比較相近，都是將第二個(gè)參數(shù)（iterable）中的每一個(gè)元素分別傳給第一個(gè)參數(shù)（func），依次執(zhí)行函數(shù)得到結(jié)果；差異在于，filter()會(huì)判斷每次執(zhí)行結(jié)果的bool值，并只將bool值為true的篩選出來，組成一個(gè)新的列表并進(jìn)行返回。

>>>mode2=lambdax:x%2

>>>filter(mode2,[1,2,3,4,5,6,7,8,9,10])

[1,3,5,7,9]

以上便是Python函數(shù)式編程基本單元的核心內(nèi)容。

接下來，我們就開始嘗試采用新學(xué)習(xí)到的基本單元對命令式編程中的條件控制和循環(huán)控制進(jìn)行轉(zhuǎn)換。

替換條件控制語句

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

什么叫“短路”處理？簡單地講，就是如下兩點(diǎn)：

在f(x) and g(y)中，當(dāng)f(x)為false時(shí)，不會(huì)再執(zhí)行g(shù)(y)，直接返回false

在f(x) or g(y)中，當(dāng)f(x)為true時(shí)，不會(huì)再執(zhí)行g(shù)(y)，直接返回true

結(jié)論是顯然易現(xiàn)的，就不再過多解釋。

那么，對應(yīng)到條件控制語句，我們不難理解，如下條件控制語句和表達(dá)式是等價(jià)的。

# flow control statement

if<cond1>:  func1()

elif<cond2>:func2()

else:        func3()

# Equivalent "short circuit" expression

(<cond1>andfunc1())or(<cond2>andfunc2())or(func3())

通過這個(gè)等價(jià)替換，我們就去除掉了if/elif/else關(guān)鍵詞，將條件控制語句轉(zhuǎn)換為一個(gè)表達(dá)式。那這個(gè)表達(dá)式和函數(shù)式編程有什么關(guān)系呢？

這時(shí)我們回顧上面講過的lambda，會(huì)發(fā)現(xiàn)lambda算子返回的就是一個(gè)表達(dá)式。

基于這一點(diǎn)，我們就可以采用lambda創(chuàng)建如下函數(shù)。

>>>pr=lambdas:s

>>>print_num=lambdax:(x==1andpr("one"))

....                  or(x==2andpr("two"))

....                  or(pr("other"))

>>>print_num(1)

'one'

>>>print_num(2)

'two'

>>>print_num(3)

'other'

通過函數(shù)調(diào)用的結(jié)果可以看到，以上函數(shù)實(shí)現(xiàn)的功能與之前的條件控制語句實(shí)現(xiàn)的功能完全相同。

到這里，我們就實(shí)現(xiàn)了命令式條件控制語句向函數(shù)式語句的轉(zhuǎn)換。并且這個(gè)轉(zhuǎn)換的方法是通用的，所有條件控制語句都可以采用這種方式轉(zhuǎn)換為函數(shù)式語句。

替換循環(huán)控制語句

接下來我們再看循環(huán)控制語句的轉(zhuǎn)換。在Python中，循環(huán)控制是通過for和while這兩種方式實(shí)現(xiàn)的。

替換for循環(huán)

for循環(huán)語句的替換十分簡單，采用map()函數(shù)就能輕松實(shí)現(xiàn)。這主要是因?yàn)閒or語句和map()原理相同，都是對可迭代對象里面的每一個(gè)元素進(jìn)行操作，因此轉(zhuǎn)換過程比較自然。

# statement-based for loop

foreinlst:  func(e)

 

# Equivalent map()-based loop

map(func,lst)

>>>square=lambdax:x *x

>>>forxin[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循環(huán)

while循環(huán)語句的替換相比而言就復(fù)雜了許多。

下面分別是while循環(huán)語句及其對應(yīng)的函數(shù)式風(fēng)格的代碼。

# 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>:

        return1

    else:

        <suite>

    return0

 

while_FP=lambda: <condition>and(while_block()orwhile_FP())

while_FP()

這里的難點(diǎn)在于，函數(shù)式while_FP循環(huán)采用了遞歸的概念。當(dāng)為true時(shí)，進(jìn)入循環(huán)體，執(zhí)行while_block()；若為true時(shí)，返回1，while_FP()調(diào)用結(jié)束；若為false時(shí)，返回0，會(huì)繼續(xù)執(zhí)行or右側(cè)的while_FP()，從而實(shí)現(xiàn)遞歸調(diào)用；若始終為false，則會(huì)持續(xù)遞歸調(diào)用while_FP()，這就實(shí)現(xiàn)了while語句中同樣的功能。

為了對函數(shù)式的while循環(huán)有更深刻的理解，可以再看下如下示例。這個(gè)例子是在網(wǎng)上找的，實(shí)現(xiàn)的是echo功能：輸入任意非”quit”字符時(shí)，打印輸入的字符；輸入”quit”字符時(shí)，退出程序。

?  PythonFP pythonpyecho.py

IMP--1

1

IMP--2

2

IMP--abc

abc

IMP--1+1

1+1

IMP--quit

quit

?  PythonFP

如下便是分別采用過程式和函數(shù)式語句實(shí)現(xiàn)的”echo”功能。

# imperative version of "echo()"

def echo_IMP():

    while1:

        x=raw_input("IMP -- ")

        printx

        ifx=='quit':

            break

 

echo_IMP()

def monadic_print(x):

    printx

    returnx

 

# FP version of "echo()"

echo_FP=lambda:monadic_print(raw_input("FP -- "))=='quit'orecho_FP()

echo_FP()

更多示例

到此為止，我們對函數(shù)式編程總算有了點(diǎn)認(rèn)識(shí)，到達(dá)之前設(shè)定的目標(biāo)應(yīng)該是沒有問題了，看來函數(shù)式編程也并沒有想象中的那么難懂。

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

這個(gè)示例也是在網(wǎng)上找的，實(shí)現(xiàn)的是兩個(gè)列表笛卡爾積的篩選功能，找出笛卡爾積元組集合中兩個(gè)元素之積大于25的所有元組。

bigmuls=lambdaxs,ys:filter(lambda(x,y):x*y>25,combine(xs,ys))

combine=lambdaxs,ys:map(None,xs*len(ys),dupelms(ys,len(xs)))

dupelms=lambdalst,n:reduce(lambdas,t:s+t,map(lambdal,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)]

雖然這個(gè)例子中l(wèi)ambda/map/reduce/filter都是我們已經(jīng)比較熟悉了的基本單元，但是經(jīng)過組合后，理解起來還是會(huì)比較吃力。

總結(jié)

看到這里，有的同學(xué)就開玩笑說我這標(biāo)題名稱非常貼切，《Python的函數(shù)式編程–從入門到?放棄?》，因?yàn)橐院笤诠ぷ髦袘?yīng)該也不會(huì)再嘗試使用函數(shù)式編程了，^_^。

不過，我還是覺得函數(shù)式編程挺有意思的，更高級(jí)的特性后面值得再繼續(xù)學(xué)習(xí)。即使代碼不用寫成pure函數(shù)式風(fēng)格，但在某些時(shí)候局部使用lambda/map/reduce/filter也能大大簡化代碼，也是一個(gè)不錯(cuò)的選擇。數(shù)據(jù)分析師培訓(xùn)

另外，通過此次分享，再次切身體會(huì)到了教授是最好的學(xué)習(xí)方式，只有當(dāng)你真正能將一個(gè)概念講解清楚的時(shí)候，你才算是掌握了這個(gè)概念。