有時，你會看到python中定義函數的時候帶有兩個奇怪的參數：*args、**kwargs。如果你曾經想知道它們是干什么的，或者想知道你的IDE為什么在main()函數中定義它們，那么本文可以幫助到你。本文會告訴你在python中如何使用args和kwargs，來增加函數的靈活性。

1.傳遞多個參數給函數

*args和*kwargs允許你給一個參數傳遞多個參數或者keyword參數?？紤]下面的例子。這是一個簡單的函數，需要獲取兩個參數并返回它們之和：

def my_sum(a, b):

return a + b

這個函數可以正常工作，但它僅限于兩個參數。如果需要對不同數量的參數求和，如果傳遞的特定參數數量僅在運行時確定，該怎么辦？創建一個可以對傳遞給它的所有整數求和的函數，不管是多少個參數，是不是很好？

2.在python函數定義中使用變量args

有多種方法可以給一個函數傳遞不同數量的參數。

對于有經驗的人來說，第一種最直觀的方法是使用集合。簡單地傳遞一個list或者set作為函數的參數。因此，對于my_sum()，你可以將你所有要相加的所有整數以一個list的形式傳入：

# sum_integers_list.py

def my_sum(my_integers):

result = 0

for x in my_integers:

result += x

return result

list_of_integers = [1, 2, 3]

print(my_sum(list_of_integers))

可以這樣實現，但是每當你要調用這個函數的時候，你就需要創建一個list作為參數傳入。這樣可能并不方便，尤其是你實現并不知道要加入list的所有值的時候。

這就是*args的作用之處了，它可以讓你傳遞可變數量的位置參數。以下為示例：

# sum_integers_args.py

def my_sum(*args):

result = 0

# Iterating over the Python args tuple

for x in args:

result += x

return result

print(my_sum(1, 2, 3))

這個例子中，你不再需要向my_sum()函數傳遞一個list。而是傳遞三個不同的位置參數。my_sum()會獲取所有輸入的參數，并將它們打包成一個可迭代的簡單對象，命名為args。

注意，args只是一個名字。你可以不用args這個名字。你可以選擇任何你喜歡的名字，比如integers:

# sum_integers_args_2.py

def my_sum(*integers):

result = 0

for x in integers:

result += x

return result

print(my_sum(1, 2, 3))

這個函數仍然正常工作，即使你傳遞的可迭代對象是integers而不是args。這里最重要的是你使用的解包(unpacking)操作符(*)。

請記住，你使用解包(unpacking)操作符*獲得的可迭代對象不是一個list，而是一個元組(tuple)。

一個元組(tuple)類似一個list，它們都支持切片和迭代。然而，元組(tuple)又是和list不同的，至少在一個方面：lists是可變的、tuple是不可變的。

為了測試這點，可以運行以下的代碼。這個腳本嘗試去修改一個list的值：

# change_list.py

my_list = [1, 2, 3]

my_list[0] = 9

print(my_list)

list中，第一個元素的值就被更新成了9。如果你執行這個腳本，你會看到list的值的確被修改了

$ python change_list.py

[9, 2, 3]

第一個元素的值不再是0，而是被更新成了9?，F在，嘗試對一個元組(tuple)做相同的操作：

# change_tuple.py

my_tuple = (1, 2, 3)

my_tuple[0] = 9

print(my_tuple)

這里，你可以看到相同的值，除了它們被作為一個元組被放在一起。如果你嘗試執行腳本，你會看到python解釋器返回了一個error：

$ python change_tuple.py

Traceback (most recent call last):

File "change_tuple.py", line 3, in

my_tuple[0] = 9

TypeError: 'tuple' object does not support item assignment

這是因為元組(tuple)是不可變對象，它的值不能在指定后就不能被更改。請牢記這一點，當你使用tuple和*args的時候。

3.在python函數定義中使用變量kwargs

到這里，你已經知道*args的用途了，但是**kwargs呢？**kwargs工作原理和*args有點類似，但不是接收位置參數，而是接收關鍵字(keyword)參數(也叫被命名的參數)。以下為例：

# concatenate.py

def concatenate(**kwargs):

result = ""

# Iterating over the Python kwargs dictionary

for arg in kwargs.values():

result += arg

return result

print(concatenate(a="Real", b="Python", c="Is", d="Great", e="!"))

執行上面的腳本，concatenate()會通過python的kwargs字典進行迭代并將找到的所有值連接起來：

$ python concatenate.py

RealPythonIsGreat!

和args類似，kwargs只是一個名字，可以修改成任何你想要的名字。最重要的是解包(unpacking operator)操作符(**)的用途。

因此，上面的例子可以寫成這樣：

# concatenate_2.py

def concatenate(**words):

result = ""

for arg in words.values():

result += arg

return result

print(concatenate(a="Real", b="Python", c="Is", d="Great", e="!"))

在上面例子中，可迭代對象是標準的字典(dict)。如果你迭代字典并想返回值，你就必須使用.values(),就像例子中那樣所示。

