傳遞參數

函數傳遞參數時的一些簡要的關鍵點:

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

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

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

傳遞參數時，傳遞一個拷貝:

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

函數內部進行拷貝

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

將可變對象轉化為不可變對象

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

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

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

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

特定的參數匹配模型

>>基礎知識
匹配模型的大綱:

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

>>匹配語法

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

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

Python內部是使用以下的步驟來在賦值前進行參數匹配的:

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

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

def f(a,b,c): print(a,b,c)f(1,2,3)   #Prints 1,2,3

關鍵字參數

關鍵字參數允許通過變量名進行匹配，而不是通過位置。

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

默認參數

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

def f(a,b=2,c=3): print(a,b,c)f(1)    #Prints 1,2,3f(1,4)   #Prints 1,4,3f(1,c=6)   #Prints 1,2,6

關鍵字參數和默認參數的混合

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)

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

收集參數

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

def f(*args):print(args)

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

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

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}

解包參數

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

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

相似的，在函數調用時，**會以鍵/值對的形式解包一個字典，使其成為獨立的關鍵字參數。

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

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

應用函數通用性

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

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

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

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

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

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

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

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

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

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

實際上，在函數調用中，類似的排序規則也是成立的：當傳遞keyword-only參數的時候，它們必須出現在一個**args形式之前。keyword-only參數可以編寫在*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創建、改變或查找變量名都是在所謂的命名空間(一個保存變量名的地方)中進行的。也就是說，在代碼中變量名被賦值的位置決定了這個變量名能被訪問到的范圍,也即決定了它存在于哪個命名空間中。

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

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

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

• 本地作用域(L)
• 上一層結構中def或lambda的本地作用域(E)(其實就是函數嵌套的情況)
• 全局作用域(G)
• 最后是內置作用域(B)

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

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

s=10def times(x,y): x=s return x*ytimes(3,4) #return 40 not 12

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

import builtinsdir(builtins)

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

global語句

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

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

X=88def func(): global X X = 99func()print(X) #Prints 99

作用域和嵌套函數

這部分內容是關于LEGB查找法則中E這一層的，它包括了任意嵌套函數內部的本地作用域。嵌套作用域有時也叫做靜態嵌套作用域。實際上，嵌套是一個語法上嵌套的作用域，它是對應于程序源代碼的物理結構上的嵌套結構。

>>嵌套作用域的細節
對于一個函數來說:

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

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

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

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

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

上述代碼中，不管調用幾次action函數，返回值都是88，f2記住了f1中嵌套作用域中的X，盡管此時f1已經不處于激活的狀態。

工廠函數

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

def maker(N): def action(X): return X ** N return actionf=maker(2) #Pass 2 to Nf(3) #Pass 3 to X,N remembers 2: 3**2,Return 9f(4) #return 4**2g=maker(3) #g remembers 3,f remembers 2g(3) #return 27f(3) #return 9

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

作用域與帶有循環變量的默認參數相比較

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

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

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

為了能讓這類代碼能夠工作，必須使用默認參數把當前的值傳遞給嵌套作用域的變量。因為默認參數是在嵌套函數創建時評估的(而不是在其稍后調用時)，每一個函數記住了自己的變量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可以對嵌套函數中的名稱進行讀取和寫入訪問。nonlocal應用于一個嵌套的函數的作用域中的一個名稱，而不是所有def之外的全局模塊作用域——它們可能只存在于一個嵌套的函數中，并且不能由一個嵌套的def中第一次賦值創建。

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

>>nonlocal基礎

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

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

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

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

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

global使得作用域查找從嵌套的模塊的作用域開始，并且允許對那里的名稱賦值。如果名稱不存在與該模塊中，作用域查找繼續到內置作用域，但是，對全局名稱的賦值總是在模塊作用域中創建或修改它們。
nonlocal限制作用域查找只是嵌套的def，要求名稱已經存在于那里，并且允許對它們賦值。作用域查找不會繼續到全局或內置作用域。
>>nonlocal應用
使用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 nestedF = tester(0) #Increments state on each callF('spam') #Prints:spam 0F('ham') #Prints:ham 1F('eggs') #Prints:eggs 2

邊界情況

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