Python中怎么對函數參數進行操作

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

Python獲取函數參數個數：

Python2.7寫法：

# -*- coding:utf-8 -*-
#! python2
def abc(a,b,c):
  print a,b
yy=abc.func_code.co_argcount
print yy

輸出結果為

3

python3.6寫法

# -*- coding:utf-8 -*-
#! python3
def abc(a,b,c):
  print(a,b)
a=abc.__code__.co_argcount
print(a)

輸出結果為

3

使用場景：

比如在REST規范的代碼中，request數據格式檢驗，判斷攜帶參數個數是否符合該函數所需參數的個數，不是就可以return error了

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