事實上，如果你忘記了這個方法，你會發現你的迭代是通過你的python的kwargs字典的鍵實現的，就下下面的例子所示：

# concatenate_keys.py

def concatenate(**kwargs):

result = ""

# Iterating over the keys of the Python kwargs dictionary

for arg in kwargs:

result += arg

return result

print(concatenate(a="Real", b="Python", c="Is", d="Great", e="!"))

現在，你再執行示例，你會發現以下結果輸出：

$ python concatenate_keys.py

abcde

可以看到，如果你不指定.values(),你的函數會通過鍵進行迭代你的python的kwargs字典，返回錯誤的結果。

4.函數中參數的順序

既然你已經學習了*args和**kwargs是干什么的，你可以開始編寫獲取不同數量的參數的函數了。但是，如果你想創建一個函數，該函數接受可變數量的位置參數和命名參數，該怎么辦?

這時，你就需要記住順序很重要。非默認參數必須在默認參數之前處理，因此*args在**kwargs的前面。

總結一下，參數的正確順序是:

(1)位置參數

(2)*args參數

(3)**kwargs參數

例如，以下函數的定義是正確的：

# correct_function_definition.py

def my_function(a, b, *args, **kwargs):

pass

*args變量在**kwargs的前面。但是，如果你想修改參數的順序呢？例如，考慮下面的函數：

現在，函數定義中**kwargs在*args的前面。如果你想運行這個例子，你會接收到來自解釋器一個錯誤：

$ python wrong_function_definition.py

File "wrong_function_definition.py", line 2

def my_function(a, b, **kwargs, *args):

^

SyntaxError: invalid syntax

這種情況下，因為*args在**kwargs的后面，python解釋器拋出SyntaxError。

這里還可以分場景繼續細化出其它場景：

(1)如果只有位置參數、默認參數、*args。順序是：(位置參數，默認參數，*args)或者(位置參數，*args，默認參數)

(位置參數，默認參數，*args)

def foo(x,y=1,*args):

pass

foo (1,2,3,4,5) // 其中的x為1，y=1的值被2替換，3,4,5都給args，即args=(3,4,5)

(位置參數，*args，默認參數)

def foo(x,*args,y=1):

pass

foo (1,2,3,4,5) // 其中的x為1，2,3,4,5都給args，即args=(2,3,4,5),y始終為1

(2)位置參數、默認參數、*args*和*kwargs同時出現。順序是：(位置參數，*args*，默認參數，*kwargs)

def foo1(x, y, *args, a=8, b=9, **kwargs):

pass

foo1(1,2,3,4,a=5,b=6,y=7)

#其中的x為1,y為2

#3,4都給args,即args=(3,4)

#a,b分別被替換成5,6

#y=7以字典形式傳給kwargs

如果不帶默認參數：

def foo2(x, y, *args,**kwargs):

pass

foo2(1,2,3,4,a=5,b=6,y=7)

#其中的x為1,y為2

#3,4都給args,即args=(3,4)

#a=5,b=6,y=7以字典形式傳給kwargs

5.解包(unpacking)星號操作符：*和**

現在你可以使用*args和**kwargs來定義獲取變化的輸入參數的python函數了。讓我們再深入地理解解包(unpacking)操作符。

單個星號(*)和兩個星號(**)解包操作符是在Python2中引入的。在3.5版本中，它們變得更強大。簡而言之，解包(unpacking)操作符是將python中可迭代對象的值解包的操作符。單個星號操作符可以用在任意python提供的可迭代對象上，兩個星號操作符只能用于字典。

我們從下面這個例子開始：

# print_list.py

my_list = [1, 2, 3]

print(my_list)

代碼定義了一個list，然后將其打印輸出到標準輸出：

$ python print_list.py

[1, 2, 3]

注意列表是如何打印的，以及相應的括號和逗號。

現在，試著把解包操作符*添加到列表中:

# print_unpacked_list.py

my_list = [1, 2, 3]

print(*my_list)

這里，*操作符告訴print()首先將list解包。

在這個例子中，輸出不再是list本身，而是list的內容：

$ python print_unpacked_list.py

1 2 3

你能看出這個例子執行結果和print_list.py有什么不同么？print()已經將三個不同的參數作為輸入，而不是以一個list作為輸入。

另外你可能看到，在print_unpacked_list.py中，你使用了解包操作符(*)來調用函數，而不是用在函數定義中。在這里，print()將list中的單個item作為一個個參數。

你也可以使用這個方法調用自己的函數，但是如果你的函數需要特定數量的參數，那么你解包的iterable必須具有相同數量的參數。

為了測試這個行為，考慮以下的腳本：

# unpacking_call.py

def my_sum(a, b, c):

print(a + b + c)

my_list = [1, 2, 3]

my_sum(*my_list)

這里，my_sum()顯式聲明a，b，c是需要的參數。

如果你運行這個腳本，你會獲得my_list中三個數的和：

