Python函數的參數是什么

Python函數的參數是什么？相信很多沒有經驗的人對此束手無策，為此本文總結了問題出現的原因和解決方法，通過這篇文章希望你能解決這個問題。

函數的靈活性非常高，除了常規定義的位置參數以外，還支持默認參數、關鍵字參數、以及可變參數 ... 這樣以來，不但能應對各種復雜的情況，甚至還可以簡化調用者的代碼。

位置參數

在調用函數時，一般會根據函數定義的參數位置來傳遞參數，這樣的參數叫做位置參數。

考慮下面的例子，函數包含了兩個參數 - name 和 msg：

>>> def greet(name, msg):
...     print('Hello, {}, {}!'.format(name, msg))
...>>>

調用它很容易：

>>> greet('Pony', 'nice to meet you')
Hello, Pony, nice to meet you!

這里，值會按照順序被依次分配。由于“Pony”是第一個值，所以它會被分配給第一個參數 name；同樣地，“nice to meet you”會被分配給第二個參數 msg。

當傳遞兩個值時，函數運行地很順利。但倘若參數的個數不匹配，會發生什么？

>>> greet('Pony')  # 少一個參數
...
TypeError: greet() missing 1 required positional argument: 'msg'

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

默認參數

在定義函數時，可以使用賦值運算符（=）為參數指定默認值：

>>> def greet(name, msg = 'nice to meet you'):
...     print('Hello, {}, {}!'.format(name, msg))
...
>>>

注意： 如果參數沒有默認值，在調用函數時必需為其指定一個值；如果有默認值，那么在調用時值是可選的，如果為其提供了一個值，將會覆蓋默認值。

由于 name 沒有默認值，所以必須指定值，而 msg 有默認值，所以值是可選的：

>>> greet('Pony')                   # 使用默認值
Hello, Pony, nice to meet you!
>>>
>>> greet('Pony', 'give me a hug')  # 覆蓋默認值
Hello, Pony, give me a hug!

值得注意的是，函數中的所有參數都可以有默認值，但是一旦存在一個默認參數，其右側的所有參數也必須有默認值。

也就是說，非默認參數不能在默認參數之后。例如，像下面這樣，就會報錯：

>>> def greet(msg = 'nice to meet you', name):
...     print('Hello, {}, {}!'.format(name, msg))
...
  File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

關鍵字參數

為方便起見，Python 還允許使用 key = value 形式的關鍵字參數調用函數：

>>> def greet(name, msg):
...     print('Hello, {}, {}!'.format(name, msg))
...>>>

當以這種方式調用函數時，所有傳遞的關鍵字參數都必須與函數接受的某個參數匹配，并且它們的順序不重要：

>>> greet(name = 'Pony', msg = 'nice to meet you')  # 按循序傳遞
Hello, Pony, nice to meet you!
>>>
>>> greet(msg = 'nice to meet you', name = 'Pony')  # 順序顛倒也可以
Hello, Pony, nice to meet you!

此外，它還可以和位置參數混合使用，但關鍵字參數必須在位置參數之后：

>>> greet('Pony', msg = 'nice to meet you')  # 位置參數與關鍵字參數混合使用
Hello, Pony, nice to meet you!

所以，如果像下面這樣調用，就會報錯：

>>> greet(name = 'Pony', message = 'nice to meet you')  # message 不存在
...
TypeError: greet() got an unexpected keyword argument 'message'
>>>
>>> greet(msg = 'nice to meet you', 'Pony')  # 關鍵字參數不能在位置參數之前
...
SyntaxError: positional argument follows keyword argument

可變參數

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

包裹位置傳遞

在參數名之前可以添加一個星號（*），在函數內部，所有傳入的參數都會被變量 names 收集，最終按照位置將它們合并為一個元組：

>>> def greet(*names):
...     print('Hello,', names)
...
>>>

嘗試一下，傳遞不同個數的參數：

>>> greet()  # 沒有參數，為空元組
Hello, ()
>>>
>>> greet('Pony')
Hello, ('Pony',)
>>>
>>> greet('Jack Ma', 'Pony')
Hello, ('Jack Ma', 'Pony')

