一、复习

1.函数的概念

函数是实现某一特定功能的代码段的封装

2.函数的声明（定义）

def 函数名(形参列表)
函数体

形参：可以看成是声明在函数中的变量；作用是将函数外部的数据传递到函数的内部。
函数体：a.函数说明文档；b.实现函数功能的代码段；c.return 语句（确定返回值，然后返回）

注意：声明函数的时候，不会执行函数体。（重点。。。。。）

3.函数的调用

函数名(实参列表)

注意：函数调用的过程：
a.回到函数声明的位置
b.传参（用实参给形参赋值），保证每个参数都有值
c.执行函数体
d.结束后，确定返回值，自然死亡或者遇到 return
e.返回函数调用的位置，这个时候函数调用表达式的值才是之前确定的返回值。
（重点。。。。。）

4.函数的参数：

位置参数和关键字参数（关键字参数要放在位置参数的后面）
参数的默认值（有默认值的参数要放在没有默认值的参数的后面）
参数类型说明
不定长参数：形参前加 *（把形参变成元组）；或 **（将形参变成字典）；
带 * 的参数要放在不带 * 的后面；带 ** 的要放在带 * 的后面。

5.函数的返回值（将函数内部的数据传递到函数的外面）

a.怎么确定函数的返回值

（就看执行函数的时候，会不会遇到 return ，遇到了，返回值就是 return 后面的东西；
没有遇到，返回值就是 None）

b.怎么获取函数的返回值

（通过获取函数调用表达式的值来获取返回值；）

普通数据能做的事情返回值都能做。

注意：每次调用函数，都会重新获取返回值。

二、匿名函数

1.什么是匿名函数

匿名函数还是函数，只是声明的格式和普通函数不一样。
只使用于函数功能比较简单的函数

def 函数名(形参列表):
函数体

2.匿名函数的声明

a.语法：

变量名 = lambda 形参列表:返回值

b.说明：

变量名 -----相当于函数名
= -----固定写法
lambda -----声明匿名函数的关键字
形参列表 -----和普通函数的形参列表要求一样
: -----固定写法
返回值 -----就相当于普通函数中只有一条 return 语句的函数体

3.匿名函数的调用：

匿名函数和普通函数的调用方法一样
例如：

func1 = lambda x, y=0: print('两个数的和为：', x + y)
func1(50, 60)

运行结果：

两个数的和为： 110

注意：

1.匿名函数的参数也可以设置默认值
1.匿名函数不能通过添加:类型名来说明参数类型
3.匿名函数可以设置不定长参数
例如：

# 这个普通函数和上面的匿名函数 func1 一模一样
def func2(x, y=0):
    print('两个数的和为：', x + y)


func2(60, 70)

func3 = lambda *nums: print(sum(nums))
func3(1, 2, 3, 4, 5)

func4 = lambda x: print(x)
print(func4(100))               # None


# 与上面的 func4 一样
def func5(x):
    print(x)

运行结果：

两个数的和为： 130
15
100
None

三、变量的作用域

1.什么是作用域：

就是变量能够使用的范围

2.全局变量和局部变量

a.全局变量：没有声明在函数中或者类中的变量都是全局变量

全局变量的作用域：从声明开始到整个文件结束，都可以使用。

b.局部变量：声明在函数中或者类中的变量就是局部变量

局部变量的作用域：从声明开始，只在类或函数结束为止可以用。

总结：当我们调用函数的时候，系统会自动在栈区间专门为这个函数开辟一块独立的内容空间，
用来保存在函数中声明的变量（形参也是属于声明在函数中的变量）。当函数调用结束后，
这个函数对应的栈区间会自动销毁（函数调用的过程是一个压栈的过程）。

如果全局变量和局部变量同名，那么在局部变量的作用域中，使用的是局部变量，作用域之外使用的是全局变量
全局变量1：
变量a 就是全局变量
例如：

a = 1
print(a)
for i in range(5):
    print('循环里：', a)


def func1():
    print('函数中：', a)


func1()

运行结果：

1
循环里： 1
循环里： 1
循环里： 1
循环里： 1
循环里： 1
函数中： 1

全局变量2：

for x in range(5):
    print(x)

print('外面：', x)


def func():
    print('函数里', x)


func2()

运行结果：

0
1
2
3
4
外面： 4
函数里 4

局部变量：
函数的形参是声明在函数中的变量，所以是局部变量

ef func3(num1):
    print(num1)
    for x in range(3):
        print(num1)


func3(3)
# print(num1)             # 局部变量不能在函数外使用

