函數(shù)式編程既美觀又純粹。功能代碼可以很干凈，但是也可能很凌亂。一些頑固的Python程序員不喜歡Python的功能范式。您應(yīng)該使用想要使用的工具，并使用最好的工具完成工作。在本文中，您將學習什么是函數(shù)范例以及如何在Python中使用函數(shù)編程。您還將了解列表理解和其他形式的理解。下面讓我們從功能范式先開始吧。

　　功能范式

在命令式范例中，您可以通過向計算機分配一系列任務(wù)來執(zhí)行操作，然后由計算機執(zhí)行這些任務(wù)。在執(zhí)行它們時，它可以更改狀態(tài)。

例如，假設(shè)您設(shè)置了A=5，然后再更改A。從某種意義上說，變量是變量內(nèi)部的值變化的。

在功能范式中，您不告訴計算機該做什么，而是告訴它什么東西。數(shù)的最大公約數(shù)是多少，乘積是什么1ton是，依此類推。

變量不能改變。設(shè)置變量后，它會一直保持這種狀態(tài)（請注意，在純函數(shù)式語言中，它們不稱為變量）。因此，功能在功能范式中沒有副作用。副作用是函數(shù)在函數(shù)外部進行了更改。

讓我們看一些典型的Python代碼示例：

a=3defsome_func():

globala

a=5

some_func()

print(a)

該代碼的輸出為5。在函數(shù)范式中，更改變量是一個很大的禁忌，而讓函數(shù)影響超出其范圍的事物也是一個很大的禁忌。函數(shù)唯一可以做的就是計算并返回。

現(xiàn)在您可能會想：“沒有變量，沒有副作用嗎？為什么這么好？”。好問題，討厭的陌生人讀這篇。

如果使用相同的參數(shù)兩次調(diào)用一個函數(shù)，則可以保證返回相同的結(jié)果。如果您已經(jīng)了解了數(shù)學函數(shù)，那么您將感激不盡。

我們稱之為參照透明性。由于函數(shù)沒有副作用，因此，如果我們要構(gòu)建一個用于計算事物的程序，則可以加快程序速度。如果程序知道func（2）等于3，我們可以將其存儲在表格中。當我們已經(jīng)知道答案時，這可以防止程序運行相同的功能。

通常，在函數(shù)式編程中，我們不使用循環(huán)。我們使用遞歸。遞歸是一個數(shù)學概念，它意味著“饋入自身”。使用遞歸函數(shù)時，該函數(shù)將自身稱為子函數(shù)。

　　這是Python中遞歸函數(shù)的一個很好的示例：

deffactorial_recursive(n):

#Basecase:1!=1

ifn==1:

return1

#Recursivecase:n!=n*(n-1)!

else:

returnn*factorial_recursive(n-1)

一些編程語言也很懶。這意味著他們直到最后一秒鐘才進行計算或執(zhí)行任何操作。如果我們寫一些代碼來執(zhí)行2+2，功能程序僅在需要使用結(jié)果時才進行計算。我們將很快探索Python中的惰性。

　　地圖

為了了解地圖，讓我們首先看看什么是可迭代的。可迭代是您可以迭代的任何事物。這些是列表或數(shù)組，但是Python具有許多不同的可迭代項。您甚至可以創(chuàng)建自己的對象，這些對象可以通過實現(xiàn)魔術(shù)方法進行迭代。魔術(shù)方法就像一個API，可以幫助您的對象變得更加Pythonic。

　　您需要實現(xiàn)2種魔術(shù)方法以使對象可迭代：

classCounter:

def__init__(self,low,high):

#setclassattributesinsidethemagicmethod__init__

#for“inistalise”

self.current=low

self.high=high

def__iter__(self):

#firstmagicmethodtomakethisobjectiterable

returnself

def__next__(self):

#secondmagicmethod

ifself.current>self.high:

raiseStopIteration

else:

self.current+=1

returnself.current-1

第一種魔術(shù)方法__iter__或dunderiter（雙下劃線iter）返回迭代對象，我們經(jīng)常在循環(huán)開始時使用它。接下來是__next__，返回下一個對象。

讓我們進入快速終端會話并檢查一下：

forcinCounter(3,8):

print(c)

這將打印：

3、4、5、6、7、8

在Python中，迭代器是僅包含一個__iter__魔術(shù)方法。這意味著我們可以訪問對象中的位置，但是不能遍歷對象。一些對象將具有魔術(shù)方法__next__而不是__iter__魔術(shù)方法。

