簡述

在 Python 中，函式的定義非常簡單，滿足對應的語法格式要求即可。對於呼叫者來說，只需關注如何傳遞正確的引數，以及獲取相應的返回值就足夠了，無需瞭解函式的內部實現（除非想學習、跟蹤原始碼）。

話雖如此，但對於函式的定義來說，靈活性非常高。除了常規定義的必選引數以外，還支援預設引數、可變引數、以及關鍵字引數。這樣以來，不但能處理複雜的引數，還可以簡化呼叫者的程式碼。

|

形參和實參

不止 Python，幾乎所有的程式語言都會涉及兩個術語：parameter 和 argument。那麼，它們之間究竟有什麼區別呢？

• parameter 是指函式定義中的引數，而 argument 指的是函式呼叫時的實際引數。
• 簡略描述：parameter = 形參（formal parameter）， argument = 實參（actual parameter）。

例如，定義一個簡單的函式：

>>> def greet(param1, param2):
...     pass
... 
>>> 
>>> greet('Hello', 'Python')

其中，param1 和 param2 是函式的形參，而在函式 greet() 被呼叫時，傳入的（'Hello' 和 'Python'）則是實參。

固定數量引數的函式

到目前為止，關於函式，我們介紹的都是固定數量的引數。來看一個簡單的示例：

>>> def greet(say, msg):
...     print(say, msg)
... 
>>> 
>>> greet('Hello', 'Python')
Hello Python

這裡，函式 greet() 有兩個引數，用兩個引數呼叫這個函式，執行得很順利，不會有任何錯誤。

倘若，引數的個數不匹配，會發生什麼？

>>> greet()  # 沒有引數
...
TypeError: greet() missing 2 required positional arguments: 'say'
 
 and 'msg'
>>> 
>>> greet('Hi')  # 只有一個引數
...
TypeError: greet() missing 1 required positional argument: 'msg'

顯然，直譯器會發牢騷。但是，對 Python 來說，要解決這個問題簡直是易如反掌，繼續往下看！

預設引數

定義函式時，可以使用賦值運算子（=）為引數指定一個預設值。

注意： 如果引數沒有預設值，在呼叫時必需為其指定一個值；如果引數有預設值，那麼在呼叫時值是可選的，如果為其提供了一個值，將會覆蓋預設值。

>>> def greet(say, name = 'James', msg = 'I am your biggest fan!'):
...     print(say, ',', name, ',', msg)
... 
>>> greet('Hi')  # 只提供強制性的引數
Hi , James , I am your biggest fan!
>>> 
>>> greet('Hi', 'Kobe')  # 給出一個可選引數
Hi , Kobe , I am your biggest fan!
>>> 
>>> greet('Hi', 'Kobe', 'I want to challenge you!')  # 給出所有引數
Hi , Kobe , I want to challenge you!

由於 say 沒有預設值，所以必須指定；name、msg 有預設值，所以值是可選的。

函式中的所有引數都可以有預設值，但是，一旦存在一個預設引數，其右側的所有引數也必須有預設值。也就是說，非預設引數不能在預設引數之後。

例如，將上面的函式定義為：

def greet(name = 'James', say):

就會引發錯誤：

SyntaxError: non-default argument follows default argument

關鍵字引數

當使用某些值呼叫函式時，這些值將根據其位置分配給引數。

例如，在上述函式 greet() 中，當使用 greet('Hi', 'Kobe') 呼叫它時，'Hi' 被賦值給引數 say，同樣地，'Kobe' 被賦值給 name。

Python 允許使用 kwarg = value 格式的關鍵字引數呼叫函式：

>>> def greet(say, name = 'James'):
...     print(say, ',', name)
... 
>>> 
>>> greet(say = 'Hi', name = 'Kobe')  # 2 個關鍵字引數
Hi , Kobe
>>> 
>>> greet(name = 'Kobe', say = 'Hi')  # 2 個關鍵字引數（次序顛倒）
Hi , Kobe
>>> 
>>> greet('Hi', name = 'Kobe')  # 位置引數與關鍵字引數混合使用
Hi , Kobe

當以這種方式呼叫函式時，關鍵字引數必須在位置引數之後，所有傳遞的關鍵字引數都必須與函式接受的某個引數匹配，並且它們的順序不重要。

例如，像下面這樣呼叫，會引發錯誤：

