一 形参与实参介绍
函数的参数分为形式参数和实际参数，简称形参和实参：
形参即在定义函数时，括号内声明的参数。形参本质就是一个变量名，用来接收外部传来的值。
实参即在调用函数时，括号内传入的值，值可以是常量、变量、表达式或三者的组合:
二 形参，实参的使用
按照从左到右的顺序依次定义的参数称之为位置参数
2.1 位置参数
-
位置形参：在函数定义阶段，按照从左到右的顺序直接定义的"变量名"，必须被传值，多一个不行少一个也不行
-
位置实参：在函数调用阶段， 按照从左到有的顺序依次传入的值，按照顺序与形参一一对应
2.2 关键字参数
关键字实参：在函数调用阶段，按照key=value的形式传入的值,指名道姓给某个形参传值，可以完全不参照顺序
def func(x,y):
print(x,y)
func(y=2,x=1)
func(1,2)
混合使用
1、位置实参必须放在关键字实参前
func(1,y=2)
2、不能能为同一个形参重复传值
2.3 默认参数
在定义函数时，就已经为形参赋值，这类形参称之为默认参数，当函数有多个参数时，需要将值经常改变的参数定义成位置参数，
而将值改变较少的参数定义成默认参数。
def register(name,age,sex='male'): #默认sex的值为male
print('Name:%s Age:%s Sex:%s' %(name,age,sex))
定义时就已经为参数sex赋值，意味着调用时可以不对sex赋值，这降低了函数调用的复杂度,也可以修改。
register('tom',17) #大多数情况,无需为sex传值,默认为male
Name:tom Age:17 Sex:male
register('Lili',18,'female') #少数情况,可以为sex传值female
Name:Lili Age:18 Sex:female
需要注意：
1、默认参数必须在位置参数之后
2、默认参数的值仅在函数定义阶段被赋值一次，准确的说是内存地址。（可变类型与不可变类型的区别）
示范1：不可变类型
m=2
def func(x,y=m): # y=>2的内存地址
print(x,y)
m=3333333333333333333
func(1)
示范2：可变类型
m = [111111, ]
def func(x, y=m): # y=>[111111, ]的内存地址
print(x, y)
m.append(3333333)
func(1)
3、虽然默认值可以被指定为任意数据类型，但是不推荐使用可变类型
函数最理想的状态：函数的调用只跟函数本身有关系，不外界代码的影响.
如果一定用可变类型的话，推荐在内部再定义：
def func(x,y,z,l=None):
if l is None:
l=[]
l.append(x)
l.append(y)
l.append(z)
print(l)
2.4 长度可变参数
参数的长度可变指的是在调用函数时，实参的个数可以不固定，而在调用函数时，实参的定义无非是按位置或者按关键字两种形式，
这就要求形参提供两种解决方案来分别处理两种形式的可变长度的参数
- 1.如果在最后一个形参名前加*号,那么在调用函数时，溢出的位置实参，
都会被接收，以元组的形式保存下来赋值给该形参。args是一个元组
def foo(x,y,z=1,*args): #在最后一个形参名args前加*号
print(x)
print(y)
print(z)
print(args)
foo(1,2,3,4,5,6,7) #实参1、2、3按位置为形参x、y、z赋值，
#多余的位置实参4、5、6、7都被*接收，以元组的形式保存下来，赋值给args，即args=(4, 5, 6,7)
1.1 *可以用在实参中，实参中带※，其后的值打散（打伞）成位置实参
def func(x,y,z):
print(x,y,z)
# func(*[11,22,33]) # func(11，22，33)
# func(*[11,22]) # func(11，22)只能多不能少
l=[11,22,33]
1.2 形参与实参中都带*,一步步来先打伞后接收。
def func(x,y,*args): # args=(3,4,5,6)
print(x,y,args)
func(1,2,[3,4,5,6])
func(1,2,*[3,4,5,6]) # func(1,2,3,4,5,6)
func(*'hello') # func('h','e','l','l','o')
- 2.如果在最后一个形参名前加号,那么在调用函数时，溢出的关键字实参，
都会被接收，以字典**的形式保存下来赋值给该形参。约定俗成应该是kwargs
def foo(x,**kwargs): #在最后一个参数kwargs前加**
print(x)
print(kwargs)
foo(y=2,x=1,z=3) #溢出的关键字实参y=2，z=3都被**接收，以字典的形式保存下来，**kwargs是一个字典**
1
{'z': 3, 'y': 2}
2.1 实参中有**，还是先打伞，
def func(x,y,z):
print(x,y,z)
func(*{'x':1,'y':2,'z':3}) # func('x','y','z')字典被一星打伞的结果
func(**{'x':1,'y':2,'z':3}) # func(x=1,y=2,z=3)字典被两星打伞的结果
#错误用法
func(**{'x':1,'y':2,}) # func(x=1,y=2)#少了
func(**{'x':1,'a':2,'z':3}) # func(x=1,a=2,z=3)对不上
2.2 形参与实参中都带**，还是先打伞，后接收。
def func(x,y,**kwargs):
print(x,y,kwargs)
func(y=222,x=111,a=333,b=444)
func(**{'y':222,'x':111,'a':333,'b':4444})
终极boss：一星两星，形参实参混用：一星args必须在两星kwargs之前（Markdown语法自动转译*，有点烦）
def func(x,*args,**kwargs):
print(args)
print(kwargs)
func(1,2,3,4,5,6,7,8,x=1,y=2,z=3)
配合使用：
def index(x,y,z):
print('index=>>> ',x,y,z)
def wrapper(*args,**kwargs): #args=(1,) kwargs={'z':3,'y':2}
index(*args,**kwargs)
# index(*(1,),**{'z':3,'y':2})
# index(1,z=3,y=2)
wrapper(1,z=3,y=2) # 为wrapper传递的参数是给index用的
# 原格式---》汇总-----》打回原形
2.5 命名关键字参数
命名关键字参数：在定义函数时，*后定义的参数，如下所示，称之为命名关键字参数
特点：
1、命名关键字实参必须按照key=value的形式为其传值
def func(x,y,*,a,b): # 其中，a和b称之为命名关键字参数
print(x,y)
print(a,b)
func(1,2,b=222,a=111)
- 组合使用
形参混用的顺序：位置新参，默认形参,*args,命名关键字形参，**kwargs
def func(x,y=111,*args,z,**kwargs):
print(x)
print(y)
print(args)
print(z)
print(kwargs)