可变长参数

可变长参数

一、可变长形参之*

​ 形参中的会将溢出的位置实参全部接收，然后存储元组的形式，然后把元组赋值给后的参数。需要注意的是：*后的参数名约定俗成为args。

def num (x,y,*args):   #*args接收了除了x、y多余的参数
    print(args)
    return 1
num(1,2,3,4,5)
----------------------------------------------------------
(3, 4, 5)  *args就为（3,4,5），1,2分别传给了x,y    #（输出后以元祖的形式储存）

二、可变长实参之*

实参中*，会将后参数的值循环取出，打散成位置实参。以后但凡碰到实参中带的，它就是位置实参，应该马上打散成位置实参去看。

def func(x, y, z, *args):
    print(x, y, z, args)
func(1, *(1, 2), 3, 4)     #实参中*一般后面是元祖，然后把它打散成位置实参
----------------------------------------------------------
1 1 2 (3, 4)

三、可变长形参之**

形参中的***会将溢出的关键字实参全部接收，然后存储字典的形式，+然后把字典赋值给**后的参数。需要注意的是：**后的参数名约定俗成为kwargs。

def func(**kwargw):
    print(kwargw)

func(a=5,b=5)
----------------------------------------------------------
{'a': 5, 'b': 5}    #接收后以字典的形式存储

四、可变长实参之**

实参中的，会将**后参数的值循环取出，打散成关键字实参。以后但凡碰到实参中带**的，它就是关键字实参，应该马上打散成关键字实参去看

def fun(a,c):    #定义一个函数，形参为（a.c）
    print(a,c)   #输出a,c对应的值
    return 4     #函数fun返回值4，注意的是必须要有值来接收

fun(**{'a':1,'c':5})    #调用函数并且赋值实参。**后参数的值循环取出，打散成关键字实参
print(fun(**{'a':5,'c':56}))  #输出函数得到返回值，此时函数又被运行了一次

1 5
5 56
4

五、可变参数的应用

def index(name, age, sex):
    print({name}{age}{sex})


def wrapper(*args, **kwargs):
    print({args})
    print({kwargs})
    index(*args, **kwargs)     #在这个函数调用了上面的函数，并且把接收到的*args, **kwargs打散传参到上面函数中


wrapper(name='nick', sex='male', age=19)

args: ()
kwargs: {'nick','male', 19}
nick, 19, male

六、命名关键字的形参

现在有一个需求：函数的使用者必须按照关键字实参传。

def register(x, y, **kwargs):
    if 'name' not in kwargs or 'age' not in kwargs:
        print('用户名和年龄必须使用关键字的形式传值')
        return
    print(kwargs['name'])
    print(kwargs['age'])


register(1, 2, name='nick', age=19)
nick
19

命名关键字形参：在函数定义阶段，*后面的参数都是命名关键字参数。

特点：在传值时，必须按照key=value的方式传值，并且key必须命名关键字参数的指定的参数名。

def register(x, y, *, name, gender='male', age):
    print(x)
    print(age)


register(1, 2, x='nick', age=19)  # TypeError: register() got multiple values for argument 'x'