上篇文章已经详细的介绍了python函数的传参方式，本文接着上文的内容详细的讲解一下可变参数 *args **kwargs，
- 本文主要内容：
- 可变参数的定义
- 理解参数传递(*)星号
- *args 非键值可变参数的定义
- 理解参数传递(**)双星号
- **kwargs 键值可变参数的定义
- 可变参数的混合调用和定义
1.可变参数定义
定义函数时，有时候我们不确定调用的时候会多少个参数,就可以使用可变参数
def func(required_arg, default_arg=None, *args, **kwargs):
pass
# required_arg 必传位置参数
# default_arg 默认参数
# *args 非键值可变参数
# **kwargs 键值可变参数
上面是Python得一个典型的函数定义，简单明了的表述了python的四种参数定义方式
- required_arg 必传位置参数
- default_arg 默认参数
- *args 非键值可变参数
- **kwargs 键值可变参数
注意：这几种参数是有顺序的，位置参数 > 默认参数>非键值可变参数>键值可变参数
今天主要介绍可变参数：
Python有一个特殊的语法,(单星号)(双星号),允许您将数量可变的参数传递给函数。 约定俗成的方式通常写args和kwargs, args和kwargs 只是变量名，你可以写vars和*vars实现相同的结果。
*args是用来传递一个非键值变长参数列表功能。
**kwargs通常用来传递关键字变长参数。
2. 理解参数传递(*)星号
>>> def add(x, y):
... print("x:",x)
... print("y:",y)
... print("sum:", x+y)
上面定义一个简单的函数add，我们通常的调用方式
>>> add(1, 2)
x: 1
y: 2
sum: 3
>>> add(x=1, y=2)
x: 1
y: 2
sum: 3
当面我们多传或者少传参数程序就会抛出异常
>>> add(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: add() missing 1 required positional argument: 'y'
>>> add(1,2,3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: add() takes 2 positional arguments but 3 were given
如果我们想通过1个变量传入多个参数怎么传？
>>> nums = (1,2)
>>> add(nums)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: add() missing 1 required positional argument: 'y'
我们把参数值封装到一个tuple 中，然后直接传递到add 中程序抛出了异常参数缺失，那要如何传参，可以使用*号
>>> nums = (1,2)
>>> add(*nums)
x: 1
y: 2
sum: 3
>>> nums = (1,2,3)
>>> add(*nums)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: add() takes 2 positional arguments but 3 were given
通过上面执行结果可以做到，只要在nums前加上,并且nums 的数量跟参数一致就可以调用成功，这是什么原因？
这里有一个知识点叫做序列化解包，在传递元组时，让元组的每一个元素对应一个位置参数，当nums 传递到函数里面时，程序会自动解包映射到位置参数上
3. *args 非键值可变参数的定义
我们在定义函数时，发现不能确认非键值参数的个数的时候，我们就可以定义为可变非键值参数
def add(*args):
... sum = 0
... for arg in args: #args是个元组
... print(arg)
... sum += arg
... print("sum:", sum)
我们通过*args 代表接收一个可变参数列表，那如何调用可变参数列表的函数呢
>>> add() #不传参数
sum: 0
>>> add(1,2,3)#通过位置参数传递
1
2
3
sum: 6
>>> nums = (1,2,3)#通过元祖或者列表 加* 传递
>>> add(*nums)
1
2
3
sum: 6
从上面的调用方式
args 定义的函数，可以传0个或者-个以上参数，可以通过位置参数传递，也可以传递
位置参数和可变参数*args 的解包关系
def add(num, *args):
... print("num:", num)
... sum = 0
... for arg in args: #args是个元组
... print(arg)
... sum += arg
... print("sum:", sum)
当我们不传参数的时候，程序会报错，因为第一个是必传位置参数，所以不传会抛出异常
>>> add()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: add() missing 1 required positional argument: 'num'
当我们传递一个参数的时候，程序正常执行，num 获取到传入的参数值，args 没有取到值
>>> add(1)
num: 1
sum: 0
当我们传递二个参数的时候，程序正常执行，num 获取到第一个参数值，args 取到第二参数
>>> add(1, 2)
num: 1
2
sum: 2
当我们传递三个参数的时候，程序正常执行，num 获取到第一个参数值，args 取到第一个以后参数
>>> add(1, 2, 3)
num: 1
2
3
sum: 5
当我们传递一个元祖的时候，程序正常执行，num 获取到第一个参数值，args 取到第一个以后参数
>>> nums = (1,2,3)
>>> add(*nums)
num: 1
2
3
sum: 5
由上可知，在使用args 定义函数时候，如果可变参数（args）之前有位置参数，解包参数会优先赋值给位置参数，剩余的变量赋值给可变参数
理解参数传递(**)双星号
>>> def fun(x, y, z):
... print("x:", x)
... print("y:", y)
... print("z:", z)
...
>>> fun(1,2,3)
x: 1
y: 2
z: 3
>>> fun(x=1,y=2,z=3)
x: 1
y: 2
z: 3
>>> fun(1,y=2,z=3)
x: 1
y: 2
z: 3
调用函数func 我们可以通过以上方式传参，我们还能有其他方式吗？有，那就是通过**
>>> nums = {"x":1,"y":2, "z":3}
>>> fun(**nums)
x: 1
y: 2
z: 3
>>> nums = {"y":2, "z":3}
>>> fun(1, **nums)
x: 1
y: 2
z: 3
我们可以把参数封装成字典，然后通过**nums 的方式传给函数func，实现原理是啥？
* 是解包赋值给位置参数
** 是解包赋值给关键词参数（关键词参数参考前文）
**kwargs 键值可变参数的定义
用”**kwargs”定义函数,kwargs接收除常规参数列表以外的键值参数字典
如果我们需要传递键值可变参数就如下定义函数
def func(**kwargs):
>>> def func(**kwargs):
... for key, value in kwargs.items(): #kwargs 是一个字典
... print("key:", key, " value:", value)
...
我们通过**kwargs代表接收一个可变参数字典，那如何调用可变参数字典的函数呢
>>> func(a=1,b=2)
key: a value: 1
key: b value: 2
>>> nums = {"a": 1, "b": 2}
>>> func(**nums)
key: a value: 1
key: b value: 2
从上面的调用方式
**kwargs 定义的函数，可以通过关键词参数传递，也可以**字典传递
6. 可变参数的混合调用和定义
位置参数、默认参数、可变参数的混合使用，基本原则是：先位置参数，默认参数， 非键值可变参数（args），键值可变参数(kwargs)
def func(required_arg, default_arg=None, *args, **kwargs):
pass
# required_arg 必传位置参数
# default_arg 默认参数
# *args 非键值可变参数
# **kwargs 键值可变参数
args和*kwargs 的区别
>>> def func(*args, **kwargs):
... print("args:", args)
... print("kwargs", kwargs)
...
>>> func(1,2)
args: (1, 2)
kwargs {}
>>> func(a=1, b=2)
args: ()
kwargs {'a': 1, 'b': 2}
>>> func(1,2,a=1, b=2)
args: (1, 2)
kwargs {'a': 1, 'b': 2}
可以看到，*args 表示任何多个非键值参数，它是一个tuple；**kwargs 表示关键字参数，它是一个dict。并且同时使用*args和**kwargs时，必须*args参数列要在**kwargs前，像func(a=1, b='2',1,2 )这样调用的话，会提示语法错误“SyntaxError: non-keyword arg after keyword arg”
*args与位置参数和默认参数混用
args与位置参数和默认参数混用:args要放到位置参数后
def func(a, *args, b=1):
... print("a:", a)
... print("b:", b)
... print("args:", args)
...
**kwargs与位置参数和默认参数混用
**kwargs 要放在默认参数之后
正确定义
def func(a, b=1,**kwargs):
... print("a:", a)
... print("b:", b)
... print("args:", args)
...
错误定义
def func(a, **kwargs， b=1):
... print("a:", a)
... print("b:", b)
... print("args:", args)
...
SyntaxError: invalid syntax
总结
了解函数4种参数传递方式，位置参数，关键词参数，默认参数，可变参数
理解*（单星号），**（双星号）的传参方式
* args和** kwargs是特殊关键字函数可以将可变长度参数。
* args通过数量可变的non-keyworded参数列表和列表的操作可以执行。
* * kwargs通过变量数量的关键字参数字典功能字典可以执行的操作。
注意：不同的类型的参数定义和传递都是有顺序要求的
