傳遞參數(shù)

函數(shù)傳遞參數(shù)時的一些簡要的關(guān)鍵點:

• 參數(shù)的傳遞是通過自動將對象賦值給本地變量名來實現(xiàn)的。所有的參數(shù)實際上都是通過指針進行傳遞的，作為參數(shù)被傳遞的對象從來不自動拷貝。
• 在函數(shù)內(nèi)部的參數(shù)名的賦值不會影響調(diào)用者。
• 改變函數(shù)的可變對象參數(shù)的值會對調(diào)用者有影響。

實際上，Python的參數(shù)傳遞模型和C語言的相當相似:

不可變參數(shù)”通過值”進行傳遞。像整數(shù)和字符串這樣的對象是通過對象引用而不是拷貝進行的，但是因為不論怎么樣都不可能在原處改變不可變對象，實際的效果就很像創(chuàng)建了一份拷貝。
可變對象是通過”指針”進行傳遞的。這就意味著，可變對象能夠在函數(shù)內(nèi)部進行原處修改。
>>避免可變參數(shù)的修改
避免參數(shù)的修改有很多種方式:

傳遞參數(shù)時，傳遞一個拷貝:

L = [1,2]
changer(L[:])

函數(shù)內(nèi)部進行拷貝

def changer(b):
 b=b[:]

將可變對象轉(zhuǎn)化為不可變對象

L=[1,2]
changer(tuple(L))

>>對參數(shù)輸出進行模擬
對于參數(shù)的返回值有一個小技巧:因為return能夠返回任意種類的對象，如果這些值封裝進一個元組或其他的集合類型，那么它也能夠返回多個值。

def multiple(x,y):
 x = 2
 y = [2,4]
 return x,y #Return new values in a tuple

這段代碼貌似返回了兩個值，其實只有一個:一個包含了2個元素的元組，它的括號是可以省略的。

特定的參數(shù)匹配模型

>>基礎(chǔ)知識
匹配模型的大綱:

• 位置:從左至右進行匹配。
• 關(guān)鍵字參數(shù):通過參數(shù)名進行匹配。(調(diào)用者可以定義哪一個函數(shù)接受這個值，通過在調(diào)用時使用參數(shù)的變量名，使用name=value這種語法。)
• 默認參數(shù):為沒有傳入值的參數(shù)定義參數(shù)值。
• 可變參數(shù):搜集任意多基于位置或關(guān)鍵字的參數(shù)。
• 可變參數(shù)解包:傳遞任意多的基于位置或關(guān)鍵字的參數(shù)。
• Keyword-only參數(shù):參數(shù)必須按照名稱傳遞。(只存在于Python3.0中)

>>匹配語法

在函數(shù)的調(diào)用中(表中的前4行)，簡單的通過變量名位置進行匹配，但是使用name=value的形式告訴Python依照變量名進行匹配，這些叫做關(guān)鍵字參數(shù)。在調(diào)用中使用*sequence或**dict允許我們在一個序列或字典中相應(yīng)地封裝任意多的位置相關(guān)或者關(guān)鍵字的對象，并且在將他們傳遞給函數(shù)的時候，將它們解包為分開的、單個的參數(shù)。
在函數(shù)的頭部，一個簡單的變量名時通過位置或變量名進行匹配的(取決于調(diào)用者是如何傳遞給它參數(shù)的)，但是name=value的形式定義了默認的參數(shù)值。*name的形式收集了任意的額外不匹配的參數(shù)到元組中，并且**name的形式將會手機額外的關(guān)鍵字參數(shù)到字典中。在Python3.0及其以后的版本中，跟在*name或一個單獨的*之后的、任何正式的或默認的參數(shù)名稱，都是keyword-only參數(shù)，并且必須在調(diào)用時按照關(guān)鍵字傳遞。
>>細節(jié)
在使用混合的參數(shù)模型的時候，Python將會遵循下面有關(guān)順序的法則。

