1、可变参数*args 和 **kwargs
- 定义函数时候,参数*args在前,**kwargs在后,*args和**kwargs组合起来可以传入任意的参数。
- *args参数:可接受任意个位置参数,当函数调用时,所有未使用(未匹配)的位置参数会在函数内自动组装进一个tuple对象中,此tuple对象会赋值给变量名args。
- **kwargs参数:可接受任意个关键字参数,当函数调用时,所有未使用(未匹配)的关键字参数会在函数内组装进一个dict对象中,此dict对象会赋值给变量名kwargs。
- 位置参数和关键字参数
2、原理解析
为什么使用了*args和**kwargs就可以接受任意参数?
定义函数
- *参数收集所有未匹配的位置参数组成一个tuple对象,局部变量args指向此tuple对象
- **参数收集所有未匹配的关键字参数组成一个dict对象,局部变量kwargs指向此dict对象
调用函数
- *参数用于解包tuple对象的每个元素,作为一个一个的位置参数传入到函数中
- **参数用于解包dict对象的每个元素,作为一个一个的关键字参数传入到函数中
3、应用场景
通用装饰器函数如下,定义内函数的时候,为了使其可以接受任意参数,给他传了参数*args 和 **kwargs。
# 通用装饰器
def wrapper(func):
def inner(*args, **kwargs):
pass
return inner
参考闭包和装饰器
4、只有*args
# 自定义函数,只有*args
def func(*args):
"""
*参数收集所有未匹配的位置参数组成一个tuple对象,局部变量args指向此tuple对象
"""
print('args类型:', type(args))
print('args=', args)
# 调用函数,方法1
func(1, 2, 3, 4)
# 调用函数,方法2,解包
tuple = (1, 2, 3, 4)
func(*tuple) # *参数用于解包tuple对象的每个元素,作为一个一个的位置参数传入到函数中
-----------------------------------------------------------------------
运行结果:
args类型: <class 'tuple'>
args= (1, 2, 3, 4)
args类型: <class 'tuple'>
args= (1, 2, 3, 4)
分析运行结果:
方法1,调用函数时传入的参数,没有匹配到位置参数,被装入到一个元组tuple中,参数args指向这个tuple对象。
方法2,使用解包的方式,*tuple会将元组对象解包成一个一个位置参数传入到函数中。
方法1等同于方法2,运行结果一致。
5、只有**kwargs
# 自定义函数,只有**kwargs
def func(**kwargs):
"""
**参数收集所有未匹配的关键字参数组成一个dict对象,局部变量kwargs指向此dict对象
"""
print('kwargs类型:', type(kwargs))
print('kwargs = ', kwargs)
# 调用函数,方法1
func(a=1, b=2)
# 调用函数,方法2,解包
dict = {'a': 1, 'b': 2}
func(**dict) # **参数用于解包dict对象的每个元素,作为一个一个的关键字参数传入到函数中
-----------------------------------------------------------------------
运行结果:
kwargs类型: <class 'dict'>
kwargs = {'a': 1, 'b': 2}
kwargs类型: <class 'dict'>
kwargs = {'a': 1, 'b': 2}
分析运行结果:
方法1,调用函数时传入的参数,没有匹配的关键字参数,被装入到一个字典dict中,参数kwargs指向这个dict对象。
方法2,使用解包的方式,*dict会将字典对象解包成一个一个关键字参数传入到函数中。
方法1等同于方法2,运行结果一致。
6、包含*args和**kwargs
# 自定义函数,包含*args和**kwargs
def func(argument, *args, **kwargs):
print('argument = ', argument)
print('args类型:', type(args))
print('args = ',args)
print('kwargs类型:', type(kwargs))
print('kwargs = ',kwargs)
# 调用函数,方法1
func(1, 2, 3, 4, a=1, b=2)
# 调用函数,方法2
tuple = (1, 2, 3, 4)
dict = {'a': 1, 'b': 2}
func(*tuple, **dict) # 注意这里会把tuple解包出来的第一个实参1传给形参argument
---------------------------------------------------------------------------------
运行结果:
argument = 1
args类型: <class 'tuple'>
args = (2, 3, 4)
kwargs类型: <class 'dict'>
kwargs = {'a': 1, 'b': 2}
argument = 1
args类型: <class 'tuple'>
args = (2, 3, 4)
kwargs类型: <class 'dict'>
kwargs = {'a': 1, 'b': 2}
分析运行结果:
方法1,调用函数时传入的参数,其中参数1传给了位置参数argument,参数2,3,4没有匹配到对应的位置参数,被装入到一个元组tuple中,参数args指向这个tuple对象。参数a=1,b=2没有匹配到对应的关键字参数,被装入到一个字典dict中,参数kwargs指向这个dict对象。
方法2,使用解包的方式,*tuple会将元组对象解包成一个一个位置参数传入到函数中。*dict会将字典对象解包成一个一个关键字参数传入到函数中。
方法1等同于方法2,运行结果一致。
reference: