第四章 Python函数使用 08-匿名函数与闭包

匿名函数

函数作为参数传递

之前学习函数中提供的形参的定义，可以接收数据传入到函数中进行使用，其实学习函数的本身，也可以作为参数传入另一个函数内

def test_func(add):
	res = add(1,2)
	print(f"计算结果为：{res}")
def add(x,y):
	return x+y
test_func(add) # 执行计算结果为：3
"""
函数add，作为参数，传入了test_func函数中使用。
test_func需要一个函数作为参数传入，这个函数需要接收2个数字进行计算，计算逻辑由这个被传入函数决定
add函数接收2个数字对其进行计算，add函数作为参数，传递给了test_func函数使用
最终，在test_func函数内部，由传入的add函数，完成了对数字的计算操作
所以，这是一种，【计算逻辑的传递，而非数据的传递】。就像上述代码那样，【不仅仅是相加，相见、相除、等任何逻辑都可以自行定义并作为函数传入】。
"""

说明：

• 函数本身是可以作为参数，传入另一个函数中进行使用的。
• 将函数传入的作用在于：传入计算逻辑，而非传入数据。

lambda匿名函数

lambda匿名函数：又称为匿名函数，一般就是应用在作为一个参数传递到另外一个函数中也可以理解成对功能简单的函数的简化

函数的定义中:

• def关键字，可以定义带有名称的函数,有名称的函数，可以基于名称重复使用。
• lambda关键字，可以定义匿名函数（无名称）无名称的匿名函数，只可临时使用一次。

匿名函数定义语法：

lambda 传入参数:函数体(一行代码)

• lambda 是关键字，表示定义匿名函数
• 传入参数表示匿名函数的形式参数，如：x, y 表示接收2个形式参数
• 函数体，就是函数的执行逻辑，要注意：只能写一行，无法写多行代码

def test_func(add):
	res = add(1,2)
	print(f"计算结果为：{res}")
# 使用def和使用lambda，定义的函数功能完全一致，只是lambda关键字定义的函数是匿名的，无法二次使用
test_func(lambda x,y:x+y)

说明：

• 匿名函数用于临时构建一个函数，只用一次的场景
• 匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数

闭包

解释：如果在一个函数的内部定义了另一个函数，外部的我们叫他外函数，内部的我们叫他内函数。

闭包：在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。

一般情况下，在我们认知当中，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。

# 将函数作为返回值返回，也是一种高阶函数
# 这种高阶函数我们也称为叫做闭包，通过闭包可以创建一些只有当前函数能访问的变量
#   可以将一些私有的数据藏到的闭包中

def outer():
    a = 10

    # 函数内部再定义一个函数
    def inner():
        print('我是outer', a)

    # 将内部函数 inner作为返回值返回
    return inner


# r是一个函数对象，是调用fn()后返回的函数对象
# 这个函数实在fn()内部定义，并不是全局函数
# 所以这个函数总是能访问到fn()函数内的变量
# 外函数返回了内函数的引用
fn = outer()

# r()相当于调用了inner()函数
print("outer引用地址：", outer)
print("inner引用地址：", fn)
fn()
"""
输出结果：
outer引用地址： <function outer at 0x0000000002BB5948>
inner引用地址： <function outer.<locals>.inner at 0x0000000002BB58B8>
我是outer 10
"""

说明上述代码：

对于闭包，在外函数outer中 最后return inner，我们在调用外函数 fn = outer() 的时候，outer函数返回了inner函数对象，inner函数对象是一个函数的引用，这个引用被存入了fn对象中。所以接下来我们再进行fn() 的时候，相当于运行了inner函数。

注意：

一个函数，如果函数名后紧跟一对括号，相当于调用这个函数。如果不跟括号，相当于只是一个函数的名字，里面存了函数所在位置的引用。

在闭包中外函数把临时变量绑定给内函数

一个函数结束的时候，会把自己的临时变量都释放还给内存，之后变量都不存在了。一般情况下，确实是这样的。但是闭包是一个特别的情况。外部函数发现，自己的临时变量会在将来的内部函数中用到，自己在结束的时候，返回内函数的同时，会把外函数的临时变量送给内函数绑定在一起。所以外函数已经结束了，调用内函数的时候仍然能够使用外函数的临时变量。

def outer(num):
    a = num

    # 函数内部再定义一个函数
    def inner():
        print('我是outer', a)

    # 将内部函数 inner作为返回值返回
    return inner

fn1 = outer(10)
fn2 = outer(20)

print("inner引用地址：", fn1)
fn1()
print("inner引用地址：", fn2)
fn2()
"""
输出结果：
inner引用地址： <function outer.<locals>.inner at 0x00000000026B58B8>
我是outer 10
inner引用地址： <function outer.<locals>.inner at 0x00000000026B5828>
我是outer 20
"""
# 注意两个inner的地址不一样，一个是8B8，一个是828。

上面的代码中，两次调用外部函数outer，分别传入的值是10和20。内部函数只定义了一次，可以发现调用的时候，内部函数是能识别外函数的临时变量是不一样的。

Python中一切都是对象，虽然函数只定义了一次，但是外函数在运行的时候，实际上是按照里面代码执行的，外函数里创建了一个函数，我们每次调用外函数，它都创建一个内函数，虽然代码一样，但是却创建了不同的对象，并且把每次传入的临时变量数值绑定给内函数，再把内函数引用返回。

所以我们每次调用外函数，都返回不同的实例对象的引用，他们的功能是一样的，但是它们实际上不是同一个函数对象。【其实这也间接的解释了为什么函数可以作为参数传递】

闭包中内函数修改外函数局部变量

Python语法当中，一个函数可以随意读取全局数据，但是要修改全局数据的时候有两种方法:

• global声明全局变量。全局变量是可变类型数据的时候可以修改。
• 在闭包内函数也是类似的情况。在内函数中想修改闭包变量（外函数绑定给内函数的局部变量）的时候，在Python中，可以用nonlocal关键字声明一个变量， 表示这个变量不是局部变量空间的变量，需要向上一层变量空间找这个变量。

def outer(num):
    a = num
    b = 10  # a和b都是闭包变量
    print("原始a值为", a)

    # inner内函数
    def inner():
        # 内函数中想修改闭包变量
        # nonlocal关键字声明变量
        nonlocal a
        a += b
        print('我是outer的a', a)

    # 将内部函数 inner作为返回值返回
    return inner

fn1 = outer(10)
fn1()
"""
输出结果：
原始a值为 10
我是outer的a 20
"""

需要注意：还有一点需要注意，闭包变量实际上只有一份，每次调用一份闭包变量。

def outer(num):
    a = num
    b = 10  # a和b都是闭包变量
    print("原始a值为", a)

    # inner内函数
    def inner():
        # 内函数中想修改闭包变量
        # nonlocal关键字声明变量
        nonlocal a
        a += b
        print('我是outer的a', a)

    # 将内部函数 inner作为返回值返回
    return inner


fn1 = outer(10)

fn1()
fn1()
fn1()
"""
输出结果：
原始a值为 10
我是outer的a 20 --》可以看到第二次第二次调用fn1()方法，a的值有增加了10。
我是outer的a 30
我是outer的a 40
"""