十二、 函数和函数的参数

一 函数的本质

函数相当于一个工具，具备某一个功能，在使用时直接拿来使用即可。

二 函数的语法

def my_func():
    """

    :return:
    """
    print('my_func')
    return

def：定义函数的关键字。
my_func：函数名，和变量名的命名一样。
()：函数名后面必须跟括号，括号里的参数可有可无。
冒号：括号后面跟冒号
“”“”“”：文档描述，函数功能，函数参数和返回值的一些描述信息。
函数体代码：功能代码。
return：函数返回值，可有可无。

三 函数的定义和调用

1.函数必须先定义在调用，定义函数的代码必须在调用函数的代码之前运行起来。
2.定义函数使用定义函数语法。
3.函数名就是将函数体代码的内存地址赋值之间的绑定关系。
4.函数在定义阶段只检查语法 不执行函数体代码
5.函数名加括号就可以调用。

my_func1()  # 报错 name 'my_func' is not defined


def my_func1():
    print('my func')


def my_func2():
    print('my func')


print(my_func2)  # <function my_func at 0x0000027B2554C670>
# 函数名就是函数体代码的内存地址


def my_func3():
    adsdsad
    asdasdasds
    print('my func')


print(my_func3)  # 不会报错
print(my_func3())  # 报错 name 'adsdsad' is not defined
# 函数在定义阶段不执行函数体代码 只检查语法 调用阶段才会执行函数体代码

四 函数的返回值

函数的返回值就是函数运行结束后产生的结果，获取函数返回值的方法就是用变量名接受。

def return_value():
    return  # 默认返回None


res = return_value()
print(res)  # None


def return_value1():
    return -1  # 后面跟什么就返回什么


res1 = return_value1()
print(res1)  # -1


def return_value2():
    name = 'jasper'
    return -1, name  # 返回一个元组


res2 = return_value2()
print(res2)  # (-1, 'jasper')


def return_value3():
    return [1, 2, 'jasper'] # 单个数据是什么类型就返回什么类型


res3 = return_value3()
print(res3, type(res3))  # [1, 2, 'jasper'] <class 'list'>


def return_value4():
    return [1, 2, 'jasper'], {'age': 18}  # 多个数据还是返回元组


res4 = return_value4()
print(res4, type(res4))  # ([1, 2, 'jasper'], {'age': 18}) <class 'tuple'>
print(res4[1], type(res4[1]))  # {'age': 18} <class 'dict'>

五 函数的分类

5.1 内置函数

python解释器在程序启动时就定义好的函数，可以直接加括号调用。

# 内置函数
len()
print()
exit()


# 可以直接加参数直接调用

5.2 自定义函数

自定义函数分为三种，分别是空函数，无参函数和有参函数。

# 自定义函数
# 1 空函数
def none_func():
    """
    无函数体代码 没有任何功能 用于前期项目搭建
    :return:
    """
    pass


none_func()


# 2 无参函数
def no_argument_func():
    """
    函数调用时不需要参数就可以执行该功能
    :return:
    """
    print('no_argument_func')


none_func()  # no_argument_func


# 3 有参函数
def argument_func(x):
    """
    函数调用时需要传入参数x
    :param x:
    :return:
    """
    print('argument_func is x')


argument_func(1)  # argument_func is x

六 函数的参数

学习函数参数之前我们要知道两个概念，什么是形式参数(简称形参)和什么是实际参数(简称实参)。
形参：函数定义阶段函数名后括号里的参数
实参：函数调用时括号里的参数
形参相当于变量名，实参相当于变量名对应的数据值，在函数调用阶段时，会临时进行绑定，函数执行结束就结束绑定关系，是一个动态绑定。

6.1 位置参数

6.1.1 位置形参

在函数定义阶段从左至右填写的变量名就是位置形参

6.1.2 位置实参

在函数调用阶段从左至右填写的数据值就是位置实参

# 位置形参
def form_argument(x, y):  # 位置形参
    z = x + y
    print(z)


form_argument(1, 2)  # 3 位置实参 在传值时从左至右依次赋值
form_argument()  # 报错 form_argument() missing 2 required positional arguments: 'x' and 'y'
form_argument(2)  # 报错 form_argument() missing 1 required positional argument: 'y'
form_argument(1, 2, 3)  # 报错 form_argument() takes 2 positional arguments but 3 were given
# 位置实参在传参数时,必须和位置形参个数一一对应,不能少也不能多

