函数二

一：形参与实参

1、形式参数：定义函数时，括号内定义的参数，其实就是变量名

def fun（x，y）：（x，y）就是形式参数

     pass

2、实际参数：调用函数是，括号内由外部调用者传入的值，其实就是变量值

def fun（x，y）

      pass

fun（10，11）（10和11就是实际参数）

3.注意点：

实际参数和形式参数的绑定关系只有在函数调用时才会生效函数调用结束后，就是失效，解除绑定，释法资源。

二、参数的具体使用：

1.位置参数

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

1.2定义函数时，按照位置定义的形式参数，称之为位置形式参数

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

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

1.3调用函数时，按照位置定义的实际参数，称之为位置实际参数

注意：位子实际参数会与形式参数一一对应

def foo(x,y,z):
     print(x,y,z)
foo(1,2,3)

三、什么是关键字参数

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

def foo (x,y,z)
   print(x,y,z)
foo(x=1,z=2,y=3)

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

四 默认参数

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

def register(name, age, sex='male'):
    print(name, age, sex)


register('egon', 18)
register('alex', 73, 'female')
register('wxx', 84)
register('xxxx', 84)

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

电脑输出结果：

egon 18 male
alex 73 female
wxx 84 male
xxxx 84 male

应用：

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

对于大多数情况下需要将对应的形式参数定义成默认参数

注意：位置参数必须在默认参数前面

def fun(y=1,x)#错误
def fun（x，y=1）#正确

默认参数在定义阶段赋值一次，也就是默认的定义阶段固定死了

m=0
def foo(x,y=m)
print(x,y)
m='aaaaaaaaaaaaaaa'（之前被定义过了，所以在次赋值就不会被应用）
foo（1）
foo（1，11）

电脑输出：

1,10
1,11

4、默认参数应当设置为不可变类型（int数字，str字符串，tuple元组）

def register(name, hobby,l=[]):
     l.append(hobby)
     print(name,1l
register('wax','play')
register('alex','read')
register('egon','music')

电脑输出：

wax ['play']
alex ['play', 'read']
egon ['play', 'read', 'music']

这样会产生一个问题：

我要的是这样的：

wax ['play']
alex ['read']
egon ['music']

为什么会产生这种问题呢？

因为  L是一个列表，会增加但不会更替。

解决方案就是：

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

或者；

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

   

五：什么是可变长度参数

可变长度指的是参数的个数可以不固定，实际参数按位置定义的实参和按照关键字定义的实参，所以可变长的实参指的是按照这两种

形式定义的实参个数可以不固定，然而实参终究是要给形参传值，所以形参必须有两种对应的解决方法来

分别解决这两个方案。

def fun(x,y,z):
    print(x,y,z)
fun(1,2,3,4,5,6,7,8,9)#(输入多了怎么办)

*会将多余的关键字存成元组的形式（位置实参）一旦碰到实际参数加*，就该实际参数的值打散

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

电脑输出：
1 2
（4，5，6，7，8）

foo(1,2,3,4,*args):
    print(x,y,z)
    print(args)
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')

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

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

电脑输出：

1 2 3
{'a': 1, 'b': 2, 'c': 3}

*args,**kwargs组合使用：

 def wrapper(*args,**kwargs):
#     print(args)
#     print(kwargs)
# wrapper(1,2,3,4,5,6,7,x=1,y=2,z=3)

电脑输出：

(1, 2, 3, 4, 5, 6, 7)
{'x': 1, 'y': 2, 'z': 3}

（wrapper被index给限制死了，只能输入三个数字）

def index(name,age,gender):
    print('welcome %s %s %s' %(name,age,gender))
def wrapper(*args,**kwargs):
    index(*args,**kwargs)
wrapper('egon',age=18,gender="male")
wrapper('egon',18,gender='male')
wrapper('egon',18,'male')

电脑输出：

welcome egon 18 male
welcome egon 18 male
welcome egon 18 male