為何使用函數(shù)

• 最大化代碼的重用和最小化代碼冗余
• 流程的分解

編寫函數(shù)

>>def語句
在Python中創(chuàng)建一個函數(shù)是通過def關(guān)鍵字進行的，def語句將創(chuàng)建一個函數(shù)對象并將其賦值給一個變量名。def語句一般的格式如下所示:

def <name>(arg1,arg2,... argN):
  <statements>

通常情況下，函數(shù)體中會有一個return語句，可以出現(xiàn)在函數(shù)體的任何位置，它表示函數(shù)調(diào)用的結(jié)束，并將結(jié)果返回至函數(shù)調(diào)用處。但是return語句是可選的，并不是必須的。從技術(shù)角度上說，一個沒有返回值的函數(shù)自動返回了none對象，但是這個值可以被忽略掉。

>>def語句是實時執(zhí)行的
Python的def語句實際上是一個可執(zhí)行的語句:當(dāng)它運行的時候，它創(chuàng)建一個新的函數(shù)對象并將其賦值給一個變量名。(請記住，Python中所有的語句都是實時運行的，沒有對像獨立編譯時間這樣的流程)因為它是一個語句，它可以出現(xiàn)在任一語句可以出現(xiàn)的地方——甚至是嵌套在其他語句中。

if test:
  def func():
    ...
else:
  def func():
    ...
...
func()

它在運行時簡單地給一個變量名進行賦值。與C語言這樣的編譯語言不同，Python函數(shù)在程序運行之前并不需要全部定義，更確切地說，def在運行時才評估，而在def之中的代碼在函數(shù)調(diào)用時才會評估。

就像Python中其他語句一樣，函數(shù)僅僅是對象，在程序執(zhí)行時它清除地記錄在了內(nèi)存之中。實際上，除了調(diào)用之外，函數(shù)允許任意的屬性附加到記錄信息以供隨后使用:

othername=func #Assign function object
othername() #Call func again

func() #call object
func.attr=value #attach attribute

一個例子:定義和調(diào)用

def times(x,y):
  return x*y

times(2,4) #return 8
times(3.12,4) #return 12.56
times('Ni',4) #return 'NiNiNi'

上面代碼中對函數(shù)的三次調(diào)用都能正確運行，因為”*“對數(shù)字和序列都有效，在Python我們從未對變量、參數(shù)或者返回值有過類似的聲明，我們可以把times用作數(shù)字的乘法或是序列的重復(fù)。

換句話說，函數(shù)times的作用決定于傳遞給它的參數(shù)，這是Python的核心概念之一。

需要強調(diào)的是，如果我們傳入了一個不支持函數(shù)操作的參數(shù)，Python會自動檢測出不匹配，并拋出一個異常，這樣就能減少我們編寫不必要的類型檢測代碼。

>>局部變量
所有在函數(shù)內(nèi)部定義的變量默認都是局部變量，所有的局部變量都會在函數(shù)調(diào)用時出現(xiàn)，并在函數(shù)退出時消失。

函數(shù)設(shè)計概念

• 耦合性:對于輸入使用參數(shù)并且輸出使用return語句。
• 耦合性:只有在真正必要的情況下使用全局變量。
• 耦合性:不要改變可變類型的參數(shù)，除非調(diào)用者希望這樣做。
• 聚合性:每一個函數(shù)都應(yīng)該有一個單一的、統(tǒng)一的目標。
• 大小:每一個函數(shù)應(yīng)該相對較小。
• 耦合:避免直接改變在另一個模塊文件中的變量。
• 函數(shù)對象:屬性和注解

>>間接函數(shù)調(diào)用
由于Python函數(shù)是對象，我們可以編寫通用的處理他們的程序。函數(shù)對象可以賦值給其他的名字、傳遞給其他函數(shù)、嵌入到數(shù)據(jù)結(jié)構(gòu)、從一個函數(shù)返回給另一個函數(shù)等等，就好像它們是簡單的數(shù)字或字符串。

把函數(shù)賦值給其他變量:

def echo(message):
 print(message)

x = echo
x('Indirect call!')  #Prints:Indirect call!

傳遞給其他函數(shù):

def indirect(func,arg):
  func(arg)

indirect(echo,'Argument call')  #Prints:Argument call

把函數(shù)對象填入到數(shù)據(jù)結(jié)構(gòu)中:

schedule=[(echo,'Spam!'),(echo,'Ham!')]
for (func,arg) in schedule:
  func(arg)

從上述的代碼中可以看到，Python是非常靈活的！

>>函數(shù)內(nèi)省
由于函數(shù)是對象，我們可以用用常規(guī)的對象工具來處理函數(shù)。

func.__name__
dir(func)

內(nèi)省工具允許我們探索實現(xiàn)細節(jié)，例如函數(shù)已經(jīng)附加了代碼對象，代碼對象提供了函數(shù)的本地變量和參數(shù)等方面的細節(jié)：

dir(func.__code__)
func.__code__.co_varnames
func.__code__.co_argument

工具編寫者可以利用這些信息來管理函數(shù)。

>>函數(shù)屬性
函數(shù)對象不僅局限于上一小節(jié)中列出的系統(tǒng)定義的屬性，我們也可以向函數(shù)附加任意的用戶定義的屬性:

func.count=0
func.count+=1

func.handles='Button-Press'

這樣的屬性可以用來直接把狀態(tài)信息附加到函數(shù)對象，而不必使用全局、非本地和類等其他技術(shù)。和非本地不同，這樣的屬性信息可以在函數(shù)自身的任何地方訪問。這種變量的名稱對于一個函數(shù)來說是本地的，但是，其值在函數(shù)退出后仍然保留。屬性與對象相關(guān)而不是與作用域相關(guān)，但直接效果是類似的。

