python函數的參數細節

按"指針"傳遞

python中變量賦值、參數傳遞都是經過"指針"拷貝的方式進行的。除了按"指針"拷貝，還有一種按值拷貝的方式，關於按值、按指針拷貝的細節，參見按值傳遞 vs. 按指針傳遞。

因此在python中，變量賦值、參數傳遞，都只是拷貝了源數據的一個地址，而不會拷貝內存中完整的數據對象副本。因此，若是在函數內部修改變量指向的數據對象，會影響函數外部的數據。

例如：

def f(x):
    print(x+3)
a=4
f(a)

在將a賦值給本地變量x的時候，只是拷貝了a目前保存的地址給x，使得x也保存了內存中數據對象4的地址。

若是傳遞的數據對象是可變數據對象(例如列表)，那麼在函數內部修改它，會影響函數外部的原始數據對象：

L1=[11,22,33,44]
def f(x):
    x[0] += 1

f(L1)
print(L1)   # 輸出：[12, 22, 33, 44]

顯然，在函數內部修改x[0]的值，函數外部原始的L1也發生了改變。由於L1賦值給x的時候，只是拷貝了一份L1所指向列表的地址給x，使得x也指向這個列表。

爲了不這種狀況，能夠新建立一份列表的副本，而後傳遞給函數參數。

L1=[11,22,33,44]
def f(x):
    x[0] += 1

f(L1[:])
print(L1)   # 輸出：[11, 22, 33, 44]

上面傳遞給函數參數x的是L1[:]，它會在內存中建立一個新的列表副本，因此x指向的是這個新的副本列表，修改它不會影響原始的列表L1。

函數參數

Python的函數對參數和返回值方面很是寬鬆，參數變量能夠是任意數據類型，返回值也同樣，只需使用變量名代替它們便可。

例如，下面的參數x能夠是任意類型的結構，能夠是數值、字符串、列表、字典等等類型。返回值語句return同理。

def f(x):
    print(x)
    return x

f(2)
f("haha")

實際上，上面調用函數時是按照參數位置進行傳參對本地變量x進行賦值的。除此以外，還能夠指定爲key=value的方式進行傳參。例如：

f(x=2)
f(x="haha")

按位置傳參

若是是多個參數，則按從左到右的順序進行參數變量的賦值：

def f(x,y,z):
    print(x)
    print(y)
    print(z)

f(2,3,4)

調用f(2,3,4)的時候，會按照從左向右的位置方式對本地變量x、y、z賦值：x=2,y=3,z=4。

按關鍵字key/value方式傳值

python還支持key=value的方式設置函數調用時的參數，使用key=value的方式賦值時，順序不重要。這種函數調用時的傳值方式稱爲"關鍵字傳值"。

例如：

def f(x,y,z):
    print(x)
    print(y)
    print(z)
    
f(x=3,y="haha",z=4)

也能夠打亂順序：

f(x=3,z=4,y="haha")

還能夠將key=value和位置傳參的方式進行混合：

f(3,"haha",z=4)

但混合按位置傳參方式的時候，位置參數必須在其它傳參方式的前面，不只此處結合key=value時如此，後文中位置參數結合其它方式傳參也都如此：位置參數必須在最前面。

例如，下面的傳參方式是錯的：

f(z=4,3,"haha")

參數默認值

在def或lambda聲明函數的時候，能夠經過var=default的方式指定參數的默認值。

例如：

def f(x=3):
    print(x)

f(4)
f("haha")
f()

上面的f(4)和f("haha")都對函數f()的本地變量x進行了賦值。可是最後一個調用語句f()未賦值，而是使用參數的默認值3。

設置參數默認值時，若是函數有多個參數，則帶默認值參數後面必須放在最後面。例如：

# 正確
def f(x,y,z=4)
def f(x,y=1,z=4)

# 錯誤
def f(x,y=4,z)

只要爲參數設置了默認值，那麼調用函數的時候，這個參數就是可選的，無關緊要的，若是沒有，則採用默認值。

def f(x,y=2,z=4):
    print(x)
    print(y)
    print(z)

# 不採用任何默認值
f(2,3,4)

# 採用z的默認值
f(2,3)

