python函数（5）— 可变参数 *args 和 **kwargs_*args, **kwargs

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：

可变参数和解包 — Python 3.8.16 文档