>>Python3.0中的函數(shù)注解
在Python3.0也可以給函數(shù)對象附加注解信息——與函數(shù)的參數(shù)相關(guān)的任意的用戶定義的數(shù)據(jù)。Python為聲明注解提供了特殊的語法，但是，它自身不做任何事情；注解完全是可選的，并且，出現(xiàn)的時候只是直接附加到函數(shù)對象的__annotations__屬性以供其他用戶使用。

從語法上講，函數(shù)注解編寫在def頭部行，對于參數(shù)，它們出現(xiàn)在緊隨參數(shù)名之后的冒號之后；對于返回值，它們編寫于緊跟在參數(shù)列表之后的一個->之后。

def func(a:'spam',b:(1,10),c:float) -> int:
  return a+b+c

注解和沒注解過的函數(shù)在功能和使用上完全一樣，只不過，注解過的函數(shù)，Python會將它們的注解的數(shù)據(jù)收集到字典中并將它們附加到函數(shù)對象自身。參數(shù)名變成鍵，如果編寫了返回值注解的話，它存儲在鍵return下，而注解的值則是賦給了注解表達式的結(jié)果:

func.__annotations__
 #Prints:{'a':'spam','c':<class 'float'>,'b':(1,10),'return':<class 'int'>}

注意點

如果編寫了注解的話，仍然可以對參數(shù)使用默認值，例如:a:'spam'=4 意味著參數(shù)a的默認值是4，并且用字符串'spam'注解它。
在函數(shù)頭部的各部分之間使用空格是可選的。
注解只在def語句中有效。
匿名函數(shù):lambda

除了def語句之外，Python還提供了一種生成函數(shù)對象的表達式形式。由于它與LISP語言中的一個工具很相似，所以稱為lambda。就像def一樣，這個表達式創(chuàng)建了一個之后能夠調(diào)用的函數(shù)，但是它返回了一個函數(shù)而不是將這個函數(shù)賦值給一個變量名。這也就是lambda有時叫做匿名函數(shù)的原因。實際上，它們常常以一個行內(nèi)函數(shù)定義的形式使用，或者用作推遲執(zhí)行一些代碼。

>>lambda表達式
lambda的一般形式是關(guān)鍵字lambda，之后是一個或多個參數(shù)，緊跟的是一個冒號，之后是一個表達式：

lambda argument1,argument2,...argumentN:expression using arguments

由lambda表達式所返回的函數(shù)對象與由def創(chuàng)建并賦值后的函數(shù)對象工作起來是完全一樣的，但是lambda有一些不同之處讓其在扮演特定的角色時很有用。

lambda是一個表達式，而不是一個語句。
lambda的主體是一個單個的表達式，而不是一個代碼塊。
一下兩段代碼生成了同樣功能的函數(shù):

def func(x,y,z):return x+y+z
func(2,3,4)          #Return 9

f = lambda x,y,z : x + y + z
f(2,3,4)           #Return 9

默認參數(shù)也能在lambda中使用

x=(lambda a="fee",b="fie",c="foe": a+b+c)
x("wee")           #Prints:'weefiefoe'

在lambda主體中的代碼像在def內(nèi)的代碼一樣都遵循相同的作用域查找法則。

>>為什么要使用lambda
通常來說，lambda起到了一種函數(shù)速寫的作用，允許在使用的代碼內(nèi)嵌入一個函數(shù)的定義。它們總是可選的，因為總是能夠用def來代替。

lambda通常用來編寫跳轉(zhuǎn)表:

L=[lambda x: x ** 2,
  lambda x: x ** 3,
  lambda x: x ** 4]

for f in L:
 print(f(2))      #Prints:4,8,16
print(L[0](3))      #Prints:9

實際上，我們可以用Python中的字典或者其他數(shù)據(jù)結(jié)構(gòu)來構(gòu)建更多種類的行為表:

key='got'
{'already':(lambda: 2+2),
 'got':(lambda: 2*4),
 'one':(lambda: 2 ** 6)}[key]()     #Prints:8

這樣編寫代碼可以使字典成為更加通用的多路分支工具。

最后需要注意的是，lambda也是可以嵌套的

((lambda x:(lambda y: x+y))(99))(4)   #Prints:103

在序列中映射函數(shù):map

map函數(shù)會對一個序列對象中的每個元素應(yīng)用被傳入的函數(shù)，并且返回一個包含了所有函數(shù)調(diào)用結(jié)果的一個列表。

counters=[1,2,3,4]
def inc(x):return x+10
list(map(inc,counters))     #[11,12,13,14]

由于map期待傳入一個函數(shù)，它恰好是lambda最常出現(xiàn)的地方之一。

list(map((lambda x: x+10),counters)) #[11,12,13,14]

函數(shù)式編程工具:filter和reduce

在Python內(nèi)置函數(shù)中，map函數(shù)是用來進行函數(shù)式編程的這類工具中最簡單的內(nèi)置函數(shù)代表。所謂的函數(shù)式編程就是對序列應(yīng)用一些函數(shù)的工具。例如過濾出一些元素(filter)，以及對每對元素都應(yīng)用函數(shù)并運行到最后的結(jié)果(reduce)。

list(filter((lambda x: x>0),range(-5,5)))  #[1,2,3,4]

序列中的元素若其返回值是真的話，將會被加入到結(jié)果列表中。

reduce接受一個迭代器來處理，但是，它自身不是一個迭代器，它返回一個單個的結(jié)果。

from functools import reduce  #Import in 3.0,not in 2.6
reduce((lambda x,y: x+y),[1,2,3,4]) #Return:10
reduce((lambda x,y: x*y),[1,2,3,4]) #Return:24

上面兩個reduce調(diào)用，計算了一個列表中所有元素的累加和與累積乘積。

最新評論