6.2 关键字参数

关键字实参：在调用阶段以变量名等于数据值的形式传入参数称之为关键字实参

# 关键字实参
def key_argument(x, y):
    z = x * y
    print(z)


key_argument(x=4, y=6)  # 24
key_argument(x=6, y=4)  # 24 都是关键字实参与位置没有关系

key_argument(y=6, 1)  # 报错 positional argument follows keyword argument
# 位置实参不能跟在关键字实参后边

key_argument(1, y=6)  # 6 可以位置实参在前 关键字实参在后

key_argument(1, x=2)  # 报错 key_argument() got multiple values for argument 'x'
# 形参x获得了多个值

key_argument(y=6, 4)  # 报错 positional argument follows keyword argument
# 位置参数跟在了关键字参数后边

6.3 默认值参数

在函数定义参数阶段，以变量名等于数据值的形式写入的就是默认值参数。

# 默认值参数
# 打印员工信息功能
def staff_info(name, age, gender):
    print(f"""
    **********info**********
    name:{name}
    age:{age}
    gender:{gender}
    ************************
    """)


staff_info('Jasper', 18, 'male')
staff_info('Tom', 28, 'male')
staff_info('Jack', 19, 'male')


def staff_info(name, age, gender='male'):
    print(f"""
    **********info**********
    name:{name}
    age:{age}
    gender:{gender}
    ************************
    """)


staff_info('Jasper', 18, 'male')
staff_info('Tom', 28, 'male')
staff_info('Jack', 19, 'male')  # 加上默认形参以后 可以不写 打印结果一致
staff_info('lili', 18, gender='female')  # 可以修改默认值形参 

6.4 可变长参数

打破实参与形参之间一一对应的关系 随意的传值

6.4.1 *args

接受多余的位置实参放在*后的变量名args中，以元组的形式存储多余的位置实参

6.4.2 **kwargs

接受多余的关键字实参放在**后的变量名kwargs中，以字典的形式存放多余的关键字实参

# 可变长参数
def variable_len_argument(*args, **kwargs):
    print(args, kwargs)


variable_len_argument()  # () {}
variable_len_argument(1, 2, 3)  # (1,2,3) {}
variable_len_argument(name='jasper', age=18)  # () {'name': 'jasper', 'age': 18}
variable_len_argument(1, name='jasper')  # (1,) {'name': 'jasper'}

总结：定义函数阶段，不同参数之间的混合使用，位置参数不能在默认值后边，简单的在前复杂的在后。

七 参数补充

7.1 * 和 ** 在实参中的作用

# 假如有一个列表 需要把列表里的所有元素当作参数传入 应该怎么做
my_list = [1, 2, 3, 4, 5]


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


# 方式一
func(my_list[0], my_list[1], my_list[2], my_list[3], my_list[4])
# (1, 2, 3, 4, 5)
# {}
# 索引取值可以解决此需求 但是写死了 如果列表数据修改则函数参数也许修改

# 方式二
func(*my_list)
# (1, 2, 3, 4, 5)
# {}
# 结果是一样的 但是列表数据修改不会影响实参的变化


# 定义一个字典
my_dict = {
    'name': 'jasper',
    'age': 18
}
func(**my_dict)
# ()
# {'name': 'jasper', 'age': 18}
# **的作用是将字典的k，v键值对以变量名等于数据值的形式当作实参传入

总结：*相当于将字符串、列表、元组、集合for循环的每个值一次性放到实参中，**就是把字典中的k，v键值对以变量名等于数据值的形式放到实参中。

7.2 命名关键字参数

def func(a, b, c):
    print(a, b, c)


# 如果要让c必须使用关键字实参的形式传入
def func1(a, b, *args, c):
    print(a, b, args, c)


# func1(1, 2, 3)  # 报错 func1() missing 1 required keyword-only argument: 'c'

func1(1, 2, 3, 4, c=666)  # 1 2 (3, 4) 666


# 完整版本
def func3(a, b, *args, c, d, **kwargs):
    print(a, b, args, c, d, kwargs)

在定义函数阶段，写在*后面的参数必须以关键字实参的形式传入，而且这个参数必须在**前面。