3：函数的参数之可变长参数

一、可变长参数

1、概述

• 指的是在调用函数时，传入的形参或实参个数可以不固定
• 根据位置参数，使用*args接收溢出的位置参数，存成元组，赋值给*后面跟的那个变量名
• 根据关键字参数，使用**kwargs接收溢出的关键字参数，存成字典，赋值给**后面跟的那个变量名

 

2、可变长形参

指的是调用函数时，传入的实参个数可以不固定

（1）、接收溢出位置实参，存成元组形式，然后赋值给*后面跟的那个变量名

def foo(x,y,*z):  #z=(3,4,5)
    print(x,y)
    print(z)

foo(1,2,3,4,5)

#返回值
1 2
(3, 4, 5)

（2）、接收溢出的关键字参数，存成字典形式，然后赋值给**后面跟的那个变量名

def foo(x,y,**z): # z={'c':4,'b':4,'a':2}
    print(x)
    print(y)
    print(z)

foo(1,a=2,b=3,c=4,y=5)

#返回值
1
5
{'a': 2, 'b': 3, 'c': 4}

 

3、可变长实参

• 实参无非两种形式：位置实参和关键字实参
• 所以对应的形参也必须对应两种解决方案，专门用于接收溢出的位置实参和关键字实参

（1）、在实参中用*，*号后面的实参会被for循环到*号后面的形参中

示例一：溢出的实参被形参z接收

def foo(x,y,*z):  #z=(3,4,5)
    print(x,y)
    print(z)

foo(1,2,*(3,4,5))

#返回值
1 2
(3, 4, 5)

 示例二：溢出的实参for循环都被形参z接收

def foo(x,y,*z):  #z=hello
    print(x,y)
    print(z)

foo(1,2,*'hello')   #foo(1,2,'h','e','l','l','o')

#返回值
1 2
('h', 'e', 'l', 'l', 'o')

 （2）、在实参中用**，**号后面的实参会被for循环成Key-value的形式到相应的形参中，如果溢出则被**号后面的形参接收

def foo(x,y,**z): # z={'a': 2, 'c': 3, 'b': 10}
    print(x)
    print(y)
    print(z)

foo(1,**{'a':2,'c':3,'b':10,'y':111}) #foo(1,y=111,c=3,a=2,b=10)

#返回值
1
111
{'a': 2, 'c': 3, 'b': 10}

 

二、可变长参数应用场景

1、接收任意长度，任意形式的参数

示例一：

def foo(*x,**y): # x=(1,2,3,4,5)
    print(x)
    print(y)

foo(1,2,3,4,5,a=1,b=2,c=3,d=4)

#返回值
(1, 2, 3, 4, 5)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

 示例二：*后面一般写args，**后面一般写kwargs

def foo(*args,**kwargs):
    print(args)
    print(kwargs)

foo(1,2,3,4,5,a=1,b=2,c=3,d=4)

#返回值
(1, 2, 3, 4, 5)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

 示例三：使用函数调用，接收任意形式的参数

def index(name,gender):
    print('welecom %s gender is %s' %(name,gender))
    
def wrapper(*args,**kwargs): # args=('alex','male')  kwargs={}
    index(*args,**kwargs) #index(*('alex','male'),**{}) #index('alex','male')

wrapper(gender='male',name='alex')

#返回值
welecom alex gender is male