在函數(shù)調(diào)用中，參數(shù)必須以此順序出現(xiàn):任何位置參數(shù)(value)，后面跟著任何關(guān)鍵字參數(shù)(name=value)和*sequence形式的組合，后面跟著**dict形式。
在函數(shù)頭部，參數(shù)必須以此順序出現(xiàn)：任何一般參數(shù)(name)，緊跟著任何默認參數(shù)(name=value)，后面是name(在Python3.0中是)形式，后面跟著任何name或name=value keyword-only參數(shù)(Python3.0中)，后面跟著**name形式。
在調(diào)用和函數(shù)頭部中，如果出現(xiàn)**arg形式的話，都必須出現(xiàn)在最后。

Python內(nèi)部是使用以下的步驟來在賦值前進行參數(shù)匹配的:

• 通過位置分配非關(guān)鍵字參數(shù)。
• 通過匹配變量名分配關(guān)鍵字參數(shù)。
• 其他額外的非關(guān)鍵字分配到*name元組中。
• 其他額外的關(guān)鍵字參數(shù)分配到**name字典中。
• 用默認值分配給在頭部未得到分配的參數(shù)。
• 在這之后，Python會進行檢測，確保每個參數(shù)只傳入了一個值。如果不是這樣的話，將會發(fā)生錯誤。當所有匹配都完成了，Python把傳遞給參數(shù)名的對象賦值給它們。

>>關(guān)鍵字參數(shù)和默認參數(shù)的實例
如果沒有使用任何特殊的匹配語法，Python默認會通過位置從左至右匹配變量名。

def f(a,b,c):
 print(a,b,c)

f(1,2,3)   #Prints 1,2,3

關(guān)鍵字參數(shù)

關(guān)鍵字參數(shù)允許通過變量名進行匹配，而不是通過位置。

f(c=3,b=2,a=1) #Prints 1,2,3

默認參數(shù)

默認參數(shù)允許創(chuàng)建函數(shù)可選的參數(shù)。如果沒有傳入值的話，在函數(shù)運行前，參數(shù)就被賦了默認值。

def f(a,b=2,c=3):
 print(a,b,c)

f(1)    #Prints 1,2,3
f(1,4)   #Prints 1,4,3
f(1,c=6)   #Prints 1,2,6

關(guān)鍵字參數(shù)和默認參數(shù)的混合

def func(spam,eggs,totast=0,ham=0):
 print((spam,eggs,totast=0,ham=0))
func(1,2)     #Ouput:(1,2,0,0)
func(1,ham=1,eggs=0)  #Ouput:(1,0,0,1)
func(spam=1,eggs=0)   #Ouput:(1,0,0,0)
func(toast=1,eggs=2,spam=3) #Ouput:(3,2,1,0)
func(1,2,3,4)    #Ouput:(1,2,3,4)

>>任意參數(shù)的實例
最后兩種匹配擴展，*和**，是讓函數(shù)支持接收任意數(shù)目的參數(shù)的。

收集參數(shù)

在函數(shù)定義中，在元組中收集不匹配的位置參數(shù)。

def f(*args):print(args)

當這個函數(shù)調(diào)用時，Python將所有位置相關(guān)的參數(shù)收集到一個新的元組中，并將這個元組賦值給變量args。因此它是一個一般的元組對象，能夠進行索引或迭代。

**特性類似，但是它只對關(guān)鍵字參數(shù)有效。將這些關(guān)鍵字參數(shù)傳遞給一個新的字典，這個字典之后將能夠通過一般的字典工具進行處理。在這種情況下，**允許將關(guān)鍵字參數(shù)轉(zhuǎn)化為字典，你能夠在之后使用鍵調(diào)用進行步進或字典迭代。

def f(a,*pargs,**kargs):print(a,pargs,kargs)

f(1,2,3,x=1,y=2)  #Prints:1 (2,3) {'x':2,'y':1}

解包參數(shù)

在最新的Python版本中，我們在調(diào)用函數(shù)時能夠使用*語法。在這種情況下，它與函數(shù)定義的意思相反。它會解包參數(shù)的集合，而不是創(chuàng)建參數(shù)的集合。

def func(a,b,c,d):print(a,b,c,d)
args=(1,2)
args+=(3,4)
func(*args)   #Prints 1,2,3,4

相似的，在函數(shù)調(diào)用時，**會以鍵/值對的形式解包一個字典，使其成為獨立的關(guān)鍵字參數(shù)。