运行结果：

3
3
3
3

3.在局部变量作用域里修改全局变量：

a.global -----在局部变量里修改全局变量的值（只能在函数里面使用）

                            若在全局变量里没有这个变量，就在全局变量里新建那个声明的变量。

在函数中：
global 变量名
变量名 = 值
例如：

bl1 = 123


def func4():
    global bl1
    bl1 = 'adc'
    print('函数里：', bl1)
    global bl2
    bl2 = 456


func4()
print('外面：', bl1)
print('外面：', bl2)  # 要先在运行一遍函数，声明了 bl2 ，此变量才能使用。

运行结果：

函数里： adc
外面： adc
外面： 456

b.nonlocal -----在局部的局部变量里改变局部变量的值（只能在函数里面使用）

例如：

def func5():
    abc = 123
    print('func5:', abc)

    def func6():
        print('func6:', abc)
    func6()

    def func7():
        nonlocal abc
        abc = 456
    func7()
    print('func5:', abc)


func5()

list1 = []
for i in range(5):
    list1.append(lambda x: x * i)

print(list1[0](3))
print(list1[3](2))

list2 = [lambda x: x * 2]
print(list2[0](100))

运行结果：

func5: 123
func6: 123
func5: 456
12
8
200

四、函数作为变量

python中声明函数，其实就是声明一个类型为 function 的变量，函数名就是变量。

函数名 -----类型为 function 的变量
函数名() -----调用函数并且获取函数的返回值
普通变量能做的事，函数名都能做。

1.给别的变量赋值：

例如：

# 声明一个列表变量list1
list1 = [1, 2, 3]


# 声明一个函数变量func1
def func1():
    return 10


# 用列表名给另外一个列表 list2 赋值
list2 = list1
print(list2[0])
print(list2[::-1])
list2.append(20)
print(list2)

# 用函数名给另外一个变量 func2 赋值
func2 = func1
func2()
print(func2())

运行结果：

1
[3, 2, 1]
[1, 2, 3, 20]
10

2.变量作为容器类数据的元素

例如：

a = 1
nums = [a, 2, 3]
print(nums)
print(nums[a] - 2)


def func3(x):
    print('adc', x)
    return 10


list3 = [func3, func3(10), 20]
print(list3)
print(list3[0](1))

运行结果：

[1, 2, 3]
0
adc 10
[<function func3 at 0x00000269B10CD7B8>, 10, 20]
adc 1
10

3.变量作为函数的实参

函数1 作为 函数2 的实参 -----函数2 就是一个高阶函数
函数作为参数的应用：sort 函数
列表.sort(key=None, reverse=False)
参数key -----要求是一个带有一个参数，并且返回值是布尔的函数。这里的参数指向的是lb中的元素，
确定按照元素的什么值进行排序。
例如：

list1 = [1, 2, 3]
# list.sort(reverse=True)
print(list1)

all_student = [
    {'name': '阿黄', 'age': '3', 'sex': '公'},
    {'name': '阿绿', 'age': '4', 'sex': '公'},
    {'name': '阿蓝', 'age': '5', 'sex': '公'},
    {'name': '阿红', 'age': '1', 'sex': '公'}
]


def func4(item):
    return item['age']


all_student.sort(key=func4)
print(all_student)
all_student.sort(key=lambda i: i['age'], reverse=True)
print(all_student)

运行结果：

[1, 2, 3]
[{'name': '阿红', 'age': '1', 'sex': '公'}, {'name': '阿黄', 'age': '3', 'sex': '公'}, {'name': '阿绿', 'age': '4', 'sex': '公'}, {'name': '阿蓝', 'age': '5', 'sex': '公'}]
[{'name': '阿蓝', 'age': '5', 'sex': '公'}, {'name': '阿绿', 'age': '4', 'sex': '公'}, {'name': '阿黄', 'age': '3', 'sex': '公'}, {'name': '阿红', 'age': '1', 'sex': '公'}]

4.变量作为函数的返回值

函数1 作为 函数2 的返回值 -----函数2 是返回值高阶函数
例如：

def operation(char):
    if char == '+':
        def func5(*nums):
            return sum(nums)
        return func5
    elif char == '-':
        def func6(*nums):
            if not nums:
                return 0
            sum1 = nums[0] * 2
            for i in nums:
                sum1 -= i
            return sum1
        return func6


print(operation('+')(1, 2, 3, 4, 5))
print(operation('-')(1, 2, 3, 4, 5))

运行结果：

15
-13