一 形参与实参介绍
函数参数分为形参和实参：
形参：在定义函数阶段定义的参数称之为形式参数，简称形参
def func(x,y): #x=1, y=2
print(x,y)
实参：在调用函数阶段传入的值称之为实际参数，简称实参
相当于变量值
func(1,2)
形参与实参的关系
1、在调用阶段：实参（变量值）会绑定为传给形参（变量名）
2、这种绑定关系只能在函数体内使用
3、实参与形参的绑定关系在函数使用时生效，函数调用结束后解决绑定关系
实参是传入的值，但值可以是以下形式
只要参数结果是一个值就可以了
形式一：
func(1, 2)
形式二：
a=1
b=2
func(a,b)
形式三：
func(int('1'), 2)
func(func(1,2),2)
二 形参与实参的具体使用
位置形参：在函数定义阶段按照从左到右的顺序直接定义的’变量名‘
特点：必须被传值,多一个不行，少一个也不行
def func(x, y):
print(x, y)
位置实参：在函数调用阶段按照从左到右的顺序依次传入的值
特点:按照顺序与形参一一对应
func（1，2）
func（1，2）
关键字实参数：在函数调用阶段，按照 key=value 的形式传入的值
特点：指名道姓给某个参数传值，可以完全不参照顺序
func(y=2,x=1）
默认形参：在定义函数阶段，就可以被赋值的形参，称之为默认参数
特点：在定义阶段就已经被赋值，意味着在调用阶段可以不用为其赋值
def func(x,y=3):
print(x,y)
func(x=1)#1,3
func(x=1, y=44)#1,44
使用场景：一般需要传入的参数大部分都是同一个值，只有偶尔需要传入不同值时，这时候可以在定义阶段将参数设为默认参数。
def register(name, age, gender='男')
print(name, age, gender)
register('三炮'，18)
register('二炮'，18)
register('大炮'，19)
register('没炮'，19，’女)
结果展示：
三炮 18 男
二炮 18 男
大炮 19 男
没炮 19 女
位置形参与默认参数混用，强调
1、位置参数必须在默认形参的左边
def func(y=2,x): #报错
pass
2、默认参数的值是在函数定义阶段被赋值的，准确地说被赋予的是值的内存地址
m=2
def func(x, y=m):#y =>2的内存地址
print(x,y)
m =333
func(1) #1,2
m = [111,]
def func(x, y=m): #y=>[111, ]的内存地址
pinrt(x,y)
m.append(333)
func(1) #1,[111,333]
Ps:
python 中所有值的传递，传递的都不是值本身，都是值的引用，即内存地址传递
3、虽然默认值可以被指定为任意数据类型，但是不推荐使用
函数的最理想的状态：函数的运行只跟函数本身有关系，不被外界代码影响
m = [111,]
def func(x, y=m): #y=>[111, ]的内存地址
pinrt(x,y)
m.append(333)
func(1) #1,[111,333]
示例：
def func(x,y,z,l=None):
if l is None:
l=[]
l.append(x)
l.append(y)
l.append(z)
print(l)
func(1,2,3) #[1, 2, 3]
func(4,5,6) #[4, 5, 6]
def func(x,y,z,l=None):
if l is None: #is 比较是 id，但是 None 只有一个，所以 id 是唯一的
l = []
l.append(x)
l.append(y)
l.append(z)
print(l)
func(1,2,3) #[1, 2, 3]
new_l = [111,222]
func(1,2,3,new_l) #[111, 222, 1, 2, 3]
混合使用，强调
1、调用阶段的位置实参必须放在关键字实参前
def func(x,y):
print(x,y)
func（1，y =2)
func(y=2, 1)#报错，语法错误
2、不能为同一参数重复传值
func(1,2, x=3, y=4)#报错 ，1，2 已经传给x,y了
可变长度的参数（*与 ** 的用法）
可变长度指的是在调用函数时，传入的值（实参）的个数不固定
而实参是用来为形参赋值的，所以对应着，针对溢出的实参必须有对应的形参来接收
可变长度的位置参数
形参格式 *形参名：用来接收溢出的位置实参， 溢出的位置实参会被 * 保存成元组的格式然后赋值给紧跟后面的参数名
def func(x,y,z): #z=(3,4,5,6)
print(x,y,z)
func(1,2,3,4,5,6) #1,2(3,4,5,6)
- 后跟的可以是任意名字，但是约定俗成应该是 args
def my_sum(*args): #args=(1,2,3,4)
res=0
for item in *args:
res += item
return res
res = my_sum(1,2,3,4)
print(res)#10
可变长度的关键字参数
形参格式 * * 形参名：用来接收溢出的关键实参，** 会将溢出的关键字实参保存成字典格式，然后赋值给紧跟后面的参数名
**后跟的可以是任意名字，但是约定俗成应该是 kwargs
def func(x,y, **kwargs):
print(x,y,kwargs)
func(1,y=2,a=1,b=2,c=3) #1 2 {'a': 1, 'b': 2, 'c': 3}
***实参中带 * **
实参中带* ，先将*后的值打散（相当于 for）成位置实参然后传入
def func(x,y,z):
print(x,y,z)
func(*[11,22,33]) #11 22 33
**形参与实参中都带 ***
先打散再赋值，溢出的参数会被*保存成元组赋值给紧跟的 args 参数名
def func(x,y,*args):
print(x,y,args)
func(1,2,[2,3,4,5]) #1 2 ([2, 3, 4, 5],)
func(1,*[2,3,4,5]) #1 2 (3, 4, 5)
** 在实参中
（ * * 后跟的只能是字典）,实参中带* *，先**后被打散成关键字实参再传给形参
def func(x,y,z):
print(x,y,z)
func(*{'x':1,'y':2,'z':3}) # func('x','y','z') 相当于 for 循环取出了 key
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) 传错了
**形参与实参中都带 * ***
def func(x,y,**kargs):
print(x,y,kargs)
func(y=22,x=11,a=33,b=55)# 11 22 {'a':33,'b':55}
func(**{'y':222,'x':111,'a':333,'b':444})# 111 222 {'a':333, 'b':444}
*混用 与 **** ： **args必须在 * kwargs 之前
def func(*args, **kwargs):
print(args) #(1,2,3,4,5)
print(kwargs)#{'x':1,'y':2,'z':3}
func(1,2,3,4,5, 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) #为 index=>>> 1 2 3 wrapper 传递的参数是给 index 用的
原格式----》汇总------》打回原形
命名关键字参数（了解）
在定义函数时，*后定义的参数，如下所示，称之为命名关键字参数
特点：
1、命名关键字实参必须按照 key = value 的形式为其传值
def func(x,y,*,a,b): #其中a和b称之为命名关键字参数
print(x,y) #1 2
print(a,b) #111 222
func(1,2, b=222, a=111)
def func(x,y,*,b =2, a) #注*后面是命名关键字参数，所以a 不是位置参数，b 不是默认参数
func(1,2,a=222)
组合使用（了解）
形参混用的顺序：
位置形参、默认形参 、*args、命名关键字参数、**kwargs
def func(x,y=111，*args,z，**kwargs):
print(x)
print(y)
print(args)
print(z)
print(kwargs)
实参混用的顺序：
def func(x,y, z,a,b,c):
print(x)
print(y)
print(z)
print(a)
print(bz
print(c)
func(111, y=222, *[333,444], **{'b':555,'c':666})#报错 *[333,444]:会打散成位置实参，所以必须放在关键字实参之前
func(111, *[333,444], z=222, **{'b':555,'c':666})
结果展示：
111
333
444
222
555
666
python 属于解释强类型动态语言
补充：
#强类型语言（python属于强类型）
数据类型不可以被忽略的语言 即变量的数据类型一旦被定义，那就不会再改变，除非进行强转。 在python中，例如：name = 'egon'，这个变量name在被赋值的那一刻，数据类型就被确定死了，是字符型，值为'egon'。
#弱类型语言：
数据类型可以被忽略的语言 比如linux中的shell中定义一个变量，是随着调用方式的不同，数据类型可随意切换的那种。
#动态语言（python属于动态语言）
运行时才进行数据类型检查 即在变量赋值时，就确定了变量的数据类型，不用事先给变量指定数据类型
#静态语言
需要事先给变量进行数据类型定义
虽然 python 不会强制强调函数的实参传值必须按照形参的数据类型，但是提供了函数的类型提示，如下：
函数的类型提示：
def register(name:"必须传入名字傻叉",age:1111111,hobbbies:"必须传入爱好元组")->"返回的是整型": #:号后面是提示信息（不会被执行）
print(name)
print(age)
print(hobbbies)
return 111
# register(1,'aaa',[1,])
# res=register('egon',18,('play','music'))
# res=register('egon',19,(1,2,3))
#查看值与类型提示信息
print(register.__annotations__) #返回值为字典形式 {'参数':'提示信息'}
结果展示：
{'name': '必须传入名字傻叉', 'age': 1111111, 'hobbbies': '必须传入爱好元组', 'return': '返回的是整型'}