函数的参数

1. 函数的返回值

关键字：retutn
def home():
    print(123)
    # return # 代码走到这立刻结束 
    # print('hello')
    return 1, 2, 3 # (1, 2, 3)
res = home() # 把home函数执行之后返回的结果赋值给res变量 如果没有返回值 默认返回None

"""
1. 每一个函数不是必须要有返回值的，可有可无
2. 当函数中没有return关键字，那么，函数的返回结果是什么?
3. 只有是return关键字后面的数据才是函数的返回结果
4. 一个函数中只能有一个return关键字，函数体体代码只有遇到return直接退出
5. return后面可以返回值多个值，逗号隔开，以元组的形式返回
"""

2. 函数参数的两大类（形参与实参）

形式参数：
    函数在'定义阶段'括号中定义的'变量名'就是形式参数，简称'形参'
        def index(a, b):
            pass
        
        # a,b 就是形参

实际参数：
    函数在'调用阶段'括号中写的'变量值'就是实际参数，简称'实参'
    def index(a, b):
        pass
    
    index(1, 2)
    # 1, 2就是函数的实参

"""
形参和实参的关系
        简单理解为把形参名=实参值-----------》变量名=变量值的形式来看
        形参和实参是在函数调用阶段临时绑定，函数调用结束的时候，两者断开
"""
函数传参形参其实只有一种情况：变量名
但是，实参就好几种形式：变量值、变量名、函数的返回值等，本质：变量值

3. 什么是形式参数与实际参数

位置参数：
    函数在括号中从左到右依次写入的参数就是位置参数
    def index(a, b, c):
        pass

位置形参
    在函数定义阶段括号中从左往右依次写入的变量名就是位置形参
    def index(a, b, c):
        pass 
        # a,b,c就是位置形参
        
位置实参
    在函数调用阶段括号中从左往右依次传入的变量值就是位置实参
    index(1, 2, 3) # 1, 2, 3称为是位置实参
"""位置参数的特点：形参和实参是一一对应的"""

4. 函数传参的方式有几种？

第一种位置传参：形参与实参的位置是从左往右一一对应的

def func(a,b,c):
    print(a,b,c)
func(1,2,3)

第二种传参方式：关键字传参 顺序是可以打乱的
def func(a,b,c):
    print(a,b,c)
func(c=2,a=3,b=1)

第三种： 默认参数 只能在形参中使用 如果实参中传就用实参的  不传就是默认形参 只有默认形参，没有默认实参

def func(a,b,c=4):
    print(a,b,c)
func(a=3,b=1)
func(a=3,b=1,c=5)
'''位置参数不能够放在关键字参数的前面！！！ 越短的越靠前'''

# 函数可以当做参数传值
def func():
     print('我是func')

def func1():
    print('我是func1')

def index(a, b):
    print(123)
index(func(), func1())

5. 可变长参数 * 与 **

可变长参数在形参中的使用
1. 无论我传入多少个位置参数，函数都能够正常的被调用? # 把多余的实参以元组的形式接收！

def index(x, y, m, n,  *a): # *a可以接收对与的参数
    print(x, y, m, n, a) # 运行结果 1 2 3 4 (5, 6, 7, 8, 9, 10, 11)
index(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)

2. 无论我们传入多少个关键字参数，函数都能够被正常的调用? 接收在实参中传过来的关键字实参 以字典的形式接收！

def index(x, y, q, z, **a):
    print(x, y, a) # {'m': 3, 'n': 4, 'z': 5, 'p': 6, 'q': 7}
    print(x, y, q, a)  # {'m': 3, 'n': 4, 'z': 5, 'p': 6}
index(x=1, y=2, m=3, n=4, z=5, p=6, q=7)

'''补充：
    *和和**号后面的变量名可以随便叫
    但是嫩：在Python中，推荐使用*args **kwargs
    args：arguments  位置参数
    kwargs: keywords arguments 关键字参数
    
'''

3. 无论我传入多少个位置参数和关键字参数，函数都能够被正常调用

def index(a, b, c=1, *args, **kwargs, ):
    print(args)  # (1, 2, 3, 4)
    print(kwargs)  # {'x': 10, 'y': 20, 'z': 30}

index(1, 2, 3, 4, x=10, y=20, z=30)




4. 可变长参数(*号)在实参中得使用(重要)  # 把列表或元组打散 以位置参数传传递

def func(a,b,c,e,d,*args): *args把多余的以元组的形式接收
    print(a,b,c,e,d,*args)
    
l = [11,22,33,44,55,66,77]
l1 = (11,22,33,44,55,66,77)
func(*l) # 把L打散成位置参数传递过去


5.可变长参数(**号)在实参中得使用(重要) # 形参以字典的形式接收

def index(a,b,**kwargs):
    print(a,b,kwargs)# 运行结果 5 4 {'t': 8, 's': 99, 'c': 3, 'd': 2, 'e': 1} 

dic = {'a':5,'b':4,'c':3,'d':2,'e':1}  
index(t=8,s=99,**dic) # **dic把字典打散成关键字形式传递 相当于 index（'a'=1,'b'=2,'c'=3）

""" 总结： 
1. 在形参中的作用 *args在形参中接收多余的位置实参，用元组的形式展示， 
　　**kuargs 在形参中接收多余的 关键字实参 用字典的形式展示 

2. 在实参中的作用 *在实参中可以把列表或元组内的元素拆开传传递给形参接收 如果是 *{} ，打散后只能取出K值 
　　** 在实参中 可以把字典打散成关键字参数的形式当作实参传递给形参接收

3.  形参原来接收，实参则是来传递
"""

6. 命名关键字参数

'''
命名关键字传参：在形参中会出现*的用法，如果出现在*号后面的形参，那么，实参传递的时候，必须以关键字的形式传递
'''

def register(name,age,*,sex,height,salary): #sex,height为命名关键字参数
   pass

# register('kevin', 10, 'male', 1.9)
register('kevin', 10, sex='male', height=1.9, salary=2000)

7. 函数的执行流程

第一步：
实参接收外面定义的变量
第二部：
实参再传递给形参
第三步：
函数体可以拿到在形参中的变量
第四步：
函数体代码执行完毕之后 如果有返回值 就把函数名赋值给一个变量即可