2021-9-28

函数的定义、函数的调用、函数的返回值（2021-9-28）

匿名函数、变量作用域

高阶函数（实参高阶函数、装饰器）

一、调用函数（使用机器）

1、定义函数的时候不会执行函数体，调用函数的时候才会执行函数体（重要）

2、调用函数

语法：函数名(实参列表)
说明：
a、函数名 - 需要使用的函数的名字。（函数名必须是已经定义过的函数的函数名）
b、() - 固定写法
c、实参列表 - 多个数据用逗号隔开：数据1, 数据2, 数据3, …
原则上定义函数的时候有多少个形参，调用函数就需要多少个实参

3、函数调用过程

当代码执行到函数调用表达式的时候：
第一步：回到函数定义的位置，用实参给形参赋值
第二步：执行函数体
第三步：确定函数返回值
第四步：回到函数调用的位置，接着往后执行

a、调用函数会执行函数体（调用多少次就执行多少次）

def str1():
    print('====')
    print('++++++')
str1()                              # ====

                                    # ++++++

b、

def str1():
    pass
str1()
str1(10)                          # TypeError: str1() takes 0 positional arguments but 1 was given
def str1(x):
    pass
str1()                            # TypeError: str1() missing 1 required positional argument: 'x'
str1(10)
str1(10, 20)                      # TypeError: str1() takes 1 positional argument but 2 were given

c、每个实参可以是任何有结果的表达式

def funk1(x):
    print(x * 2)
funk1(10 + 20)                      # 60
str1 = 'hello'
funk1(str1[1:])                     # elloello

二、返回值

m = 200
n = 200
def funk1():
    print(m, n)
funk1()

1、返回值 - 将函数内部的数据传递到函数外部

1）怎样将一个数据作为函数的返回值

语法：
return 需要返回的数据（需要从函数内部传递到函数外部的数据），如果有多个数据则用逗号隔开

2）怎样在函数外部获取函数的返回值

获取函数调用表达式的值，就是获取函数的返回值。（函数调用表达式的值就是函数的返回值）
返回值能做的事情，函数调用表达式都可以做

def sum1(num1, num2):
    return num1 + num2        # return 30
num1 = 10
num2 = 20
print(sum1(num1, num2))       # 30
a =20
b = sum1(num1, num2)
print(a + b)                  # 50

练习：执行以下代码后控制台的打印结果是？

def funk(x, y):
    # x = [10, 20] , y = [30]
​    x.append(y*2)             # x = [10, 20, 30*2]
​    return x                  # return [10, 20, 30*2]
list1 = [funk([10, 20], 30), 'abc']    # list1 = [[10, 20, 60], 'abc']
print(list1[0][-1])           # 60

三、return关键字

return的两个作用：

1）确定函数返回值（将函数内部的数据传递到函数外部）

2）提前结束函数（在执行函数体的时候，如果遇到了return，那么函数直接结束）

def funk1():
    print('==========')
    return
    print('++++++++++')
    print('----------')
result = funk1()
print(result)
def download(state):
    if not state:
        return '无网络'
    print('连接服务器，下载数据')
A = download(False)
print(A)                               # 无网络
def odevity(num):
    if num % 2:
        return '奇数'
    return '偶数'
num = 4
a = odevity(num)
print(a)                               # 偶数

四、函数的参数

1、位置参数和关键字参数 - 根据实参提供的方式分的类

1）位置参数 - 直接将多个数据用逗号隔开，让实参和形参从位置上一一对应（第一个实参给第一个形参赋值…）

2）关键字参数 - 以’形参=实参’的形式传参

3）位置参数和关键字参数混用 - 位置参数必须在关键字参数前面

位置参数

def funk1(x, y, z):
    print( f'x:{x}, y:{y}, z:{z}')
funk1(10, 20, 30)                              # x:10, y:20, z:30
关键字参数
funk1(x = 10, z = 30, y = 20, )                # x:10, y:20, z:30
混用
funk1(10, 20, z=30)                            # x:10, y:20, z:30

2、参数默认值

定义函数的时候可以通过’形参=数据’给参数赋默认值，调用函数的时候有默认值的函数可以不用传参
定义函数的时候可以只给部分参数赋默认值，那么这个时候没有默认值的参数必须在有默认值参数的前面

def funck1(x=10, y=20, z=30):
    print(f'x:{x}, y:{y}, z:{z}')
funck1()
funck1(100)                                    # x:100, y:20, z:30
funck1(100, y=200)                             # x:100, y:200, z:30
def funck2(x, y, z = 30):
    print(f'x:{x}, y:{y}, z:{z}')
funck2(10, 20)

3、参数类型说明和返回值类型说明

参数类型说明：1）无默认值参数：类型名
2）参数赋默认值
返回值类型说明：

def func4(x:str, y='') -> list:
    list1 = [x,y]
    return list1
a = func4('adf', 'dwf')
print(a)

4、（了解）不定长参数 - 一个形参可以同时接收多个实参

1）在参数名前加*，那么这个参数就可以同时接收多个实参（必须是位置参数）

原理：带的参数会变成一个元组，接收到的实参会变成元组中的元素
注意：带的不定长参数在传参的时候只能用位置参数
（重！）重要结论：定义函数的时候，如果参数中有一个独立的*，它的作用是让你在调用这个函数的时候*后面的参数必须用关键字参数传参

2）在参数名前加**，那么这个参数就可以同时接收多个实参（必须是关键字参数）

原理：带**的参数会变成一个字典，接收到的实参会变成字典中的键值对

1）*
def sum1(*x):
    sum2 = sum(x)
    print(sum2)
sum1(20,4,546,645)
def sum1(*x):
    print(f'x:{x}')
sum1()                      # x:()
sum1(10)                    # x:(10)
sum1(10, 20)                # x:(10, 20)
def sum1(y, z, *x):
    print(f'x:{x}, y:{y}, z:{z}')
sum1(10,20)                 # x:(), y:10, z:20
sum1(10,20,30,40)           # x:(30, 40), y:10, z:20
结论：如果定长参数在*

对应的不定长参数的后面，定长参数在传参的时候必须使用关键字参数

def sum1(*x, y, z):
    print(f'x:{x}, y:{y}, z:{z}')
sum1(10,20,30,y=40,z=50)    # x:(10, 20, 30), y:40, z:50

def sum1(x, *y, z):
    print(f'x:{x}, y:{y}, z:{z}')
sum1(10,z=50)               # x:10, y:(), z:50

def sum1(x, *, y):
    print(f'x:{x}, y:{y}')
sum1(10, y= 20)             # x:10, y:20
2）**
def func1(**x):
    print(x)
func1()                     # {}
func1(x=10, y=20, z=30)     # {'x': 10, 'y': 20, 'z': 30}