# 採用y的默認值
# 此時z必須按key=value的方式傳值
f(2,z=5)

# y、z都採用默認值
f(2)

變長參數：*

對於任意長度的參數，能夠在def聲明的函數中使用*將各位置參數收集到一個元組中。例如：

def f(*args):
    print(args)

f(1,2,3,4)

上面調用f(1,2,3,4)的時候，將全部參數都收集到了一個名爲args的元組中。因此上面的函數將輸出：

(1, 2, 3, 4)

既然是元組，就能夠對參數進行迭代遍歷：

def f(*args):
    for arg in args:
        print(arg)

f(1,2,3,4)

必須注意，*是按位置收集參數的。

def f(x,y,*args):
    print(x)
    print(y)
    for arg in args:
        print(arg)

f(1,2,3,4)

按照從左向右的傳參規則，首先將1賦值給x，將2賦值給y，而後將剩餘全部的位置參數收集到args元組中，因此args=(3,4)。

若是*後面還有參數，則調用函數的時候，後面的參數必須使用key=value的方式傳遞，不然會收集到元組中，從而致使參數缺乏的問題：

def f(x,*args,y):
    print(x)
    print(y)
    for arg in args:
        print(arg)

# 正確
f(1,3,4,y=2)

# 錯誤
f(1,2,3,4)

上面調用f(1,3,4,y=2)的時候，會按照位置參數對x賦值爲1，而後將全部位置參數收集到元組args中，由於y=2是非位置參數傳值方式，因此args=(3,4)。

若是爲上面的y設置默認值：

def f(x,*args,y=2)

那麼f(1,2,3,4)會將(2,3,4)都收集到元組args中，而後y採用默認值2。

變長參數：**

除了能夠使用*將位置參數收集到元組中，還能夠使用**將key=value格式的參數收集到字典中。

例如：

def f(x,**args):
    print(x)
    print(args)

f(1,a=11,b=22,c=33,d=44)

上面首先按位置傳參的方式賦值x=1，而後將剩餘的全部key=value參數收集到名爲args的字典中。因此，args字典的內容爲：

{'a': 11, 'b': 22, 'c': 33, 'd': 44}

既然是將參數收集到字典中，就能夠使用字典類的工具操做這個字典。例如，遍歷字典。

在**的後面不能出現任何其它類型的參數。例如，下面的都是錯誤的def定義方式：

def f(x,**args,y)
def f(x,**args,y=3)
def f(x,**args,*t)

只能將位置參數或者*的收集放在**的前面。

def f(x,y,**args)
def f(x,*args1,**args2)

函數調用時的*和**

除了在def定義函數時，參數中能夠使用*或**收集參數，在函數調用的時候也能夠使用*或**分別解包元組(列表或其它對象)、字典。必定要注意區分函數定義和函數調用時的*、**，它們的用法是不通用的。

例如，解包元組：

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

T=(1,2,3,4)
f(*T)

*除了能夠解包元組，還能夠解包其它可迭代對象，例如列表。甚至是字典也能解包，只不過*解包的字典獲得的是key組成的參數列表，和value無關：

D=dict(a=11,b=22,c=33,d=44)
f(*D)

# 輸出：
a
b
c
d

而**解包的字典則是key=value組成的參數列表。如下是函數調用時使用**進行解包，字典D中的key名稱必須和def中定義的參數名稱相同：

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

D=dict(a=11,b=22,c=33,d=44)
f(**D)

# 輸出：
11
22
33
44

在函數調用時，能夠混合位置參數、關鍵字參數、*解包參數、**解包參數。用法很是的靈活：

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

f(*(1,2),**{'d':4,'c':3})

f(1,*(2,3),**{'d':4})

f(1,c=3,*(2,),**{'d':4})

f(1,*(2,3),d=4)

f(1,*(2,),c=3,**{'d':4})

上面調用函數時的效果都等同於f(1,2,3,4)。

keyword-only參數形式

keyword-only的參數傳值方式表示def中若是使用了*，那麼在調用函數時，它後面的參數必須只能使用關鍵字傳值。其實在前面的內容中已經出現過幾回與之相關的說明。

