python函数(5)— 可变参数 *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类型: 
args= (1, 2, 3, 4)
args类型: 
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类型: 
kwargs =  {'a': 1, 'b': 2}
kwargs类型: 
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类型: 
args =  (2, 3, 4)
kwargs类型: 
kwargs =  {'a': 1, 'b': 2}
argument =  1
args类型: 
args =  (2, 3, 4)
kwargs类型: 
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 文档

你可能感兴趣的:(Python基础,python,args,kwargs,可变参数,函数)