為何使用函數

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

編寫函數

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

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

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

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

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

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

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

othername=func #Assign function objectothername() #Call func againfunc() #call objectfunc.attr=value #attach attribute

一個例子:定義和調用

def times(x,y):  return x*ytimes(2,4) #return 8times(3.12,4) #return 12.56times('Ni',4) #return 'NiNiNi'

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

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

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

>>局部變量
所有在函數內部定義的變量默認都是局部變量，所有的局部變量都會在函數調用時出現，并在函數退出時消失。

函數設計概念

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

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

把函數賦值給其他變量:

def echo(message): print(message)x = echox('Indirect call!')  #Prints:Indirect call!

傳遞給其他函數:

def indirect(func,arg):  func(arg)indirect(echo,'Argument call')  #Prints:Argument call

把函數對象填入到數據結構中:

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

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

>>函數內省
由于函數是對象，我們可以用用常規的對象工具來處理函數。

func.__name__dir(func)

內省工具允許我們探索實現細節，例如函數已經附加了代碼對象，代碼對象提供了函數的本地變量和參數等方面的細節：

dir(func.__code__)func.__code__.co_varnamesfunc.__code__.co_argument

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

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

func.count=0func.count+=1func.handles='Button-Press'

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

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

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

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

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

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

注意點

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

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

>>lambda表達式
lambda的一般形式是關鍵字lambda，之后是一個或多個參數，緊跟的是一個冒號，之后是一個表達式：

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

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

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

def func(x,y,z):return x+y+zfunc(2,3,4)          #Return 9f = lambda x,y,z : x + y + zf(2,3,4)           #Return 9

默認參數也能在lambda中使用

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

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

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

lambda通常用來編寫跳轉表:

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

實際上，我們可以用Python中的字典或者其他數據結構來構建更多種類的行為表:

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

在序列中映射函數:map

map函數會對一個序列對象中的每個元素應用被傳入的函數，并且返回一個包含了所有函數調用結果的一個列表。

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

由于map期待傳入一個函數，它恰好是lambda最常出現的地方之一。

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

函數式編程工具:filter和reduce

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

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

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

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

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

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