Python入门之函数的形式参数与实参/参数的具体使用方法
本篇目录：
一、 函数参数之形式参数与实参
二、 函数参数的具体使用
#1、位置参数：按照从左到右的顺序定义的参数 位置形参：必选参数 位置实参：按照位置给形参传值 #2、关键字参数：按照key=value的形式定义的实参 无需按照位置为形参传值 注意的问题： 1. 关键字实参必须在位置实参右面 2. 对同一个形参不能重复传值 #3、默认参数：形参在定义时就已经为其赋值 可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参） 注意的问题： 1. 只在定义时赋值一次 2. 默认参数的定义应该在位置形参右面 3. 默认参数通常应该定义成不可变类型 #4、可变长参数： 可变长指的是实参值的个数不固定 而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs #5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递 ！
==========================================================================
一、函数的形式参数和实参
# x，y就是形式参数 def func(x,y): pass
2. 实际参数：调用函数是，括号内由外部调用者传入的值，其实就是变量值，
# 10,11就是实参 func(10,11)
''' 注意点 实参值（变量的值）和形参（变量名）的绑定关系只有在函数调用时才会生效 函数调用结束后，就会失效，解除绑定，释放资源 '''
二、 函数参数的具体使用
1.位置参数
1.1 位置参数，位置即顺序，位置参数就是按照从左到右的顺序依次定义的参数
1.2 在定义函数阶段，按照位置定义的形式参数，称为位置形参
def foo(x,y,z): print(x,y,z)
# 位置形参必须为其传值，有几个形参，必须传入几个值
1.3 在调用函数的阶段，按照位置定义的实参，被称位置实参
#1,2,3都是位置实参 foo(1,2,3) ........
2. 关键字参数（属于位置实参）
2.1 在调用函数的时候，按照key=value的形式定义的实参，称为关键字参数
a. 相当于指名道姓的为形参传值，意味着不按照顺序定义，礽可以为参数传值
foo(1,2,3)
foo(y=2,x=1,z=3)
b. 调用函数时，位置实参与关键字可以混合使用，但是必须满足传值的要求
# 必须遵循形参的规则 foo(x,y,z) foo(1,z=3,y=2)
# 不能为同一个形惨重复传值 foo(x,y,z) foo(1,x=1,z=3,y=2)
3. 默认参数
3.1 在函数定义阶段，已经为某个形参赋值，该形参被称为默认参数
# 注意在函数定义阶段已经有值，意味着调用阶段可以不用传值 # 如果传值，那就覆盖默认参数 def register(name, age, gender='male'): print(name, age, gender) register('Archer, 20) register('Bob, 22) register('Carol‘, 27，'Female')
# 对于经常需要变化的值，需要将对应的形参定义为位置形参 # 对于大多数情况下，值都一样，可以将对应的形参定义为默认参数
3.2 位置形参必须在默认参数前面
# 错误参数放置 def func（y=1,x）: pass #正确参数放置 def func(x, y=1): pass
3.3 默认参数的值只在定义阶段赋值一次，也就是说默认参数的值在定义阶段就被固定
# 函数定义阶段 m=10 def foo(x,y=m): print(x,y) #函数调用阶段(即使这时候m变为11，但是函数调用后还是打印 1,10) m=11 foo(1)
# 以上的打印结果 1 10 # 不会是 1 11
3.4 默认参数的值应该设置为不可变类型
def register(name, hobboy, l=[]): l.append(hobby) print(name, l) register('Archor', 'reading') register('Alen','running') register('Bob','playing')
#以上的打印结果 Archor reading Alen reading running Bob reading running playing # 不是很奇怪吗？我们要分别打印出姓名+爱好，但是结果来看，爱好被堆积起来传递下去了 # 这是因为默认参数的值我们定义为了一个空列表，列表是个可变类型（可以改变里面的值，列表的内存地址不变，这是可变类型的特点）
# 如果默认参数被传值的话，就会覆盖原值，可以通过每次都覆盖的方式来改进上面的程序 def register(name, hobby, l=[]) l.append(hobby) print(name,l) # 这里我们自带了空列表来覆盖每次产生的新值 register('Archor', 'reading', []) register('Alen', 'running', []) register('Bob', 'playing', [])
#以上的打印结果 Archor reading Alen running Bob playing
# 当然我们也可以通过把默认参数直接设置为None来改进 def register(name, hobby,l=None): if l is None: l=[] l.append(hobby) print(name,l) register('Archor', 'reading') register('Alen', 'running') register('Bob', 'playing') register('Archor', 'reading', []) register('Alen', 'running', []) register('Bob', 'playing', [])
# 上面的输出结果为 Archor ['reading'] Alen ['running'] Bob ['playing'] Archor [] Alen [] Bob [] #这里请多加对比思考
4. 可变长度类型的实参（*args, **kwargs）
4.1 实参的个数可以不固定
a. 按照位置定义的实参
b. 按照关键字定义的实参
4.2 (*args)可以将溢出位置的实参全部接收，然后保存成元组的形式返回给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,)
4.3 (**kwargs)可以将溢出位置的实参全部接收，然后保存成字典的形式返回给kwargs
def foo(x,y,z,**kwargs): 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｝
4.4 如果遇到实参带*，那么就需要拆分该实参
def foo(x,y,z,*args): print(x,y,z) print(args) foo(*[1,2,3]) foo(*(1,2,3))
foo(1,2,3,*{'a':1,'b':2})
foo(1,2,3,*'canshu')
# 以上的输出结果 1 2 3 () 1 2 3 () 1 2 3 ('a', 'b') 1 2 3 ('c', 'a', 'n', 's', 'h', 'u')
4.5 如果遇到实参带**，那么就需要拆分该实参
===========**kwargs===========
def foo(x,y,**kwargs):
print(x,y)
print(kwargs)
foo(1,y=2,a=1,b=2,c=3)
def foo(x,y,**kwargs):
print(x,y)
print(kwargs)
foo(1,y=2,**{'a':1,'b':2,'c':3})
def foo(x,y,z):
print(x,y,z)
foo(**{'z':1,'x':2,'y':3})
===========*args+**kwargs===========
def foo(x,y):
print(x,y)
def wrapper(*args,**kwargs):
print('====>')
foo(*args,**kwargs)
