有时，你会看到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。现在，尝试对一个元组(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 <module>
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 <module>
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}
原文地址：https://www.cnblogs.com/abclife/p/11483372.html