現(xiàn)在我們知道了一個可迭代的對象，讓我們回到map函數(shù)。map函數(shù)使我們可以將函數(shù)應(yīng)用于可迭代的每個項目。我們希望對列表中的每個項目都應(yīng)用一個函數(shù)，但要知道大多數(shù)迭代器都有可能使用該函數(shù)。Map需要2個輸入，即要應(yīng)用的功能和可迭代的對象。

map(function,iterable)

假設(shè)我們有一個數(shù)字列表，如下所示：[1,2,3,4,5]

我們想要對每個數(shù)字取平方，可以編寫如下代碼：

x=[1,2,3,4,5]

defsquare(num):

returnnum*num

print(list(map(square,x)))

功能性Python很懶。如果我們不包括list()該函數(shù)將存儲可迭代對象的定義，而不是列表本身。我們需要告訴Python“將其轉(zhuǎn)換為列表”以供我們使用。

在Python中突然從非延遲評估轉(zhuǎn)到延遲評估很奇怪。如果您在功能性思維方式上的思考多于命令式思維，則您會習慣于它。

現(xiàn)在寫一個普通的函數(shù)就像square(num)但是看起來不對。我們只需要在地圖中使用一次就定義一個整體功能？好了，我們可以使用lambda（匿名）函數(shù)在map中定義一個函數(shù)。

　　Lambda表達式

Lambda表達式是單行函數(shù)。以這個lambda表達式為例，該表達式平方一個給定的數(shù)字：

square=lambdax:x*x

現(xiàn)在運行此命令：

>>>square(3)

　　9

我聽到你了“布蘭登，爭論在哪里？這到底是什么？看起來不像功能嗎？”

好吧，這很混亂，但是可以解釋。我們正在給變量賦值square。

　　這部分：

lambdax:

告訴Python這是一個lambda函數(shù)，輸入名為x。冒號之后的所有內(nèi)容都是我們對輸入所做的事情，并且返回的結(jié)果是什么。

要將平方程序簡化為一行，我們可以執(zhí)行以下操作：

x=[1,2,3,4,5]

print(list(map(lambdanum:num*num,x)))

在lambda表達式中，所有參數(shù)都在左側(cè)，而您要使用它們的內(nèi)容在右側(cè)。它有點混亂，沒有人可以否認。編寫只有其他函數(shù)式程序員才能閱讀的代碼，這是有一定樂趣的。另外，將一項功能轉(zhuǎn)換為單行代碼也很酷。

　　減少

Reduce是一種將可迭代變成一件事的功能。通常，我們將對列表執(zhí)行計算以將其減少到一個數(shù)字。

減少看起來像這樣：

reduce(function,list)

我們可以（并且經(jīng)常會）使用lambda表達式作為函數(shù)。

列表的乘積是將每個數(shù)字相乘。

　　要對此編程：

product=1

x=[1,2,3,4]

fornuminx:

product=product*num

但是使用reduce可以編寫：

fromfunctoolsimportreduce

product=reduce((lambdax,y:x*y),[1,2,3,4])

要獲得相同的產(chǎn)品。代碼更短，并且具有函數(shù)式編程知識，因此更加整潔。

　　過濾

filter函數(shù)接受一個可迭代的對象，并過濾掉該可迭代對象中所有不需要的東西。

過濾器具有一個功能和一個列表。它將函數(shù)應(yīng)用于列表中的每個項目，如果該函數(shù)返回True，則不執(zhí)行任何操作。

如果返回False，則將其從列表中刪除。

語法如下：

filter(function,list)

讓我們看一個小例子，沒有過濾器，我們將編寫：

x=range(-5,5)

new_list=[]

fornuminx:

ifnum<0:

new_list.append(num)

使用filter，它將變?yōu)椋?/p>

x=range(-5,5)

all_less_than_zero=list(filter(lambdanum:num<0,x))

　　高階函數(shù)

高階函數(shù)可以將函數(shù)用作參數(shù)并返回函數(shù)。

一個非常簡單的示例如下所示：

defsummation(nums):

returnsum(nums)

defaction(func,numbers):

returnfunc(numbers)

print(action(summation,[1,2,3]))

#Outputis6

或第二個定義的簡單示例，returnfunctions，是：

defrtnBrandon():

return“brandon”

defrtnJohn():

return“john”

