函数的参数分为两种

一：函数的参数分为两种：

#1.形参：在定义阶段括号内指定的参数,相当于变量名
#2.实参：在调用阶段传入的值称之为实参，相当于值

#形参在定义阶段是不占用内存空间的

#在调用阶段，实参的值会绑定给形参，在调用结束后解除绑定。 
# def foo(x,y):
 #x=1,y=2 
# print(x,y) 
# 
# foo(1,2)

 

二：在python中的参数分类

#1.位置参数：按照从左到右的顺序依次定义的参数
#位置形参：必须被传值，在函数调用的使传入的值多一个少一个都不行。
#位置实参：与形参一一对应传值   #按照顺序给形参传值


如：位置形参：必须被传值，多一个少一个都不行。

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

foo(1,2,3)
错误：TypeError: foo() takes 2 positional arguments but 3 were given 
#接受两个位置参数，你给了3个，只有两个位置形参，那就必须给传两个实参.

如：#位置实参：与形参一一对应传值   #按照顺序给形参传值

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

foo(1,2)
#结果是 1 2

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

foo(2,1)
#结果是2 1 

#我们通过位置实参，发现我们传参是通过顺序给我们的形参一一对应的

关键字参数：在函数调用时，按照key=value的形式定义的实参 #按照关键词的方式给我们的形参传值
特点：指明道姓地给形参传值，不在依赖于位置
注意：关键词实参必须放在位置实参的后面。

如：

def info(name,age,sex):
    print(name,age,sex)
info('zhao',18,'male')

#返回结果：zhao 18 male #这个传值你必须知道这个参数是按照什么排列的，有一个更好的方法，我们使用关键字参数 

关键词传参如下：

def info(name,age,sex):
    print(name,age,sex)
info(name='zhao',sex='male',age=18)

#返回结果：zhao 18 male #现在就不依赖位置进行传参，这个时候我们的形参是固定死，位置形参

总结：
实参的传值方式：位置实参，关键词实参，它们必须遵循形参的规则。 位置形参是必须比传值。

 

默认参数：

#默认参数：在函数定义阶段，就已经给形参赋值了
#特点：定义阶段已经有值，意味着调用阶段可以不用传值
#注意：
#1.默认参数必须放在位置形参的后面
#2.默认参数的值旨在定义是被赋值一次
#3.默认参数的值通常应该是不可变类型 ： 常用字符串 整型

def info(name,age,sex='male'):
    print(name,age,sex)
info('zhao',18)
#返回结果：zhao 18 male

def info(name,age,sex='male'):
    print(name,age,sex)
info(name='zhao',age=18)

#返回结果：zhao 18 male

 

可变成参数 *的用法

#可变长参数：在调用函数是，实参值的个数不固定
#实参的形式有：位置实参，关键字实参
#位置实参的个数不固定，形参是负责收值，形参就必须有相应的解决方案
#位置实参的个数不固定：形参的解决方案：*, ** 
# * 处理的按照位置定义的实参，溢出的部分，多出来的部分
# **  处理按照关键词，溢出的部分，多出来的部分

def info(x,y,*args):
    print(x,y)
    print(args)
info(1,2,3,4,5,6) #按照位置定义的实参，超出都会被*接受，然后保存成元组的形式，赋值给args # 
#返回结果：

  1 2
(  3, 4, 5, 6)

 

#第二种

#以后只要在实参看见* 他就等同于位置参数,在这里遇到的是一个元组的方式 *(1,2,3,4,5)，首先我们进行解压得到的结果 1 2 3 4 5

def info(x,y,*args):  #args=(3,4,5)
    print(x,y)
    print(args)
info(*(1,2,3,4,5))  #解压打回原形成位置实参的方式   info(1,2,3,4,5)  #在进行对形参传值
info(*[1,2,3,4,5])  #解压  info(1,2,3,4,5)  
#注意以后在实参看见* 就先把它解压打回原形

#返回结果是一样

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

#实例
#首先看到实参上有* 先把他打回原形 

def info(x,y):  #x=1 y=2
    print(x,y)
info(*(1,2))  # info(1,2)  这里的1对应的x  2对应的y

#**kwargs  关键字参数

#按照关键字定义的实参它的个数是不固定的,相应的形参也有一种按照关键词收值多出来的
#只要关键字实参遇见 ** 先打会原形解压 

def info(x,y,**kwargs): #kwargs={'x':1,'y':2,'c':3,'d':4,'e':5} 赋值给kwargs

    print(x,y)
    print(kwargs)
info(x=1,y=2,c=3,d=4,e=5) #c=3,d=4,e=5 这个是关键词多出来的实参

#返回的结果是：

1 2
{'c': 3, 'd': 4, 'e': 5}

 

 

实例二：

def info(x,y,**kwargs): # x=1,y=2 kwargs={c:3}
    print(x,y)
    print(kwargs)
# info(x=1,y=2,c=3,d=4,e=5)
info(**{'x':1,'y':2,'c':3})  #看到**关键字实参，先打回原形解压 info(x=1,y=2,c=3) 


实例三：

def foo(name,age):
    print(name,age)
foo(**{'name':'zhao','age':18})  #把字典当做参数传给形参,先解压 foor(name=zhao,'age'=18)
foo({'name':'zhao','age':18},18) #注意这里不加**他就是一个位置实参，把一个字典给了我们的形参name赋值  name='name':'zhao','age':18}

#返回结果：

zhao 18
{'name': 'zhao', 'age': 18} 18

 

*和 ** 可变长参数的应用的场景

#首先我们定义个 bar函数
#bar定义的是位置形参，意味就是必须给传值，传值的形式不固定，可以按照位置实参传值，关键字传值

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

#以下定义的这个函数很牛逼，任意长度，任意形式的参数

def wrapper(*args,**kwargs):
    print(args,kwargs)
wrapper(1,2,3,a=4,b=5,c=6)
站在实参的位置，必须这样写返回结果：
(1, 2, 3) {'a': 4, 'b': 5, 'c': 6}