通常情況下，可變參數（*）會出現在形參列表的最后，因為它們會把傳遞給函數的所有剩余輸入參數都收集起來：

>>> def greet(msg, *names):
...     print('Hello, {}, {}!'.format(names, msg))
...
>>>
>>> greet('nice to meet you', 'Jack Ma', 'Pony')
Hello, ('Jack Ma', 'Pony'), nice to meet you!

話雖如此，但可變參數（*）之后還可以出現其它參數，只不過這些形參都是“強制關鍵字”參數，這意味著，它們只能被用作關鍵字參數，而不能是位置參數：

>>> def greet(*names, msg):
...     print('Hello, {}, {}!'.format(names, msg))
...
>>>
>>> greet('Pony', msg = 'nice to meet you')  # 只能被用作關鍵字參數
Hello, ('Pony',), nice to meet you!
>>>
>>> greet(msg = 'nice to meet you', 'Pony')  # 不能被用作位置參數
...
SyntaxError: positional argument follows keyword argument

包裹關鍵字傳遞

還有一種機制，在參數名之前添加兩個星號（**），當這種形式出現時，msgs 將收集所有關鍵字參數，最終將它們合并為一個字典：

>>> def greet(**msgs):
...     print('Hello,', msgs)
...>>>

和上面一樣，嘗試傳遞不同個數的參數：

>>> greet()  # 沒有參數，為空字典
Hello, {}
>>>
>>> greet(name = 'Pony')
Hello, {'name': 'Pony'}
>>>
>>> greet(name = 'Pony', msg = 'nice to meet you')
Hello, {'name': 'Pony', 'msg': 'nice to meet you'}

此外，*names 還可以與 **msgs 形式的參數相結合，但*names 必須出現在 **msgs 之前。

例如，像下面這樣，就會報錯：

>>> def greet(**msgs, *name):
...
SyntaxError: invalid syntax

解包裹參數

正如【可變參數】那樣，也可在函數調用中使用 * 和 **。只不過在這種情況下，與在函數定義中的語義相反，參數將被解包裹而不是被包裹：

>>> def greet(name, msg):
...     print('Hello, {}, {}!'.format(name, msg))
...
>>>

嘗試一下，元組用 * 來傳遞位置參數：

>>> t = ('Pony', 'nice to meet you')
>>> greet(*t)
Hello, Pony, nice to meet you!

同樣地，字典也可以用 ** 傳遞關鍵字參數：``

>>> d = {'name':'Pony', 'msg':'nice to meet you'}
>>> greet(**d)
Hello, Pony, nice to meet you!

位置參數、默認參數、可變參數混合使用

根據上面的介紹，我們不難發現，當這些參數混合使用時，應遵循一個基本的原則：位置參數 -> 默認參數 -> 包裹位置 -> 包裹關鍵字（定義和調用都應遵循該順序）。

例如，定義一個函數，能夠同時向多個人發送多條消息：

>>> def greet(sender, address = 'BeiJing', *receivers, **msgs):
...     print('Hello, I am {}, from {}.'.format(sender, address))
...     print('-' * 30)      # 華麗的分割線
...     for rec in receivers:
...         for key, val in msgs.items():
...             print('No {}: {}, {}!'.format(key, val, rec))
...         print('-' * 30)  # 華麗的分割線
...
>>>

為了顯示更好的效果，我們在中間穿插了一些華麗的分割線：

>>> greet('Waleon', 'Xi\'an', 'Jack Ma', 'Pony', one = 'nice to meet you', two = 'give me a hug')
Hello, I am Waleon, from Xi'an.
------------------------------
No one: nice to meet you, Jack Ma!
No two: give me a hug, Jack Ma!
------------------------------
No one: nice to meet you, Pony!
No two: give me a hug, Pony!
------------------------------

看完上述內容，你們掌握Python函數的參數是什么的方法了嗎？如果還想學到更多技能或想了解更多相關內容，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！