函数的参数

函数的参数

形式参数
	在函数定义阶段括号内填写的参数 简称'形参'
实际参数
	在函数调用阶段括号内填写的参数 简称'实参'
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
"""
形参与实参的关系
	形参类似于变量名 在函数定义阶段可以随便写 最好见名知意
	def register(name,pwd):
		pass
	
	实参类似于数据值 在函数调用阶段与形参临时绑定 函数运行结束立刻断开
	register('jason',123)   形参name与jason绑定 形参pwd与123绑定
"""

函数参数值位置参数

"""
补充:当子代码只有一行并且很简单的情况下 可以直接在冒号后编写 不用换行
"""
位置形参
	函数定义阶段括号内从左往右依次填写的变量名
    def func1(a,b,c):pass
位置实参
	函数调用阶段括号内从左往右依次填写的数据值
    func1(1, 2, 3)

def func1(a, b):
    print(a, b)

func1(1, 2)  # 按照位置意义对应传值
func1(1)  # 少一个不行
func(1, 2, 3)  # 多一个也不行
func1(b=1, a=2)  # 关键字传参(指名道姓的传)
func1(b=1, 2)  # 关键字传参一定要跟在位置传参的后面  报错
func1(2, b=1)  # 可以
func1(1. a=2, b=3)  # 同一个形参在调用的时候不能多次复制
name = 'guts'
pwd = 123
func1(name, pwd)  # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
func1(a=name, b=pwd)  # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
"""
越短的越简单的越靠前
越长的越复杂的越靠后
但是遇到下列的情况除外
    同一个形参在调用的时候不能多次赋值
"""

默认参数

本质其实就是关键字形参(关键字实参上述内容已经讲了)
	别名叫默认参数:提前就已经给了 用户可以不传 也可以传
'''默认参数的定义也遵循短的简单的靠前 长的复杂的靠后'''
def register(name, age, gender='male'):
    print(f"""
    --------学员信息----------
    姓名:{name}
    年龄:{age}
    性别:{gender}
    -------------------------
    """)
register('jason', 18)
register('kevin', 28)
register('1111', 28, 'famale')
register('1111', 28, gender='famale')

register('jason', 18, 'male')
register('tony', 28, 'male')
register('kevin', 38, 'male')

可变长形参

def func1(*a)
	print(a)
func1()  # ()
func1(1)  # (1,)
func1(1,2)  # (1, 2)

def func2(b, *a):
	print(a, b)
func2()  # 函数至少需要一个参数给到b
func2(1)  # () 1
func2(1, 2, 3, 4)  # (2, 3, 4) 1
"""
*号在形参中
    用于接收多余的位置参数 组织成元组赋值给*号后面的变量名
"""

def func3(**k):
    print(k)
func3()  # {}
func3(a=1)  # {'a': 1}
func3(a=1, b=2, c=3)  # {'a': 1, 'b': 2, 'c': 3}

def func4(a, **k):
    print(a, k)
    

func4()  # 函数至少需要一个参数给到a
func4(a=1)  # 1 {}
func4(a=1, b=2, c=3)  # 1 {'b': 2, 'c': 3}
func4(a=1, b=2, c=3, x='jason', y='guts')  # 1 {'b': 2, 'c': 3, 'x': 'jason', 'y': 'kevin'}
"""
**号在形参中
    用于接收多余的关键字参数 组织成字典的形式赋值给**号后面的变量名
"""


def func5(*a, **k):
    print(a,k)
func5()  # () {}
func5(1, 2, 3)  # (1, 2, 3) {}
func5(a=1, b=2, c=3)  # () {'a': 1, 'b': 2, 'c': 3}
func5(1, 2, 3, a=1, b=2, c=3)  # (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}


def func5(n, *a, **k):
    print(a, k)
    

func5()  # 函数知晓需要一个参数给到n
func5(1, 2, 3)  # (2,3) {}
func5(111, a=1, b=2, c=3) # () {'a': 1, 'b': 2, 'c': 3}
func5(n=111,a=1, b=2, c=3)  # () {'a': 1, 'b': 2, 'c': 3}
func5(a=1, b=2, c=3, n=111)  # () {'a': 1, 'b': 2, 'c': 3}
func5(1, 2, 3, a=1, b=2, c=3)  # (2, 3) {'a': 1, 'b': 2, 'c': 3}

"""
由于*和**在函数的形参中使用频率很高 后面跟的变量名推荐使用
    *args
    **kwargs
def index(*args,**kwargs):pass
"""

可变长实参

def index(a, b, c):
    print(a, b, c)
l1 = [11, 22, 33]
t1 = (33, 22, 11)
s1 = 'tom'
se = {123, 321, 222}
d1 = {'username': 'guts', 'pwd': 123, 'age': 22}
'''将列表中三个数据值取出来传给函数的三个形参'''
index(l1[0], l1[1], l1[2])
index(*l1)  # index(11, 22, 33)
index(*t1)  # index(33, 22, 11)
index(*s1)  # index('t', 'o', 'm')
index(*se)  # index(321 123 222)
idnex(*d1)  # index('username','pwd','age')
"""
*在实参中
    类似于for循环 将所有循环遍历出来的数据按照位置参数一次性传给函数
"""

def index(username, pwd, age):
    print(username, pwd, age)
d1 = {'username': 'jason', 'pwd': 123, 'age': 18}
index(username=d1.get('username'), pwd=d1.get('pwd'), age=d1.get('age'))
index(**d1)  # index(username='jason',pwd=123,age=18)
"""
**在实参中
    将字典打散成关键字参数的形式传递给函数
"""
def index(*args, **kwargs):
    print(args)  # (11, 22, 33, 44)
    print(kwargs)  # {}

index(*[11, 22, 33, 44])  # (11, 22, 33, 44) {}
index(*(11, 22, 33, 44))  # (11, 22, 33, 44) {}

命名关键字参数(了解)

'''形参必须按照关键字参数传值>>>:命名关键字参数'''


def index(name, *args, gender='male', **kwargs):
    print(name, args, gender, kwargs)

# index('jason',1,2,3,4,a=1,b=2)
index('jason', 1, 2, 3, 4, 'female', b=2)