9.4参数

""""""
"""1.位置参数"""

"""
# 求两个数的大小 返回大的那个

# 位置参数:在函数定义阶段按照位置从左往右依次书写的变量名 叫做函数位置形参
# 位置形参在调用的时候 必须为其传值
"""

def my_max(x,y):
    print(x,y)
    if x > y:
        return x
    else:
        return y
# res = my_max(1)  # 在调用函数的时候 少一个实参不行
# res = my_max(1,2,3)  # 在调用函数的时候 多一个实参也不行

# res = my_max(20,10)

# 位置实参:在函数的调用阶段 传入的参数会按照位置一一对应给形参
# print(res)

# 第一种直接按照位置传  一一对应

# 第二种指名道姓的传  >>>:关键字传参
# my_max(y=20,x=10)
# my_max(10,y=20)  # 位置和关键字混合使用
# my_max(20,y=40)


# my_max(20,y=40,x=30)
"""
注意:在函数的调用阶段 位置参数和关键字参数可以混合使用
但是必须保证
    1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)
    2.同一个形参不能被多次赋值
"""

"""2.默认值参数"""
"""
# 默认值参数:在函数的定义阶段,形参(变量名)就已经被赋值了
# 在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值
# 在调用的时候如果可以给默认值形参传值 传了那么就使用你传的值
# 在定义阶段 默认值形参必须放在位置形参的后面

# def my_max(x,y=100):
#     if x > y:
#         return x
#     return y
# # res = my_max(200)
# res1 = my_max(200,1000)
# res2 = my_max(y=200,x=1000)
# print(res2)

# def register(username,age,gender='male'):
#     print(username,age,gender)
# register('jason',18)
# register('tank',28)
# register('egon',84)
# register('kevin',58)
# register('xiaohou',17,'female')


# 默认值参数的应用场景
# 当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参


"""
def info(username,hobby,l=None):
    if l == None:
        l = []
    l.append(hobby)
    print('%s 的爱好是 %s'%(username,l))
info('jason','study')
info('tank','生蚝')
info('kevin','喝腰子汤')
info('egon','女教练')

# 解决方法1
info('jason','study',[])
info('tank','生蚝',[])
info('kevin','喝腰子汤',[])
info('egon','女教练',[])

# 解决方法2
# info('jason','study')
# info('tank','生蚝')
# info('kevin','喝腰子汤')
# info('egon','女教练')

"""
函数在定义阶段 内部所使用的变量都已经初始化完毕了
不会因为调用的位置的变化 而影响到内部的值(暂时可忽略)


函数无论在什么地方被调用
都会跑到函数定义阶段去执行代码
形参中用到的值都是往函数定义阶段代码往上找
"""

"""3.可变长参数"""
"""
# 可变长参数
# 站在调用函数传递实参的角度  实参的个数不固定的情况
# 也就意味形参也不固定
# 站在形参的角度 可以用*和**来接收多余的(溢出的)位置参数和关键字参数

# 站在形参的角度 看 *
# 形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名

"""
def func1(x,y,*z):
    print(x, y, z)  # z = (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)
func1(1,2,3,4,5,6,7,8,54,43,4,5,6,6,7,8,) # 1 2 (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)

# 站在实参的角度 看 *
def func2(x,y,*z):
    print(x,y,z)
# l = [1,2,3]
# a,b,c = l
# func2(a,b,c)
func2(*[1,2,3,4,5,6])  # *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6)
# func(*(1,2,3))  # 等价于func(1,2,3)
# def func(x,*z):
#     print(x,z)
# func(1,*{1,2,3})  # *在形参中只能接收多余的位置实参 不能接收关键字实参
# *只能将列表 元组 集合 字符串
# *的内部你可以看成是for循环


"""# 站在形参的角度看 **"""

def func3(x,y,**z):
    print(x,y,z)  # z = {'z': 1, 'a': 1, 'b': 2, 'c': 3}
func3(x=1,y=2,z=1,a=1,b=2,c=3)
# **会接收所有多余的关键字参数 并将关键字参数 转换成字典的形式 字典的key就是关键字的名字
# 字典的value就是关键字的名字指向的值  将字典交给**后面的变量名


# 站在实参的角度看 **
def func4(x, y, z):
    print(x, y, z)


# func4(12,3,4)
# func4(x=1,y=2,z=3)
# d = {'x':1,'y':2,'z':333}
# func(x=1,y=2,z=3)
# func(**d)  # 等价于func(x=1,y=2,z=333)
# **会将字典拆封成 key = value的形式


"""
总结 * 与 **
    *在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名
    **在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名


    *:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数
        (*就看成是for循环取值)
    **:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数
"""

# 需求 你写的函数 无论调用者按照正确传参的方式无论怎么传 你的函数都能够正常执行
# def func1(*x,**y):
#     print(x,y)
# func1(1,2,3,4,5,6,x=1,y=2,z = 3)

"""
注意python推荐形参*和**通用的写法
"""


def func_2(*args, **kwargs):
    print(args, kwargs)


func_2(1, 2, 3, 4, 5, 6, x=1, y=2, z=3)