Servlet 過濾器具體引見

為什麼應用函數

• 最年夜化代碼的重用和最小化代碼冗余
• 流程的分化

編寫函數

>>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 object
othername() #Call func again

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

一個例子:界說和挪用

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

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

下面代碼中對函數的三次挪用都能准確運轉，由於”*“對數字和序列都有用，在Python我們從未對變量、參數或許前往值有過相似的聲明，我們可以把times用作數字的乘法或是序列的反復。

換句話說，函數times的感化決議於傳遞給它的參數，這是Python的焦點概念之一。

須要強調的是，假如我們傳入了一個不支撐函數操作的參數，Python會主動檢測出不婚配，並拋出一個異常，如許就可以削減我們編寫不用要的類型檢測代碼。

>>部分變量
一切在函數外部界說的變量默許都是部分變量，一切的部分變量都邑在函數挪用時湧現，並在函數加入時消逝。

函數設計概念

• 耦合性:關於輸出應用參數而且輸入應用return語句。
• 耦合性:只要在真正需要的情形下應用全局變量。
• 耦合性:不要轉變可變類型的參數，除非挪用者願望如許做。
• 聚合性:每個函數都應當有一個單一的、同一的目的。
• 年夜小:每個函數應當絕對較小。
• 耦合:防止直接轉變在另外一個模塊文件中的變量。
• 函數對象:屬性和注解

>>直接函數挪用
因為Python函數是對象，我們可以編寫通用的處置他們的法式。函數對象可以賦值給其他的名字、傳遞給其他函數、嵌入到數據構造、從一個函數前往給另外一個函數等等，就似乎它們是簡略的數字或字符串。

把函數賦值給其他變量:

def echo(message):
 print(message)

x = echo
x('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_varnames
func.__code__.co_argument

對象編寫者可以應用這些信息來治理函數。

>>函數屬性
函數對象不只局限於上一末節中列出的體系界說的屬性，我們也能夠向函數附加隨意率性的用戶界說的屬性:

func.count=0
func.count+=1

func.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+z
func(2,3,4)          #Return 9

f = lambda x,y,z : x + y + z
f(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,16
print(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+10
list(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.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挪用，盤算了一個列表中一切元素的累加和與積累乘積。