函数的参数

1.形参与实参是什么？

　　形参（形式参数）：指的是

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

　　实参（实际参数）：括号内传入的值，实参其实就是变量的值

　x,y是形参

def func(x,y):

    print(x)
    print(y)

func(20,30)

#20,30是实参

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

2.函数的参数

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

3.有两种参数：

（1）在定义时，按照位置定义的形参，称为位置形参

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

foo(1,2,3)



注意：位置形参的特性是：在调用函数时必须为其传值，而且多一个不行，少一个也不行。

 （2）在调用函数时，按照位置定义的实参，称为位置实参。
注意：位置实参会与形参一一对应。

4.什么是关键字参数：
　　在调用函数时，按照key=value的形式定义的实参，称为关键字参数。

def foo(x,y,z):
    print(x,y,z)
foo(5,9,3)
foo(y=8,x=1,z=4)


注意：相当于指名道姓的为形参传值，意味着即便不是按照顺序定义，仍然能为指定的参数传达值。

（1）在调用函数时，位置实参与关键字实参可以混合使用，但必须遵循形参的规则。

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

foo(1,z=3,y=2)  #这样写是正确的
foo(1,z=5)　　#这个没有遵循实参的规则，所以会报错



（2）不能为同一个形参重复传值。

（3）位置实参必须放到关键字实参的面前。

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

foo(x=8,y=7,3)  #里面的3就是位置实参，放在后面和中间都是不行的，必须要放在关键字实参的前面

这样才是正确的用法：

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

foo(3,y=7,z=8)


5.默认参数

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

注意：
（1）定义阶段已经有值，意味着调用阶段可以不传值。

def register(name,pasd,sex='yuan'):
    print(name,pasd,sex)

register('liuyuan',22,)
register('xiang',22)
register('xxx',80)


（2）位置形参必须在默认参数的面前

def func(y=1,x):  #这是错误的，里面的x为位置形参，不能放在后面。
    pass


（3）默认参数的值只在定义的阶段赋值一次，也就是说默认参数的值再定义就固定死了。

s=88
def foo(x,y=s):
    print(x,y)

s='555555555555555'
foo(1)
foo(1,22)

***输出结果：

1 88
1 22

（4）记住：默认参数的值应该设置为不可变类型

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

register('liuyuan','play')
register('xiang','read')


***以上输出：

liuyuan ['play']
xiang ['read']

应用：对于经常需要变化的值，需要将对应的形参定义成位置形参
　　　对于大多数情况值都一样的情况，需要将对应的形参定义成默认形参


6.可处理以上两种形式变参数
　
什么是可变参数？
　　可变长度指的参数的个数可以不固定，实参有按位置定义的实参和按关键字定义的实参，
　所以可变长的实参指的就是按照这两种形式定义的实参个数可以不固定。
　　然而实参终究是要给形参传值的
　所以形参必须有两种对应解决方案来分别处理以上两种形式可变长度的实参。

（1）形参里面包含*与**

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

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

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

###以上输出：

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

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

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

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

###以上输出：

1 2 3
{'a': 5, 'b': 6, 'c': 7}




注意：实参里面包含*与**
一旦碰到实参加*，就把该实参的值打散

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

foo(1,2,3,*[4,5,6,7,8,9])
foo(1,2,3,*'h,e,l,l,o')

###以上输出：

1 2 3
(4, 5, 6, 7, 8, 9)
1 2 3
('h', ',', 'e', ',', 'l', ',', 'l', ',', 'o')




一旦碰到实参加**，就该把该实参的值打散。

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

###以上输出：

1 8 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('egon',age=18,gender='male')
wrapper('egon',18,gender='male')
wrapper('egon',18,'male')

###以上输出：

welcome yuan 18 male
welcome xiang 18 male
welcome abasida 0.6 male

函数的参数

推荐阅读