defrtnPerson():

age=int(input(“What’syourage?”))

ifage==21:

returnrtnBrandon()

else:

returnrtnJohn()

您之前知道我怎么說純函數(shù)式編程語言沒有變量嗎？

好吧，高階函數(shù)使此操作更容易。

如果我們要做的只是通過長函數(shù)通道傳遞數(shù)據(jù)，則無需在任何地方存儲變量。

Python中的所有函數(shù)都是一流的對象。

我們將一流對象定義為具有以下一個或多個功能：

·在運行時創(chuàng)建

·分配給數(shù)據(jù)結(jié)構(gòu)中的變量或元素

·作為參數(shù)傳遞給函數(shù)

·作為函數(shù)的結(jié)果返回

因此，Python中的所有函數(shù)都是一流的，可以用作高階函數(shù)。

　　部分申請

部分應(yīng)用程序（也稱為閉包）很奇怪，但是很酷。我們可以在不提供所需所有參數(shù)的情況下調(diào)用函數(shù)。我們來看一個例子。

我們想要創(chuàng)建一個函數(shù)，該函數(shù)接受2個參數(shù)（一個底數(shù)和一個指數(shù)），然后將base返回給指數(shù)的冪，如下所示：

defpower(base,exponent):

returnbase**exponent

現(xiàn)在我們想要一個專用的平方函數(shù)，使用冪函數(shù)計算一個數(shù)字的平方：

defsquare(base):

returnpower(base,2)

這行得通，但是如果我們想要多維數(shù)據(jù)集函數(shù)怎么辦?還是4的冪的函數(shù)?我們可以永遠繼續(xù)寫它們嗎?好吧，我們可以。

但是程序員很懶。如果我們重復(fù)做同樣的事情，則表明有一種更快的方法可以加快處理速度，這將使我們不再重復(fù)處理。我們可以在這里使用部分應(yīng)用程序。

讓我們看一下使用部分應(yīng)用程序的平方函數(shù)的示例：

fromfunctoolsimportpartial

square=partial(power,exponent=2)

print(square(2))

#outputis4

那不是很酷!通過告訴Python第二個參數(shù)是什么，我們可以僅使用1個參數(shù)來調(diào)用需要2個參數(shù)的函數(shù)。

我們還可以使用循環(huán)來生成冪函數(shù)，該冪函數(shù)從立方到1000的冪一直有效。

fromfunctoolsimportpartial

powers=[]

forxinrange(2,1001):

powers.append(partial(power,exponent=x))

print(powers[0](3))

#outputis9

函數(shù)式編程不是Pythonic

您可能已經(jīng)注意到，但是我們在函數(shù)式編程中要做的許多事情都圍繞列表進行。除了reduce函數(shù)和部分應(yīng)用程序之外，您看到的所有函數(shù)都會生成列表。

如果將“importthis”寫入“PythonIDLE”會話，則會得到：

>>>importthis

TheZenofPython,byTimPeters

Beautifulisbetterthanugly.

Explicitisbetterthanimplicit.

Simpleisbetterthancomplex.

Complexisbetterthancomplicated.

Flatisbetterthannested.

Sparseisbetterthandense.

Readabilitycounts.

Specialcasesaren’tspecialenoughtobreaktherules.

Althoughpracticalitybeatspurity.

Errorsshouldneverpasssilently.

Unlessexplicitlysilenced.

Inthefaceofambiguity,refusethetemptationtoguess.

Thereshouldbeone--andpreferablyonlyone--obviouswaytodoit.

Althoughthatwaymaynotbeobviousatfirstunlessyou’reDutch.

Nowisbetterthannever.

Althoughneverisoftenbetterthan*right*now.

Iftheimplementationishardtoexplain,it’sabadidea.

Iftheimplementationiseasytoexplain,itmaybeagoodidea.

Namespacesareonehonkinggreatidea--let’sdomoreofthose!

這就是Python的禪宗。這是一首關(guān)于Pythonic意味著什么的詩。

我們要在這里涉及的部分是：

Thereshouldbeone?—?andpreferablyonlyone?—?obviouswaytodoit.

在Python中，地圖和過濾器可以做與列表理解相同的事情。這打破了PythonZen的一條規(guī)則，因此函數(shù)編程的這些部分是“pythonic”。

另一個話題是Lambda。在Python中，lambda函數(shù)是常規(guī)函數(shù)。Lambda是語法糖。

