前言

以前学习python的时候,一直看到文档上说闭包可以保存上一次执行的状态,那么为何能保存呢?
今天通过debug的方式,来一探究竟

代码

这是还是用之前写过的LRU缓存算法,来提现这个概念

def cache(func):
    data = {}
    def wrapper(n):
        if n in data:
            print(data)
            return data[n]
        else:
            res = func(n)
            data[n] = res
            return res

    return wrapper

# fib = cache(fib)
@cache
def fib(n):
    if n <= 2:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)

fib(10)

当我们运行这端代码的时候,得到结果

{2: 1, 1: 1, 3: 2}
{2: 1, 1: 1, 3: 2, 4: 3}
{2: 1, 1: 1, 3: 2, 4: 3, 5: 5}
{2: 1, 1: 1, 3: 2, 4: 3, 5: 5, 6: 8}
{2: 1, 1: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13}
{2: 1, 1: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13, 8: 21}
{2: 1, 1: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13, 8: 21, 9: 34}

当我们再次运行这段代码,会发现结果是

{2: 1, 1: 1, 3: 2}
{2: 1, 1: 1, 3: 2, 4: 3}
{2: 1, 1: 1, 3: 2, 4: 3, 5: 5}
{2: 1, 1: 1, 3: 2, 4: 3, 5: 5, 6: 8}
{2: 1, 1: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13}
{2: 1, 1: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13, 8: 21}
{2: 1, 1: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13, 8: 21, 9: 34}
{2: 1, 1: 1, 3: 2, 4: 3, 5: 5, 6: 8, 7: 13, 8: 21, 9: 34, 10: 55}

第二次运行是直接命中第一次的缓存的,那么为什么呢?

闭包是怎么定义的

这里的fib如果不加语法糖的形式来写的话,其实是fib=cache(fib)
也就是这里左边的fib其实是cache返回的wrapper,

对代码加以修改

def cache(func):
    data = {}
    def wrapper(n):
        if n in data:
            print(data)
            return data[n]
        else:
            res = func(n)
            data[n] = res
            return res

    return wrapper

# fib = cache(fib)
@cache
def fib(n):
    if n <= 2:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)

def fib2(n):
    if n <= 2:
        return 1
    else:
        return fib2(n - 1) + fib2(n - 2)

fib(10)
print("fib:", fib)
fib(10)
print("fib2:", fib2)
fib: <function cache.<locals>.wrapper at 0x10a921950>
fib2: <function fib2 at 0x10a9219e0>

我们可以看到经过装饰器加持的函数和普通的函数是不一样的。fib其实就是wrapper

那么正常如果一个局部变量只存在于函数中,一旦这个函数执行完,这个变量便会被gc所回收,那么这里的data如何保存到下一次的状态呢?

引用qsr大佬的研究

对于cpython来说

1. python是解释型语言
2. python是没有所谓的堆空间、栈空间的
3. python的函数调用栈是由python解释器模拟的stack(栈)数据结构

也就是python是一个stack-based machine,本身虚拟机就实现了栈,有些可能会问,这里的cache里面的data不就相当于是个局部变量吗,cache执行完data难道不会被GC吗?感觉这个说法也很有道理

那么我们再来看这个fib是什么
fib: <function cache.<locals>.wrapper at 0x10a921950>

cache是个全局函数,位于全部作用域上,而fib同样也是全局作用域上的函数,经过fib=cache(fib)这一处理后的fib相当于是由fib来进行维护的cache中的wrapper函数

通俗来说fib是一个函数对象,秉承着python一切皆对象的思想,fib指向的是cache中的wrapper,地址是0x10a921950。是不是有那么点意思?因为wrapper被fib所引用,导致wrapper不能被GC!也就是说,执行完wrapper不能被回收,又因为data在wrapper里面进行了修改,自然data的引用次数也不为0,也同样不能被GC!

所以对于整个闭包来说,data和wrapper都是位于全局作用域上的,只要整个代码段不结束,它们就一直存在于module之中,但是我们并不能通过print(data)这样的方式看到data,因为data是位于fib: <function cache.<locals>.wrapper at 0x10a921950>这个之下维护的,当下次执行wrapper的时候,data就会被弹出使用。

是不是就清楚很多了?

总结

总结下来能保存状态的原因就是,fib其实指向了cache中的wrapper,wrapper中使用了data,又因为fib是全局函数,直到代码段结束都是不能被GC的,所以导致了data也不能被GC,因为它被fib所引用

那么如果我改造一下代码

def cache(func):
    data = {}
    def wrapper(n):
        if n in data:
            print(data)
            return data[n]
        else:
            res = func(n)
            data[n] = res
            return res

    return wrapper

# fib = cache(fib)
@cache
def fib(n):
    if n <= 2:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)

@cache
def fib2(n):
    if n <= 2:
        return 1
    else:
        return fib2(n - 1) + fib2(n - 2)

fib(10)
fib2(10)

再次打印结果,会得知,fib2其实是拿不到fib的缓存的,因为fib,fib2是两个函数对象,指向的wrapper地址是不同的,自然里面的data不共享。

fib:<function cache.<locals>.wrapper at 0x10acf99e0>
fib2:<function cache.<locals>.wrapper at 0x10acf9b00>

从debug中我们可以看到fib和fib2都是位于全局的module之中,data就分别由fib和fib2进行维护保持。

版权声明:本文为原创文章,版权归 heroyf 所有
本文链接: https://www.heroyf.club/2019/11/08/python_closure/


“苹果是给那些为了爱选择死亡的人的奖励”