$ python unpacking_call.py

6

my_list中的三個元素完美地匹配了my_sum()需要的參數。

現在，看一下下面的腳本，my_list有四個參數而不是三個：

# wrong_unpacking_call.py

def my_sum(a, b, c):

print(a + b + c)

my_list = [1, 2, 3, 4]

my_sum(*my_list)

在這個例子中，my_sum()仍然期待三個參數，但是*操作符從list中獲得了四個。如果你嘗試執行這個腳本，你會發現python解釋器仍然可以運行它：

$ python wrong_unpacking_call.py

Traceback (most recent call last):

File "wrong_unpacking_call.py", line 6, in

my_sum(*my_list)

TypeError: my_sum() takes 3 positional arguments but 4 were given

當你用*操作符去解包一個list并傳遞給函數作為參數，就好像你在傳遞每一個單獨的參數。

這表示你可以使用多個解包(unpacking)操作符，從多個lists中獲取值并作為參數傳遞個一個函數。

可以用以下的示例來測試：

# sum_integers_args_3.py

def my_sum(*args):

result = 0

for x in args:

result += x

return result

list1 = [1, 2, 3]

list2 = [4, 5]

list3 = [6, 7, 8, 9]

print(my_sum(*list1, *list2, *list3))

如果你運行這個例子，所有的lists都被解包。每個單獨的項被傳遞給my_sum()，結果如下：

$ python sum_integers_args_3.py

45

解包操作符還有其他方便的用途。例如，假設你需要將列表分成三個不同的部分。輸出應該顯示第一個值、最后一個值和中間的所有值。使用解包操作符，你可以用一行代碼完成:

# extract_list_body.py

my_list = [1, 2, 3, 4, 5, 6]

a, *b, c = my_list

print(a)

print(b)

print(c)

在這個例子中，my_list包含6個項。第一個變量被分配給a，最后一個被分配給c，其它的值都被打包成一個list b。如果你運行一下，print()會顯示三個變量的值：

$ python extract_list_body.py

1

[2, 3, 4, 5]

6

另一個有趣的事是，你可以使用解包操作符(*)來對任何可迭代對象進行分片。如果你需要將兩個list進行合并，就會非常有用：

# merging_lists.py

my_first_list = [1, 2, 3]

my_second_list = [4, 5, 6]

my_merged_list = [*my_first_list, *my_second_list]

print(my_merged_list)

解包操作符(*)作為my_first和my_second的前綴。

如果你運行腳本，你會看到一個合并的list：

$ python merging_lists.py

[1, 2, 3, 4, 5, 6]

你可以合并兩個不同的字典，通過解包操作符(**):

# merging_dicts.py

my_first_dict = {"A": 1, "B": 2}

my_second_dict = {"C": 3, "D": 4}

my_merged_dict = {**my_first_dict, **my_second_dict}

print(my_merged_dict)

這里，迭代合并了my_first_dict和my_second_dict。

執行這個代碼，輸出一個合并后的字典：

$ python merging_dicts.py

{'A': 1, 'B': 2, 'C': 3, 'D': 4}

請牢記，*操作可以對任意可迭代對象起作用?？梢詫σ粋€字符串進行解包操作：

# string_to_list.py

a = [*"RealPython"]

print(a)

在python中，字符串是可迭代對象，因此*會解包字符串并將單個值放入list a中：

$ python string_to_list.py

['R', 'e', 'a', 'l', 'P', 'y', 't', 'h', 'o', 'n']

在使用這些操作符的時候，要記住代碼的可讀性很重要。

考慮以下的代碼：

# mysterious_statement.py

*a, = "RealPython"

print(a)

這里的解包操作符*，后面跟了一個變量，一個逗號和一個賦值。一行中打包了很多東西，這個代碼和上面的代碼沒有什么區別。只是將字符串RealPyhton中所有的項指定到一個新的list a。

a后面的逗號就可以了。當使用帶有變量賦值的解包操作符時，Python要求得到的變量要么是列表，要么是元組。使用后面的逗號，實際上已經定義了一個只有一個命名變量a的元組。

雖然這是一個巧妙的技巧，但許多Pythonistas并不認為這段代碼可讀性很強。因此，最好少用這類結構。

6.結論

現在，在你的python函數中，可以使用*args和**kwargs來接收可變數量的參數了。你也了解了解包操作符。

你已經學會：

(1)*args和**kwargs的含義。*args：非關鍵字參數、**kwargs：關鍵字參數

(2)如何使用*args和**kwargs來定義函數

(3)如何使用單個星號(*)來解包可迭代對象

(4)如何使用兩個星號(**)來解包字典對象

7.python小技巧

# How to merge two dicts

# in Python 3.5+

>>> x = {'a':1,'b':2}

>>> y = {'b':3,'c':4}

>>> z = {**x,**y}

>>> z

{'c':4,'a':1,'b':3}

總結

以上是生活随笔為你收集整理的python args kwargs_Python中的args和kwargs的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。