Python闭包基本介绍与作用

最新推荐文章于 2024-02-04 15:49:23 发布

rs勿忘初心

最新推荐文章于 2024-02-04 15:49:23 发布

阅读量985

点赞数

分类专栏： # Python技术学习文章标签： python 闭包作用基本介绍

本文链接：https://blog.csdn.net/sinat_33718563/article/details/121216086

版权

Python技术学习专栏收录该内容

89 篇文章 10 订阅

订阅专栏

1.闭包基本介绍

“闭包”的本质就是函数的嵌套定义，即在函数内部再定义函数。“闭包”有两种不同的方式，第一种是在函数内部就“直接调用了”；第二种是“返回一个函数名称”。

如果在一个函数（func1）的内部定义了另一个函数（func2），外部的函数（func1）叫外函数，内部的函数（func2）叫内函数。

闭包的条件：

在一个外函数中定义了一个内函数。
内函数里运用了外函数的临时变量。
并且外函数的返回值是内函数的引用（也就是返回函数对象的意思）。

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

我们不妨先来看一个最简单的很典型的闭包示例：

# 闭包函数的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer(a):
    b = 10

    # inner是内函数
    def inner():
        # 在内函数中 用到了外函数的临时变量
        print(a + b)
    # 外函数的返回值是内函数的引用
    return inner


if __name__ == '__main__':
    # 在这里我们调用外函数传入参数5
    # 此时外函数两个临时变量 a是5 b是10 ，并创建了内函数，然后把内函数的引用返回存给了demo1
    # 外函数结束的时候发现内部函数将会用到自己的临时变量，这两个临时变量就不会释放，会绑定给这个内部函数
    demo1 = outer(5)
    # 我们调用内部函数，看一看内部函数是不是能使用外部函数的临时变量
    # demo1存了外函数的返回值，也就是inner函数的引用，这里相当于执行inner函数
    demo1()  # 15

    demo2 = outer(7)
    demo2()  # 17

1.1 外函数的返回值是内函数的引用

在Python中一切皆对象，包括整型数据、函数等都是对象。当我们进行a=1的时候，实际上在内存当中有一个地方存了值1，然后用a这个变量名存了1所在内存位置的引用。引用就类似于C语言里的指针，引用也可以理解成地址。a只不过是一个变量名字，a里面存的是1这个数值所在的地址，就是a里面存了数值1的引用。

相同的道理，在python中定义一个函数def demo(): 的时候，内存当中会开辟一些空间，存下这个函数的代码、内部的局部变量等等。这个demo只不过是一个变量名字，它里面存了这个函数所在位置的引用而已。我们还可以进行x = demo， y = demo，这样的操作就相当于，把demo里存的东西赋值给x和y，这样x 和y 都指向了demo函数所在的引用，在这之后我们可以用x() 或者 y() 来调用我们自己创建的demo() ，调用的实际上根本就是一个函数，x、y和demo三个变量名存了同一个函数的引用。

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

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

1.2 外函数把临时变量绑定给内函数

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

在以上实际例子中，两次调用外部函数outer,分别传入的值是5和7。内部函数只定义了一次，我们发现调用的时候，内部函数是能识别外函数的临时变量是不一样的。

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

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

在闭包内函数中，可以随意使用外函数绑定来的临时变量，但是如果想修改外函数临时变量数值的时候发现出问题了！

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

global 声明全局变量
全局变量是可变类型数据的时候可以修改

在闭包内函数也是类似的情况。在内函数中想修改闭包变量（外函数绑定给内函数的局部变量）的时候：

在python3中，可以用nonlocal 关键字声明一个变量，表示这个变量不是局部变量空间的变量，需要向上一层变量空间找这个变量。

# nonlocal让内部函数中的变量在上一层函数中生效，外部必须有

x=1
def f1():
    x=2
    def f2():
        # x=3
        def f3():
            # global x #修改全局的
            nonlocal x #修改局部的（当用nonlocal时，修改x=3为x=100000000，当x=3不存在时，修改x=2为100000000 ）
                   # 必须在函数内部
            x=10000000000
        f3()
        print('f2内的打印',x)
    f2()
    print('f1内的打印', x)
f1()
print(x)

在python2中，没有nonlocal这个关键字，可以把闭包变量改成可变类型数据进行修改，不展开说啦，直接用Python3吧，Python2官方都不维护了。

2.闭包的作用

优点：

局部变量无法共享和长久的保存，而全局变量可能造成变量污染，闭包既可以长久的保存变量又不会造成全局污染。（这些变量的值始终保持在内存中，不会在外层函数调用后被自动清除）
提高代码的可复用性（当变量需要反复使用，又想避免全局污染时），举个例子如下，创建直线函数：

# （1）闭包创建直线
def line_set(a, b):   
    
    def line(x):  # 函数line 和变量 a,b构成闭包
        return a*x+b   # 返回一条直线，y = ax + b
    return line

line1 = line_set(1, 1)   # line1 = x + 1
print(line1(0))
print(line1(1))

line2 = line_set(4, 5)  # line2 = 4x + 5
print(line2(0))
print(line2(1))

print(line1(2))
print(line2(2))


# （2）普通方法创建直线
def line_creat(a, b, x):
    return a*x+b

print(line_creat(1, 1, 0))
print(line_creat(1, 1, 1))
print(line_creat(1, 1, 2))

print(line_creat(4, 5, 0))
print(line_creat(4, 5, 1))
print(line_creat(4, 5, 2))

缺点：由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，也可能导致内存泄露。

闭包和普通函数比较：