🐍函数参数

1、形参 与 实参是什么？

形参（形式参数）：指的是在定义函数时，括号内定义的参数，形参其实就变量名

实参（实际参数），指的是在调用函数时，括号内传入的值，实参其实就变量的值

#x,y是形参
    def func(x,y): #x=10,y=11
        print(x)
        print(y)

#10,11是实参
    func(10,11)

 

注意：

实参值（变量的值）与形参（变量名）的绑定关系只在函数调用时才会生效/绑定, 在函数调用结束后就立刻解除绑定

 

2、位置参数 位置形参 位置实参

位置即顺序，位置参参数指的就是按照从左到右的顺序依次定义的参数

 

#在定义函数时，按照位置定义的形参，称为位置形参 
def foo(x,y,z):
    print(x,y,z)    
    
#位置形参的特性是：在调用函数时必须为其传值，而且多一个不行，少一个也不行
 foo(1,2)       #少了一个数 报错
 foo(1,2,3,4)   #多了一个数 报错
 
#在调用函数时，按照位置定义的实参，称为位置实参
注意：位置实参会与形参一一对应
foo(1,3,2)  #必须一一对应

 

3、 关键字参数

在调用函数时，按照key=value的形式定义的实参，称为关键字参数

def foo(x,y,z):
    print(x,y,z)
    
#相当于指名道姓地为形参传值，意味着即便是不按照顺序定义，仍然能为指定的参数传值
 foo(2,1,3)    #位置实参，一一对应
 foo(y=2,x=1,z=3)      #关键字实参  指名道姓  不需要顺序
 foo(z=2,aaaa=1)     #少了值   没有aaa   报错

#在调用函数时，位置实参与关键字实参可以混合使用，但必须
#必须遵循形参的规则
foo(1,z=3,y=2)    #1,2,3    x=1,y=2,z=3
foo(1,z=3)       #少了  报错

#不能为同一个形参重复传值
foo(1,x=1,y=3,z=2)    #x重复传值   报错

#位置实参必须放到关键字实参的前面
foo(y=3,z=2,1)   #位置实参应该  在  关键字实参前面   报错

 

4、默认参数

在定义阶段，已经为某个形参赋值，那么该形参叫默认参数

 

(1) 定义阶段已有值，代表着调用阶段可以不传值

def register(name,age,sex='male')：
    print(name,age,sex)
    
register('sss',14)
register('ddd',18)
register('lll',74,'female')    #传的话 用新值
register('nnn',54)
#sss 14 male
#ddd 18 male
#111 74 female  
#nnn 54 male

 

(2) 位置形参必须在默认参数的前面

def func(y=i,x):    #报错，位置应该在默认形参的前面
pass

 

(3) 默认参数的值只在定义阶段赋值一次,也就是说默认参数的值再定义阶段就固定死了

m=10
def foo(x,y=m)   #这里 y已经是 m=10 了，不会再改变了
    print(x,y)
    
m='jhhhhjhj'    #再次定义也不会改变 y 的值
foo(1)    #1,10
foo(1,11)   #这里 y=11

 

(4)记住:默认参数的值应该设置为不可变类型

def register(name,hobby,l=None):
    if l is None:
        l=[]
    l.append(hobby) #l=['play']
    print(name,l) # wxx ['play']

register('wxx','play')  # wxx ['play']
register('alex','read') # alex ['read']
register('egon','music') # alex ['music']

def register(name,hobby,l=[]):   #如果是这种情况 l=[]
    l.append(hobby)              #为一个集合，可变类型
    print(name,l) 

 

应用:

对于经常需要变化的值,需要将对应的形参定义成 位置形参

对于大多数情况值都一样的情况,需要将对应的形参定义成 默认形参

 

5、可变长度参数

参数的个数不固定,实参有 按位置定义（*）的实参和 按关键字定义（**）的实参

 

形参里包含 * **

（1）*会将溢出的位置实参全部接收,然后保存成元组的形式赋值给args

def foo(x,y,z,*args):    #位置
    print(x,y,z)
    print(args)    ##args=(4,5,6,7,8）

foo(1,2,3,4,5,6,7,8,)    

 

（2） **会将溢出的关键字实参全部接收,然后保存成字典的形式赋值给kwargs

def foo(x,y,z,**kwargs):   #关键字
    print(x,y,z)
    print(kwargs)    # kwargs={'c':3,'a':1,'b':2}

foo(x=1,y=2,z=3,a=1,b=2,c=3)

 

实参里包含 * **

（1）一旦碰到实参加*,就把该实参的值打散

def foo(x,y,z,*args): 
    print(x,y,z)    #1,2,3，
    print(args)    #args=([4,5,6,7,8],)

foo(1,2,3,*[4,5,6,7,8]) #foo(1,2,3,4,5,6,7,8)  #把*里面的打散
foo(1,2,3,*(4,5,6,7,8)) #foo(1,2,3,4,5,6,7,8)
foo(1,2,3,*'hello') #foo(1,2,3,'h','e','l','l','o')

 

错误例子

def foo(x,y,z):
    print(x,y,z)

foo(*[1,2,3])     #foo(1,2,3)
foo(*[1,2,3,4])    #foo(1,2,3,4) 多了一个  报错
foo(*[1,2,])        #foo(1,2,)  少了一个   报错

 

（2）一旦碰到实参加**,就把该实参的值打散

def foo(x,y,z,**kwargs):
    print(x,y,z)
    print(kwargs)

foo(1,2,3,**{'a':1,'b':2})   #foo(1,2,3,b=2,a=1)
          #把**里的打散

def foo(x,y,z):
    print(x,y,z)

foo(1,**{'z':3,'y':2})    #foo(1,z=3,y=2)
foo(1,**{'z':3,'y':2,'x':111})   #foo(1,z=3,y=2,x=111)
                                 #重复传值  x  ，报错

 

重点

（3）组合使用

def index(name,age,gender):
    print('welcome %s %s %s' %(name,age,gender)
          
#----------------------------------------------------
          
def wrapper(*args,**kwargs):  #args=(1,2,3),kwargs={'x':1,'y':2,'z':3}
    index(*args,**kwargs) #index(*(1,2,3),**{'x':1,'y':2,'z':3}) # index(1,2,3,z=3,y=2,x=2)
wrapper(1,2,3,x=1,y=2,z=3)
#如果这样写，符合了wrapper，但rapper里面有一个index，不符合，报错
#在index里面会把元组和集合打散，变成6个元素，而index里面只有3个

#----------------------------------------------------

wrapper(name='egon',age=18,gender='male')   #这种写法都可以，符合index的语法
wrapper('egon',age=18,gender='male')
wrapper('egon',18,gender='male')
wrapper('egon',18,'male')

 

6、命名关键字参数

 

def auth(*args,**kwargs):
    """
    使用方式auth(name="egon",pwd="123")
    :param args:
    :param kwargs:
    :return:
    """
    # print(args,kwargs)
    if len(args) !=0:
        print('必须用关键字的形式传参')
        return
    if 'name' not in kwargs:
        print('必须用指定的key名name')
        return
    
    if 'pwd' not in kwargs:
        print('必须用指定的key名pwd')
        return

    name=kwargs['name']
    pwd=kwargs['pwd']
    print(name,pwd)
    
    ef auth(*args,name,pwd):
    print(name,pwd)