函数

今天学习的内容有函数，有返回值和参数，其中参数的内容包括位置参数、默认值参数、可变长参数。

什么是函数？函数就是具有某个具体功能的工具
为什么要用函数？提供开发效率、减少代码冗余、提高程序的扩展性

函数有内置函数和自定义函数，内置函数是系统中已经定义好的如常用的len()等，自定义函数使我们自己设定的。

定义一个函数
def是定义函数的关键字
函数名:函数名的命名规则与变量名一致
1.不能以关键字(******)
2.函数也应该做到见名知意

def func():
print('hello')

调用函数的固定格式：
函数名+括号
函数名只要遇到括号会立即执行函数体代码
代码中遇到函数名加括号 优先级最高
先去执行函数 再看下面的代码

函数在定义的时候只检测函数体语法 不执行函数体代码

函数必须先定义后调用，定义了的函数可以在任意位置调用

函数的返回值

函数内要想返回给调用者值 必须用关键字return

返回值还分为以下几种情况

#不写return:函数默认返回None
def func():
    print('hahaha')
res = func()
print(res)

#只写return:return除了可以返回值之外 还可以直接结束整个函数的运行，只写return的结果是返回的也是None(None就表示什么都没有)
def func():
    l = ['jason','egon','tank']
    while True:
        for i in l:
            if i == 'egon':  # 当i为egon的时候 直接结束函数运行
                return
                # print('asdasdkljlsjadl')  # 这一行代码拥有都不会运行
            print(i)
res = func()
print(res)

#写return None:跟上面的只写return是一样的
def func():
    return None
res = func()
print(res)

#写return返回一个值:这个值可以是python任意数据类型
def func():
    return '123'
def func1():
    return [1,2,3]
def func2():
    return {'name':'jason'}
def func3():
    return (1,)
def func4():
    return {1,2,3,4,5}
def func5():
    return True
print(func(),func1(),func2(),func3(),func4(),func5())

# 写return返回多个值:return会自动将多个值以元组的形式返回给调用者
def func():
    return 1,2,3,4  # 返回的是(1, 2, 3, 4)
# res = func()
# print(res)

def func1():
    return 'a','b','c'  # ('a', 'b', 'c')
res = func1()
print(res)
def func2():
    return [1,2,3],[1,2,3],[1,2,3]  # ([1, 2, 3], [1, 2, 3], [1, 2, 3])
res1 = func2()
print(res1)
def func3():
    return {'name':'jason'},{'username':'tank'},{'user_name':'egon'}  # ({'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'})
res2 = func3()
print(res2)

# 返回多个值 并且不想让return帮你做处理  自己手动加上你想返回的数据类型符号
def func4():
    return [[1,2,3,4],[1,2,3,4],[1,2,34]]
res = func4()
print(res)

#返回多个值用多个变量接收
def ret_demo2():
    return 1,['a','b'],3,4
a,b,c,d = ret_demo2()
print(a,b,c,d)

函数的参数

函数参数的两大类型
　　形参:在函数的定义阶段 括号内写的变量名 叫做该函数的形式参数 简称 形参
　　实参:在函数的调用阶段 括号内实际传入的值 叫做实际参数 简称 实参

形参与实参的关系
　　形参就相当于变量名,而实参就相当于变量的值
　　函数调用传参的过程 就是给形参变量名赋值的过程

注意:形参和实参的绑定关系只在函数的调用阶段有效,函数运行结束关系自动解除
只在函数内部有效 函数外部无任何影响

函数的简易结构
def 函数名(形参1,形参2...):
'''函数的注释 用来描述该函数的作用以及各个形参的类型'''
函数体代码1
函数体代码2
...
return 函数的返回值

def func(x,y):

    """
    该函数的作用
    :param x: 对形参x的解释
    :param y: 对形参y的解释
    :return: 对函数返回值的解释
    """
    print('hahaha')
    return 'heihei'

写一个比大小的程序，返回值为大的数
def my_max(x,y):
    print(x,y)
    if x > y:
        return x
    else:
        return y

在这里，函数体重的两个参数分别为x,y

位置参数:在函数定义阶段按照位置从左往右依次书写的变量名,叫做函数位置形参位置形参在调用的时候,必须为其传值.在函数的调用阶段 传入的参数会按照位置一一对应给形参.

在调用函数的时候少一个实参和多一个实参都不行。

两种传参的方法：

第一种直接按照位置传  一一对应
def my_max(x,y):
    print(x,y)
    if x > y:
        return x
    else:
        return y
res=my_max(10,20)
第二种指名道姓的传  >>>:关键字传参
def my_max(x,y):
    print(x,y)
    if x > y:
        return x
    else:
        return y
res=my_max(y=10,x=20)
关键字和位置混合使用
1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)
2.同一个形参不能被多次赋值

默认值参数

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

def my_max(x,y=100):
    if x > y:
        return x
    return y
res = my_max(200)  # y有默认参数的时可以只给x输入值
res1 = my_max(200,1000)  # y有默认参数的时候也可以给它输入值
res2 = my_max(y=200,x=1000)  # y有默认参数时可以通过关键字传参给他传
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 func(x,y,*z):
    print(x,y,z)  # z = (3, 4, 5, 6, 7, 8)
func(1,2,3,4,5,6,7,8)

#站在实参的角度 看 *
def func(x,y,z):
    print(x,y,z) 
func(*(1,2,3))  # # 调用函数输出的结果1 2 3

def func(x,*z):
    print(x,z)
func(1,*{1,2,3})  # 调用函数输出的结果是 1 (1, 2, 3)  
#*在形参中只能接收多余的位置实参 不能接收关键字实参
#*只能将列表 元组 集合 字符串
#*的内部你可以看成是for循环

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

# 站在实参的角度看 **
def func(x,y,z):
    print(x,y,z)
d = {'x':1,'y':2,'z':333}
func(**d)  # 等价于func(x=1,y=2,z=333)
# **会将字典拆封成 key = value的形式

总结 * 与 **
*在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名
**在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名
*:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数
(*就看成是for循环取值)
**:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数

补充内容：
# 需求 你写的函数 无论调用者按照正确传参的方式无论怎么传 你的函数都能够正常执行
def func2(*args,**kwargs):
    print(args,kwargs)
func2(1,2,3,4,5,6,x=1,y=2,z = 3)  # >>>(1, 2, 3, 4, 5, 6) {'x': 1, 'y': 2, 'z': 3}