>>> greet(name = 'Kobe', 'Hi')  # 關鍵字引數在位置引數之前
...
SyntaxError: positional argument follows keyword argument
>>>
>>> greet('Hi', na = 'Kobe')  # na 不匹配
...
TypeError: greet() got an unexpected keyword argument 'na'

可變引數

可變引數也被稱為不定長引數，顧名思義，就是傳入的引數個數是可變的，可以是任意個（0、1、2 … N）。

要定義可變引數，僅需在引數名之前新增一個星號（*）。在函式內部，這些引數被包裝為一個 tuple。

注意： 此 * 非彼 *，不要誤認為是 C/C++ 中的指標。

>>> def greet(*names):
...     print(names)
... 
>>> 
>>> greet()  # 沒有引數，返回空元組
()
>>>
>>> greet('Jordan', 'James', 'Kobe')
('Jordan', 'James', 'Kobe')

有時，必須在函式定義中使用位置引數以及可變引數，但位置引數始終必須在可變引數之前。

>>> def greet(say, *names):
...     print(say, names)
... 
>>> 
>>> greet('Hi')
Hi ()
>>> 
>>> greet('Hi', 'Jordan', 'James', 'Kobe')
Hi ('Jordan', 'James', 'Kobe')

通常情況下，可變引數會出現在形參列表的最後，因為它們會把傳遞給函式的所有剩餘輸入引數都收集起來。可變引數之後出現的任何形參都是“強制關鍵字”引數，這意味著，它們只能被用作關鍵字引數，而不能是位置引數。

>>> def greet(*names, sep = ','):
...     return sep.join(names)
... 
>>> 
>>> greet('Jordan', 'James', 'Kobe')
'Jordan,James,Kobe'
>>> 
>>> greet('Jordan', 'James', 'Kobe', sep = '/')  # 被用作關鍵字引數
'Jordan/James/Kobe'
>>>
>>> greet('Jordan', 'James', 'Kobe', '/')  # 被用作位置引數
'Jordan,James,Kobe,/'

任意關鍵字引數

還有一種機制，用於任意數量的關鍵字引數。為了做到這一點，使用雙星號（**）：

>>> def greet(**all_star):
...     print(all_star)
... 
>>> greet()  # 沒有引數，返回空字典
{}
>>> 
>>> greet(name = 'James', age = 18)
{'name': 'James', 'age': 18}

當最後一個形式為 **msgs 的形參出現時，它將收到一個字典，其中包含所有關鍵字引數，除了與形參對應的關鍵字引數之外。還可以與 *names 的形參相結合（*names 必須出現在 **msgs 之前）。

例如，定義一個這樣的函式：

>>> def greet(say, *names, **msgs):
...     print('--', say)
...     for name in names:
...         print(name)
...     print('-' * 40)
...     keys = sorted(msgs.keys())
...     for key in keys:
...         print(key, ':', msgs[key])
... 
>>> 
>>> greet('Hi', 'Jordan', 'James', 'Kobe', msg = 'I want to challenge you!', challenger = 'Waleon')
-- Hi
Jordan
James
Kobe
----------------------------------------
challenger : Waleon
msg : I want to challenge you!

注意： 在列印內容之前，通過對 msgs 字典的 keys() 方法的結果進行排序來建立關鍵字引數名稱列表。如果沒有這樣做，則列印引數的順序是未定義的。

對引數進行解包

正如“可變引數”那樣，也可在函式呼叫中使用 * 操作符。只不過在這種情況下，與在函式定義中 * 的語義相反，引數將被解包而不是打包。

>>> def greet(name, age):
...     print(name, age)
... 
>>> 
>>> t = ('James', 18)
>>> greet(*t)
James 18

還有一種方式，幾乎沒有必要提到，這裡也羅嗦一下：

>>> greet(t[0], t[1])
James 18

與解包相比，這種呼叫方式顯然不舒適。另外，在一般情況下，呼叫 greet(t[0], t[1]) 幾乎是徒勞的，因為長度是未知的。“未知”的意思是：長度只在執行時才知道，而不是在編寫指令碼時就知道。

同樣地，字典也可以用 ** 操作符傳遞關鍵字引數：

>>> def greet(name, age = 18):
...     print(name, age)
... 
>>> 
>>> d = {'name':'James', 'age':32}
>>> greet(**d)
James 32