兩者是等效的：

foo=lambdaa:2

deffoo(a):

return2

常規(guī)函數(shù)可以執(zhí)行l(wèi)ambda函數(shù)可以做的所有事情，但是反之則不行。Lambda函數(shù)無法執(zhí)行常規(guī)函數(shù)可以執(zhí)行的所有操作。

這是關(guān)于為什么函數(shù)式編程不能很好地適合整個Python生態(tài)系統(tǒng)的簡短爭論。

您可能已經(jīng)注意到我之前提到過列表理解，現(xiàn)在我們將討論它們。

　　清單理解

之前，我提到過您可以使用map或filter進行的任何操作，也可以使用列表理解的方法。這是我們將了解它們的部分。列表理解是一種在Python中生成列表的方法。

語法為：

[functionforiteminiterable]

因此，讓我們對列表中的每個數(shù)字取平方，例如：

print([x*xforxin[1,2,3,4]])

好的，所以我們可以看到如何將函數(shù)應(yīng)用于列表中的每個項目。我們?nèi)绾螒?yīng)用過濾器?

好吧，請看一下前面的代碼：

x=range(-5,5)

all_less_than_zero=list(filter(lambdanum:num<0,x))

print(all_less_than_zero)

我們可以這樣將其轉(zhuǎn)換為列表理解：

x=range(-5,5)

all_less_than_zero=[numfornuminxifnum<0]

列表推導支持if這樣的語句。您不再需要將一百萬個函數(shù)應(yīng)用于某些對象即可獲得所需的東西。實際上，如果我們要嘗試某種列表機會，那么使用列表理解將使它看起來更干凈，更容易。

如果我們想對列表中0以下的每個數(shù)字求平方怎么辦？

好吧，使用lambda，map和filter，我們將編寫：

x=range(-5,5)

all_less_than_zero=list(map(lambdanum:num*num,list(filter(lambdanum:num<0,x))))

這是漫長而復(fù)雜的。通過列表理解，它是：

x=range(-5,5)

all_less_than_zero=[num*numfornuminxifnum<0]

列表理解僅對列表有益。映射和過濾器在任何可迭代的地方都可以工作，那又是怎么回事?我們可以對遇到的任何可迭代對象使用任何理解。

　　其他理解

我們可以使用理解來生成任何可迭代的。從Python2.7開始，我們甚至可以生成一個字典(hashmap)。

#Takenfrompage70chapter3ofFluentPythonbyLucianoRamalho

DIAL_CODES=[(86,‘China’),

(91,‘India’),

(1,‘UnitedStates’),

(62,‘Indonesia’),

(55,‘Brazil’),

(92,‘Pakistan’),

(880,‘Bangladesh’),

(234,‘Nigeria’),

(7,‘Russia’),

(81,‘Japan’),

]

>>>country_code={country:codeforcode,countryinDIAL_CODES}

>>>country_code

{’Brazil’:55,‘Indonesia’:62,‘Pakistan’:92,‘Russia’:7,‘China’:86,‘UnitedStates’:1,‘Japan’:81,‘India’:91,‘Nigeria’:234,‘Bangladesh’:880}

>>>{code:country.upper()forcountry,codeincountry_code.items()ifcode<66}

{1:‘UNITEDSTATES’,7:‘RUSSIA’,62:‘INDONESIA’,55:‘BRAZIL’}

如果是可迭代的，我們可以生成它。讓我們看一下集合的最后一個例子。

TL；DR為：

·集是元素列表，該列表中沒有元素重復(fù)兩次

·套裝順序無所謂

#takenfrompage87,chapter3ofFluentPythonbyLucianoRamalho

>>>fromunicodedataimportname

>>>{chr(i)foriinrange(32,256)if‘SIGN’inname(chr(i),‘’)}

{’×’,‘￥’,‘°’,‘￡’,‘?’,‘?’,‘%’,‘μ’,‘>‘,‘¤’,‘±’,‘?’,‘§’,‘<’,‘=’,‘?’,‘$’,‘÷’,‘￠’,‘+’}

您可能會注意到，集合具有與字典相同的花括號。Python很聰明。它會根據(jù)您是否為字典提供額外的價值而知道您是在編寫字典理解還是集合理解。

上述就是關(guān)于Python語法功能有哪些的全部內(nèi)容，想了解更多關(guān)于Python的信息，請繼續(xù)關(guān)注中培偉業(yè)。