Python函數參數全面介紹
本文主要介紹Python的函數參數，各種形式的參數。建議動手試試，可以加深理解。
函數參數
定義函數的時候，我們把參數的名字和位置確定下來，函數的接口定義就完成了。對於函數的調用者來說，只需要知道如何傳遞正確的參數，以及函數將返回什麽樣的值就夠了，函數內部的復雜的邏輯被封裝起來，調用者無需了解。
Python的函數定義非常簡單，但靈活度卻非常大。除了正常定義的必選參數外，還可以使用默認參數、可變參數和關鍵字參數，使得函數定義出來的接口，不但能處理復雜的參數，還可以簡化調用者的代碼。
默認參數
默認參數使得API簡潔，但不失靈活性。當一個參數有默認值時，調用時如果不傳遞此參數時，會使用默認值。
def inc(init, step=1):
return init + step
# 調用一下這個函數
>>> inc(3)
4
>>> inc(3, 2)
5默認參數有一個坑，就是非默認參數要放到默認參數的前面（不然Python的解釋器會報語法錯誤）。允許有多個默認參數，但默認參數需要放在參數列表的最後面。
def append(x, lst=[]):
return lst.append(x)此函數有問題。（函數中的形參是全局變量？lst在append函數中叫lst，但在全局作用域中，我們不知道lst具體叫什麽名字。）修改之後的函數為，
def append(x, lst=None):
if lst is None:
lst = []
lst.append(x)
return lst通常來說，當默認參數是可變的時候，需要特別註意作用域的問題，我們需要上述的技巧（不可變的數據類型是值傳遞，可變的數據類型是引用傳遞。）。目前可變的對象為list，dict，set，bytearray。
默認參數很有用，但使用不當，也會掉坑裏。默認參數有個最大的坑，演示如下：
# 先定義一個函數，傳入一個list，添加一個END再返回 def add_end(L=[]): L.append(‘END‘) return L
當我們正常調用時，結果似乎不錯，
>>> add_end([1, 2, 3])
[1, 2, 3, ‘END‘]
>>> add_end([‘x‘, ‘y‘, ‘z‘])
[‘x‘, ‘y‘, ‘z‘, ‘END‘]當我們使用默認參數調用時，一開始結果也是對的，
>>> add_end()
[‘END‘]但是，再次調用add_end()時，結果就不對了，
>>> add_end()
[‘END‘, ‘END‘]
>>> add_end()
[‘END‘, ‘END‘, ‘END‘]原因解釋如下，
Python函數在定義的時候，默認參數L的值就被計算出來了，即[]，因為默
認參數L也是一個變量，它指向對象[]，每次調用該函數，如果改變了L的內
容，則下次調用時，默認參數的內容就變了，不再是函數定義時的[]了。
所以，定義默認參數要牢記一點：默認參數必須指向不變對象！
要修改上面的例子，我們可以用None這個不變對象來實現，
def add_end(L=None):
if L is None:
L = []
L.append(‘END‘)
return L為什麽要設計str、None這樣的不變對象呢？因為不變對象一旦創建，對象內部的數據就不能修改，這樣就減少了由於修改數據導致的錯誤。此外，由於對象不變，多任務環境下同時讀取對象不需要加鎖，同時讀一點問題都沒有。我們在編寫程序時，如果可以設計一個不變對象，那就盡量設計成不變對象。
位置參數
我們先寫一個計算x^2的函數：
def power(x):
return x * x對於power(x)函數，參數x就是一個位置參數。當我們調用power函數時，必須傳入有且僅有的一個參數x：
>>> power(5)
25
>>> power(15)
225現在，如果我們要計算x^3怎麽辦呢？可以再定義一個power3函數，但是如果要計算x^4、x^5、x^n，怎麽辦？我們不可能定義無限多個函數，我們可以把power(x)修改為power(x, n)，用來計算x^n，說寫就寫，
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s關鍵字參數
可變參數允許我們傳入0個或任意個參數，這些可變參數在函數調用時自動組裝為一個tuple。而關鍵字參數允許你傳入0個或任意個含參數名的參數，這些關鍵字參數在函數內部自動組裝為一個dict。示例如下，
def person(name, age, **kwargs):
print(‘name:‘, name, ‘age:‘, age, ‘other:‘, kwargs)函數person除了必選參數name和age外，還接受關鍵字參數kwargs。在調用該函數時，可以只傳入必選參數：
>>> person(‘LavenLiu‘, 25)
name: LavenLiu age: 25 other: {}也可以傳入任意個數的關鍵字參數：
>>> person(‘LavenLiu‘, 25)
name: LavenLiu age: 25 other: {}
>>> person(‘Taoqi‘, 25, city=‘Hebei‘)
name: Taoqi age: 25 other: {‘city‘: ‘Hebei‘}
>>> person(‘James‘, 31, gender=‘M‘, job=‘NBA player‘)
name: James age: 31 other: {‘gender‘: ‘M‘, ‘job‘: ‘NBA player‘}關鍵字參數有什麽用？它可以擴展函數的功能。比如，在person函數裏，我們保證能接收到name和age這兩個參數，但是，如果調用者願意提供更多的參數，我們也能收到。試想你正在做一個用戶註冊的功能，除了用戶名和年齡是必填項外，其他都是可選項，利用關鍵字參數來定義這個函數就能滿足註冊的需求。
和可變參數類似，也可以先組裝出一個dict，然後，把該dict轉換為關鍵字參數傳進去：
>>> kwargs = {‘city‘: ‘Hebei‘, ‘job‘: ‘Test‘}
>>> person(‘Taoqi‘, 25, **kwargs)
name: Taoqi age: 25 other: {‘city‘: ‘Hebei‘, ‘job‘: ‘Test‘}位置參數和關鍵字參數
位置參數和關鍵字參數是函數調用時的概念。
當默認參數和關鍵字參數結合起來用的時候，很有用。
關鍵字參數必須寫在位置參數之後，否則會拋出語法錯誤。
def minus(x, y):
return x - y
minus(3, 5) # 位置參數，位置傳參
minus(5, 3) # 位置參數，位置傳參
minus(x=5, y=3) # 關鍵字參數，關鍵字傳參
minus(y=3, x=5) # 關鍵字參數，關鍵字傳參位置參數和關鍵字參數可以共存，但是關鍵字參數必須寫到位置參數之後。
可變位置參數
可變位置參數用*定義，在函數體內，可變位置參數是一個元組。
可變位置參數。
In [1]: def fn(*args):
...: print(args)
...:
In [2]: fn((1, 2, 3, 4))
((1, 2, 3, 4),)
In [3]: tup01 = (1, 2, 3, 4)
In [4]: fn(tup01)
((1, 2, 3, 4),)
In [5]: fn(*tup01)
(1, 2, 3, 4)在python的函數中，還可以定義可變參數。可變參數就是傳入的參數個數是可變的。
In [6]: def cacl(*numbers):
...: sum = 0
...: for n in numbers:
...: sum = sum + n * n
...: return sum
...:
In [7]: nums = [1, 2, 3]
In [8]: cacl(*nums) # 這裏如果不在nums前面加*，有問題嗎？
Out[8]: 14可變關鍵字參數
可變關鍵字參數使用**定義，在函數體內，可變關鍵字參數是一個字典。可變關鍵字參數的key都是字符串，並且符合標識符定義規範。
def fn(**kwargs):
print(kwargs)
dict01 = {‘name‘: ‘Laven Liu‘, ‘age‘: 29}
fn(**dict01)
# fn(dict01)
fn(name=‘Laven Liu‘, age=29)
{‘name‘: ‘Laven Liu‘, ‘age‘: 29}
{‘name‘: ‘Laven Liu‘, ‘age‘: 29}- 可變位置參數只能以位置參數的形式調用
- 可變關鍵字參數只能以關鍵字參數的形式調用
- 可變位置參數必須在可變關鍵字參數之前
In [18]: def fn(*args, **kwargs):
...: print(args)
...: print(kwargs)
...:
In [19]: fn(1, 2, 3, a=1, b=2)
(1, 2, 3)
{‘a‘: 1, ‘b‘: 2}
In [20]: def fn(*args, x, y):
...: print(args)
...: print(x, y)
...:
In [21]: fn(1, 2, 3, 4)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-21-0ab4fbc96a17> in <module>()
----> 1 fn(1, 2, 3, 4)
TypeError: fn() missing 2 required keyword-only arguments: ‘x‘ and ‘y‘
In [22]: fn(1, 2, x=3, y=4)
(1, 2)
3 4- 可變參數後置
- 可變參數不和默認參數一起出現
參數組合
在Python中定義函數，可以用必選參數、默認參數、可變參數和關鍵字參數，這4種參數都可以一起使用，或者只用其中某些，但是請註意，參數定義的順序必須是： 必選參數、默認參數、可變參數和關鍵字參數
比如定義一個函數，包含上述4種參數，
>>> def func(a, b, c=0, *args, **kwargs):
... print(‘a =‘, a, ‘b =‘, b, ‘c =‘, c, ‘args = ‘, args, ‘kwargs = ‘, kwargs)在函數調用的時候，Python解釋器自動按照參數位置和參數名把對應的參數傳進去。
>>> func(1, 2)
a = 1 b = 2 c = 0 args = () kwargs = {}
>>> func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kwargs = {}
>>> func(1, 2, 3, ‘a‘, ‘b‘)
a = 1 b = 2 c = 3 args = (‘a‘, ‘b‘) kwargs = {}
>>> func(1, 2, 3, ‘a‘, ‘b‘, x=99)
a = 1 b = 2 c = 3 args = (‘a‘, ‘b‘) kwargs = {‘x‘: 99}
>>>最神奇的是通過一個tuple和dict，我們也可以調用該函數：
>>> args = (1, 2, 3, 4)
>>> kwargs = {‘x‘: 99}
>>> func(*args, **kwargs)
a = 1 b = 2 c = 3 args = (4,) kwargs = {‘x‘: 99}所以，對於任意函數，都可以通過類似func(*args, **kwargs)的形式調用它，無論它的參數是如何定義的。
參數解構
參數解構發生在函數調用時，可變參數發生函數定義的時候。參數解構分為兩種形式，一種是位置參數解構，另一種是關鍵字參數解構。
參數結構的兩種形式：
- 位置參數解構，使用一個星號。解構的對象為可叠代對象，解構的結果為位置參數。
- 關鍵字參數解構，使用兩個星號。解構的對象為字典，解構的結果為關鍵字參數。
位置參數解構的一個例子：
In [23]: def fn(a, b, c):
...: print(a, b, c)
...:
In [24]: lst = [1, 2, 3]
In [25]: fn(lst[0], lst[1], lst[2])
1 2 3
# 也可以進行如下形式的調用
In [26]: fn(*lst) # 這種做法就叫參數解構
1 2 3
# *號可以把線性結構解包成位置參數
lst = [1, 2, 3, 4]
fn(*lst) # -> fn(lst[0], lst[1], lst[2], lst[3])
TypeError: fn() takes 3 positional arguments but 4 were given
# 這裏就報錯了，本來這個函數只能接收3個位置參數，lst有四個元素，通過參數解構之後，就變成了4個參數，所以就報錯了。接下來看字典解構的例子，
In [27]: d = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
In [28]: fn(**d)
1 2 3
# **可以把字典解構成關鍵字參數參數解構發生在函數調用時。解構的時候，線性結構的解構是位置參數，字典解構是關鍵字參數。
傳參的順序：位置參數，線性結構解構；關鍵字參數，字典解構。盡量的少的同時使用兩種解構，除非你真的知道在做什麽。
In [29]: def fn(a, b, c, d):
...: print(a, b, c, d)
...:
In [30]: fn(0, *[2], c=1, **{‘d‘: 3})
0 2 1 3參數槽(keyword-only參數)
Python3中引入的。
def fn(a, b, c):
print(a, b, c)
fn(a=1, b=2, c=3)如果要強制傳入的參數為關鍵字參數，
def fn(*, a, b, c):
print(a, b, c)
>>> fn(1, 2, 3)
Traceback (most recent call last):
File "<pyshell#17>", line 1, in <module>
fn(1, 2, 3)
TypeError: fn() takes 0 positional arguments but 3 were given
>>> fn(a=1, b=2, c=3)
1 2 3
# *之後的參數，必須以關鍵字參數的形式傳遞，稱之為參數槽。參數槽通常和默認參數搭配使用。
>>> def fn(a, b, *, x, y):
print(a, b)
print(x, y)
>>> fn(1, 2, 3, 4)
Traceback (most recent call last):
File "<pyshell#23>", line 1, in <module>
fn(1, 2, 3, 4)
TypeError: fn() takes 2 positional arguments but 4 were given
>>> fn(1, 2, x=3, y=4)
1 2
3 4
>>> fn(1, 2, **{‘x‘: 3, ‘y‘: 4})
1 2
3 4
def fn(a, b, *):
print(a, b)
def fn(a, b, *):
... print(a, b)
File "<stdin>", line 1
SyntaxError: named arguments must follow bare *幾個例子：
def fn01(*, x=1, y=5):
print(x)
print(y)
>>> fn01()
1
5
def fn02(x=1, *, y):
print(x)
print(y)
>>> fn02(y=3)
1
3參數槽之坑：
*之後必須有參數- 非命名參數有默認值時，命名參數可以沒有默認值
- 默認參數應該在每段參數的最後
- 使用參數槽時，不能使用可變位置參數，可變關鍵之參數必須放在命名參數之後
總結
Python的函數具有非常靈活的參數形態，既可以實現簡單的調用，又可以傳入非常復雜的參數。
默認參數一定要用不可變對象，如果是可變對象，運行會有邏輯錯誤！
要註意定義可變參數和關鍵字參數的語法：
*args是可變參數，args接收的是一個tuple；
**kwargs是關鍵字參數，kwargs接收的是一個dict。
以及調用函數時如何傳入可變參數和關鍵字參數的語法：
可變參數既可以直接傳入：func(1, 2, 3)，又可以先組裝list或tuple，再
通過*args傳入：func(*(1, 2, 3))；
關鍵字參數既可以直接傳入：func(a=1, b=2)，又可以先組裝dict，再通過**kwargs 傳入：func(**{‘a‘: 1, ‘b‘: 2})。
使用*args和**kwargs是Python的習慣寫法，當然也可以用其他參數名，但最好使用習慣用法。
Python函數參數全面介紹