args={'a':1,'b':2,'c':3}
args['d']=4
func(**args)   #Prints 1,2,3,4

注意：別混淆函數(shù)頭部和函數(shù)調(diào)用時*/**的語法:在頭部，它意味著收集任意多的參數(shù)，而在調(diào)用時，它解包任意數(shù)量的參數(shù)。

應(yīng)用函數(shù)通用性

if <test>:
 action,args=func1,(1,)
else:
 action,args=func2,(1,2,3)
...

action(*args)

>>Python3.0 Keyword-Only參數(shù)
Python3.0把函數(shù)頭部的排序規(guī)則通用化了，允許我們指定keyword-only參數(shù)——即必須只按照關(guān)鍵字傳遞并且不會由一個位置參數(shù)來填充的參數(shù)。

從語法上講，keyword-only參數(shù)編碼為命名的參數(shù)，出現(xiàn)在參數(shù)列表中的*args之后。所有這些參數(shù)都必須在調(diào)用中使用關(guān)鍵字語法來傳遞。

我們也可以在參數(shù)列表中使用一個*字符，來表示一個函數(shù)不會接受一個變量長度的參數(shù)列表，而是仍然期待跟在*后面的所有參數(shù)都作為關(guān)鍵字傳遞。

def kwonly(a,*,b,c):
 print(a,b,c)
kwonly(1,c=3,b=2) #Prints:1,2,3
kwonly(c=3,b=2,a=1) #Prints:1,2,3
kwonly(1,2,3)  #Error!

上述代碼中，b和c必須按照關(guān)鍵字傳遞，不允許其他額外的位置傳遞。

另外，默認函數(shù)仍然對keyword-only參數(shù)有效，所以，實際上，帶有默認值的keyword-only參數(shù)都是可選的，但是，那些沒有默認值的keyword-only參數(shù)真正地變成了函數(shù)必需的keyword-only參數(shù)。

排序規(guī)則 最后，注意keyword-only參數(shù)必須在一個單個星號后指定，而不是兩個星號——命名的參數(shù)不能出現(xiàn)在**args任意關(guān)鍵字形式的后面，并且一個**不能獨自出現(xiàn)在參數(shù)列表中。這兩種做法將產(chǎn)生錯誤。

def kwonly(a,**pargs,b,c)  #Error!
def kwonly(a,**,b,c)   #Error!

這就意味著，在一個函數(shù)的頭部，keyword-only參數(shù)必須編寫在**args任意關(guān)鍵字形式之前，且在*args任意位置形式之后。

實際上，在函數(shù)調(diào)用中，類似的排序規(guī)則也是成立的：當傳遞keyword-only參數(shù)的時候，它們必須出現(xiàn)在一個**args形式之前。keyword-only參數(shù)可以編寫在*arg之前或者之后，并且可能包含在**args中:

def f(a,*b,c=6,**d):print(a,b,c,d)

f(1,*(2,3),**dict(x=4,y=5))  #Prints:1 (2,3) 6 {'x':4,'y':5}
f(1,*(2,3),**dict(x=4,y=5),c=7) #Error!
f(1,*(2,3),c=7,**dict(x=4,y=5)) #Prints:1 (2,3) 7 {'x':4,'y':5}
f(1,c=7,*(2,3),**dict(x=4,y=5)) #Prints:1 (2,3) 7 {'x':4,'y':5}
f(1,*(2,3),**dict(x=4,y=5,c=7)) #Prints:1 (2,3) 7 {'x':4,'y':5}

Python作用域

在一個Python程序只用變量名時，Python創(chuàng)建、改變或查找變量名都是在所謂的命名空間(一個保存變量名的地方)中進行的。也就是說，在代碼中變量名被賦值的位置決定了這個變量名能被訪問到的范圍,也即決定了它存在于哪個命名空間中。

除了打包程序之外，函數(shù)還為程序增加了一個額外的命名空間層:默認情況下，一個函數(shù)所有變量名都是與函數(shù)的命名空間相關(guān)聯(lián)的。這意味著:

一個在def內(nèi)的定義的變量能夠在def內(nèi)的代碼使用,不能在函數(shù)的外部應(yīng)用這樣的變量名。
def之中的變量名與def之外的變量名并不沖突，一個在def之外被賦值的變量X與在這個def之中賦值的變量X是完全不同的變量。
>>作用域法則
在開始編寫函數(shù)之前，我們編寫的所有代碼都是位于一個模塊的頂層(也就是說，并不是嵌套在def之中)，所以我們使用的變量名要么是存在于模塊文件本身，要么就是Python內(nèi)置預(yù)先定義好的。函數(shù)定義本地作用域，而模塊定義的全局作用域。這兩個作用域有如下關(guān)系:

內(nèi)嵌的模塊是全局作用域 每個模塊都是一個全局作用域(也就是說，一個創(chuàng)建于模塊文件頂層的變量的命名空間)。對于模塊外部來說，該模塊的全局變量就成為了這個模塊對象的屬性，但是在這個模塊中能夠像簡單的變量一樣使用。
全局作用域的作用范圍僅限于單個文件 這里的全局指的是在一個文件的頂層的變量名僅對于這個文件內(nèi)部的代碼而言是全局的。在Python中是沒有基于一個單個的、無所不包的情景文件的全局作用域的。
每次對函數(shù)的調(diào)用都創(chuàng)建了一個新的本地作用域
賦值的變量名除非聲明為全局變量或非局部變量，否則均為局部變量
所有的變量名都可以歸納為本地、全局或者內(nèi)置的
>>變量名解析:LEGB原則
Python的變量名解析機制有時稱為LEGB法則，當在函數(shù)中使用未認證的變量名時，Python搜索4個作用域:

• 本地作用域(L)
• 上一層結(jié)構(gòu)中def或lambda的本地作用域(E)(其實就是函數(shù)嵌套的情況)
• 全局作用域(G)
• 最后是內(nèi)置作用域(B)

Python按順序在上面4個作用域中查找變量，并且在第一個能夠找到這個變量名的地方停下來，如果在這4個作用域中都沒找到，Python會報錯。

這里需要強調(diào)的是，上面四個作用域是函數(shù)中代碼的搜索過程，也就是說，在函數(shù)中能直接使用上一層中的變量！

s=10
def times(x,y):
 x=s
 return x*y

times(3,4) #return 40 not 12

>>內(nèi)置作用域
內(nèi)置作用域是通過一個名為builtin的標準模塊來實現(xiàn)的，但是這個變量名自身并沒有放入內(nèi)置作用域內(nèi)，所以必須導(dǎo)入這個文件才能夠使用它。在Python3.0中，可以使用以下的代碼來查看到底預(yù)定義了哪些變量:

import builtins
dir(builtins)

因此，事實上有兩種方法可以引用一個內(nèi)置函數(shù):通過LEGB法則帶來的好處，或者手動導(dǎo)入builtin模塊。其中第二種方法在一些復(fù)雜的任務(wù)里是很有用的，因為一些局部變量有可能會覆蓋內(nèi)置的變量或函數(shù)。再次強調(diào)的是，LEGB法則只使它找到的第一處變量名的地方生效!

global語句

global語句是一個命名空間的聲明，它告訴Python解釋器打算生成一個或多個全局變量，也就是說，存在于整個模塊內(nèi)部作用域(命名空間)的變量名。關(guān)于全局變量名:

全局變量是位于模塊文件內(nèi)部頂層的變量名。
全局變量如果是在函數(shù)內(nèi)部被賦值的話，必須經(jīng)過聲明。
全局變量名在函數(shù)的內(nèi)部不經(jīng)過聲明也可以被引用。
global語句包含了關(guān)鍵字global，其后跟著一個或多個由逗號分開的變量名。當在函數(shù)主題被賦值或引用時，所有列出來的變量名將被映射到整個模塊的作用域內(nèi)。 舉個例子:

X=88
def func():
 global X
 X = 99

func()
print(X) #Prints 99

作用域和嵌套函數(shù)

這部分內(nèi)容是關(guān)于LEGB查找法則中E這一層的，它包括了任意嵌套函數(shù)內(nèi)部的本地作用域。嵌套作用域有時也叫做靜態(tài)嵌套作用域。實際上，嵌套是一個語法上嵌套的作用域，它是對應(yīng)于程序源代碼的物理結(jié)構(gòu)上的嵌套結(jié)構(gòu)。

>>嵌套作用域的細節(jié)
對于一個函數(shù)來說:

一個引用(X)首先在本地(函數(shù)內(nèi))作用域查找變量名X；之后會在代碼的語法上嵌套了的函數(shù)中的本地作用域，從內(nèi)到外查找；之后查找當前的全局作用域(模塊文件)；最后在內(nèi)置作用域內(nèi)(模塊builtin)。全局聲明將會直接從全局(模塊文件)作用域進行搜索。其實就是從引用X的地方開始，一層一層網(wǎng)上搜索，直到找到的第一個X。
在默認情況下，一個賦值(X=value)創(chuàng)建或修改了變量名X的當前作用域。如果X在函數(shù)內(nèi)部聲明為全局變量，它將會創(chuàng)建或改變變量名X為整個模塊的作用域。另一方面，如果X在函數(shù)內(nèi)部聲明為nonlocal，賦值會修改最近的嵌套函數(shù)的本地作用域中的名稱X。
>>嵌套作用域舉例

X = 99
def f1():
 X = 88
 def f2():
 print(X)
 f2()
f1() #Prints 88:enclosing def local

首先需要說明的是，上面這段代碼是合法的，def是一個簡單的執(zhí)行語句，可以出現(xiàn)在任意其他語句能夠出現(xiàn)的地方，包括嵌套在另一個def之中。代碼中，f2是在f1中定義的函數(shù)，在此情況下，f2是一個臨時函數(shù)，僅在f1內(nèi)部執(zhí)行的過程中存在(并且只對f1中的代碼可見)。通過LEGB查找法則，f2內(nèi)的X自動映射到了f1的X。

值得注意的是，這個嵌套作用域查找在嵌套的函數(shù)已經(jīng)返回后也是有效的。

X = 99
def f1():
 X = 88
 def f2():
 print(X) #Remember X in enclosing def scope
 return f2 #Return f2 but don't call it

action = f1() #Make return function
action() #Call it now:Prints 88

上述代碼中，不管調(diào)用幾次action函數(shù)，返回值都是88，f2記住了f1中嵌套作用域中的X，盡管此時f1已經(jīng)不處于激活的狀態(tài)。

工廠函數(shù)

上述這些行為有時叫做閉合(closure)或者工廠函數(shù)——一個能夠記住嵌套作用域的變量值的函數(shù)，即使那個作用域也許已經(jīng)不存在了。通常來說，使用類來記錄狀態(tài)信息時更好的選擇，但是像這樣的工廠函數(shù)也提供了一種替代方案。 具體的例子:

def maker(N):
 def action(X):
 return X ** N
 return action

f=maker(2) #Pass 2 to N
f(3) #Pass 3 to X,N remembers 2: 3**2,Return 9
f(4) #return 4**2

g=maker(3) #g remembers 3,f remembers 2
g(3) #return 27
f(3) #return 9

從上面代碼中可以看到，f和g函數(shù)分別記錄了不同的N值，也就是記錄了不同的狀態(tài)，每一次對這個工廠函數(shù)進行賦值，都會得到一個狀態(tài)信息的集合，每個函數(shù)都有自己的狀態(tài)信息，由maker中的變量N保持。

作用域與帶有循環(huán)變量的默認參數(shù)相比較

在已給出的法則中有一個值得注意的特例：如果lambda或者def在函數(shù)中定義，嵌套在一個循環(huán)之中，并且嵌套的函數(shù)引用了一個上層作用域的變量，該變量被循環(huán)所改變，所有在這個循環(huán)中產(chǎn)生的函數(shù)都將會有相同的值——在最后一次循環(huán)中完成時被引用變量的值。具體的例子:

def makeActions():
 acts=[]
 for i in range(5): #Tries to remember each i
 acts.append(lambda x: i ** x) #All remember same last it
 return acts

盡管是在嘗試創(chuàng)建一個函數(shù)列表，使得每個函數(shù)擁有不同的狀態(tài)值，但是事實上，這個列表中的函數(shù)的狀態(tài)值都是一樣的，是4。因為嵌套作用域中的變量在嵌套的函數(shù)被調(diào)用時才進行查找，所以它們實際上記住的是同樣的值(在最后一次循環(huán)迭代中循環(huán)變量的值)。

為了能讓這類代碼能夠工作，必須使用默認參數(shù)把當前的值傳遞給嵌套作用域的變量。因為默認參數(shù)是在嵌套函數(shù)創(chuàng)建時評估的(而不是在其稍后調(diào)用時)，每一個函數(shù)記住了自己的變量i的值。

def makeActions():
 acts=[]
 for i in range(5): #Use default instead
 acts.append(lambda x,i=i: i ** x) #Remember current i
 return acts
{

nonlocal語句

事實上，在Python3.0中，我們也可以修改嵌套作用域變量，只要我們在一條nonlocal語句中聲明它們。使用這條語句，嵌套的def可以對嵌套函數(shù)中的名稱進行讀取和寫入訪問。nonlocal應(yīng)用于一個嵌套的函數(shù)的作用域中的一個名稱，而不是所有def之外的全局模塊作用域——它們可能只存在于一個嵌套的函數(shù)中，并且不能由一個嵌套的def中第一次賦值創(chuàng)建。

換句話說，nonlocal即允許對嵌套的函數(shù)作用域中的名稱變量賦值，并且把這樣的名稱作用域查找限制在嵌套的def。

>>nonlocal基礎(chǔ)

def func():
 nonlocal name1,name2...

這條語句允許一個嵌套函數(shù)來修改在一個語法嵌套函數(shù)的作用域中定義的一個或多個名稱。在Python 2.X中，當一個函數(shù)def嵌套在另一個函數(shù)中，嵌套的函數(shù)可以引用上一層函數(shù)中定義的各種變量，但是不能修改它們。在Python3.0中，在一條nonlocal語句中聲明嵌套的作用域，使得嵌套的函數(shù)能夠賦值，并且由此也能夠修改這樣的名稱。

除了允許修改嵌套的def中的名稱，nonlocal語句還加快了引用——就像global語句一樣，nonlocal使得對該語句中列出的名稱的查找從嵌套的def的作用域中開始，而不是從聲明函數(shù)的本地作用域開始，也就是說，nonlocal也意味著”完全略過我的本地作用域”。

實際上，當執(zhí)行到nonlocal語句的時候，nonlocal中列出的名稱必須在一個嵌套的def中提前定義過，否則，將會產(chǎn)生一個錯誤。直接效果和global很相似:global意味著名稱位于上一層的模塊中，nonlocal意味著它們位于一個上一層的def函數(shù)中。nonlocal甚至更加嚴格——作用域查找只限定在嵌套的def。也就是說，nonlocal只能出現(xiàn)在嵌套的def中，而不能在模塊的全局作用域中或def之外的內(nèi)置作用域中。

當在一個函數(shù)中使用的時候，global和nonlocal語句都在某種程度上限制了查找規(guī)則:

global使得作用域查找從嵌套的模塊的作用域開始，并且允許對那里的名稱賦值。如果名稱不存在與該模塊中，作用域查找繼續(xù)到內(nèi)置作用域，但是，對全局名稱的賦值總是在模塊作用域中創(chuàng)建或修改它們。
nonlocal限制作用域查找只是嵌套的def，要求名稱已經(jīng)存在于那里，并且允許對它們賦值。作用域查找不會繼續(xù)到全局或內(nèi)置作用域。
>>nonlocal應(yīng)用
使用nonlocal進行修改

def tester(start):
 state = start #each call gets its own state
 def nested(label):
 nonlocal state #remember state in enclosing scope
 print(label,state)
 state+=1 #Allowed to change it if onolocal
 return nested


F = tester(0) #Increments state on each call
F('spam') #Prints:spam 0
F('ham') #Prints:ham 1
F('eggs') #Prints:eggs 2

邊界情況

當執(zhí)行一條nonlocal語句時，nonlocal名稱必須已經(jīng)在一個嵌套的def作用域中賦值過，否則將會得到一個錯誤。
nonlocal限制作用域查找僅為嵌套的def，nonlocal不會在嵌套的模塊的全局作用域或所有def之外的內(nèi)置作用域中查找。

最新評論