另外注意，*纔是keyword-only開關，**不是，雖然**也有本身的一些語法限制：任意類型的參數定義都必須在**以前，包括keyword-only類型的參數。這個前面已經解釋過了。

例如：

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

按照keyword-only的規則，被*b收集的位置參數不包括c，這個c必須只能使用關鍵字的方式傳值，不然就被看成位置參數被收集到元組b中。

# 正確
f(1,2,3,c=4)

# 錯誤
f(1,2,3,4)

# 錯誤
f(1,c=4,2,3)

其中最後一個錯誤和如何def的定義無關，而是函數調用時的語法錯誤，前面已經解釋過：位置參數必須放在最前面。

還能夠直接使用*而非*args的方式，這表示不收集任何參數，但卻要求它後面的參數必須按照關鍵字傳值的方式。

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

如下是正確和錯誤的調用方式示例：

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

# 錯誤
f(1,2,3)
f(1,2,c=3)
f(1,b=2,3)

不過，keyword-only後面的參數能夠使用參數默認值。

def f(a,*,b,c=3)

那麼c是可選的，但若是給定，則必須按關鍵字方式傳值。

參數定義和參數傳值的規則

對於函數定義中的參數，有3種方式：普通位置參數、*開啓的keyword-only參數、**args收集參數。它們之間的規則是：

• **args必須在最後面
  
• *或*args後面能夠是普通參數，可是函數調用傳值時，它後面的參數必須按照關鍵字的方式指定

因此，函數定義時參數的通用形式爲：其中c和d必須使用關鍵字傳值方式

def f(a,b,  *,c,d,  **dicts)
def f(a,b,  *args,c,d,  **dicts)

對於函數調用中的參數，有：普通位置參數、關鍵字參數、*解包參數、**解包參數。它們之間的規則時：

• 普通位置參數必須在最前面
  
• **解包必須在最後面
  
• 關鍵字參數和*解包參數只要求在上述兩種參數形式中間，順序能夠隨意

因此，函數調用時的傳參形式爲：

f(a,b,c,  *(d,e,f),g=1,h=2,  **dict(j=3,k=4))
f(a,b,c,  d=1,e=2,*(f,g,h),  **dict(j=3,k=4))

例如：

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

f(1,  2,3,  c=4,  x=5,y=6)
f(1,  c=4,*(2,3),  **dict(x=5,y=6))
f(1,  *(2,3),c=4,  **dict(x=5,y=6))
f(1,  *(2,3),      **dict(c=4,x=5,y=6))
f(1,  2,3,         **dict(c=4,x=5,y=6))

函數註解(annotations)

python函數有一個名爲__annotations__的屬性(能夠使用dir(Func_Name)來查看)。它表示函數的註解。

函數的註解使得參數變得更規範、更通用，它有點相似於強調數據類型。但它們僅僅只是註解，只是給人看，用來起提示做用的，不會對實際的調用有任何影響。

例如，下面是沒有給註解的函數參數，也就是平時見到的參數方式：

def myfunc(a,b,c):
    return a+b+c

myfunc(1,2,3)

函數的註解分兩種：參數註解和返回值註解。

• 參數註解：定義在各參數名以後，使用冒號分隔參數和參數的註解
  
• 返回值註解：定義在參數列表以後，冒號以前，使用瘦箭頭->分隔

例如：

def myfunc(a:'string',b:[1,5],c:int)->int:
    return a+b+c

print( myfunc(1,2,3) )
print( myfunc("a","b","c") )

雖然上面的函數註解提示了參數a是一個字符串，b是一個列表，c是一個int類型的數據，以及返回值是一個int類型的值，但在函數調用的時候，這些"強調"並無發生影響，只不過在使用該函數的時候，若是使用IDE編寫代碼，會有代碼提示。

能夠經過函數的__annotations__屬性查看函數的註解：

print(myfunc.__annotations__)

輸出：

{'a': 'string', 'b': [1, 5], 'c': <class 'int'>, 'return': <class 'int'>}

能夠只對其中一個或多個參數進行註解。

若是使用了註解，還要設置參數的默認值，則默認值須要在註解的後面。例如：

def f(a:'string'=4):

函數註解只對def語句有效，對lambda無效，由於lambda已經限制了函數的定義方式。