7

我有一个简单的小装饰器，它将函数调用的结果缓存dict为函数属性。

from decorator import decorator
def _dynamic_programming(f, *args, **kwargs):
    try:
        f.cache[args]
    except KeyError:
        f.cache[args] = f(*args, **kwargs)
    return f.cache[args]

def dynamic_programming(f):
    f.cache = {}
    return decorator(_dynamic_programming, f)

我现在想添加清空缓存的可能性。所以我改变了dynamic_programming()这样的功能：

def dynamic_programming(f):
    f.cache = {}
    def clear():
        f.cache = {}
    f.clear = clear
    return decorator(_dynamic_programming, f)

现在假设我用这个小东西来实现一个斐波那契数函数：

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

>>> fib(4)
5
>>> fib.cache
{(0,): 1, (1,): 1, (2,): 2, (3,): 3, (4,): 5}

但是现在当我清除缓存时，会发生一些奇怪的事情：

>>> fib.clear()
>>> fib.cache
{(0,): 1, (1,): 1, (2,): 2, (3,): 3, (4,): 5}

或者（运行一个新的 Python 内核）反过来做：

>>> fib.clear()
>>> fib(4)
5
>>> fib.cache
{}

为什么缓存在第一次访问后以某种方式无法“访问”，即在调用clear()后调用或调用后不改变clear()？

（顺便说一句。我知道正确清除缓存的解决方案：调用f.cache.clear()而不是分配{}给它按预期工作。我只是对分配解决方案失败的原因感兴趣。）

4

2 回答 2

7

问题出在decorator模块上。如果您print在装饰器中添加一些语句：

from decorator import decorator
def _dynamic_programming(f, *args, **kwargs):
    print "Inside decorator", id(f.cache)
    try:
        f.cache[args]
    except KeyError:
        f.cache[args] = f(*args, **kwargs)
    return f.cache[args]

def dynamic_programming(f):
    f.cache = {}
    print "Original cache", id(f.cache)
    def clear():
        f.cache = {}
        print "New cache", id(f.cache)
    f.clear = clear
    return decorator(_dynamic_programming, f)

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

print fib(4)
print id(fib.cache)
fib.clear()
print id(fib.cache)
print fib(10)
print id(fib.cache)

它输出（跳过重复的行）：

Original cache 139877501744024
Inside decorator 139877501744024
5
139877501744024
New cache 139877501802208
139877501744024
Inside decorator 139877501802208
89
139877501744024

如您所见，cache装饰器内部根据 clear 功能发生变化。但是，cache访问的来源__main__不会改变。打印cache装饰器的外部和内部可以提供更清晰的图片（同样，跳过重复项）：

Inside decorator {}
Inside decorator {(1,): 1}
Inside decorator {(2,): 2, (0,): 1, (1,): 1}
Inside decorator {(2,): 2, (0,): 1, (3,): 3, (1,): 1}
5
Outside {(2,): 2, (0,): 1, (3,): 3, (1,): 1, (4,): 5}
Inside decorator {}
Inside decorator {(1,): 1}
Inside decorator {(2,): 2, (0,): 1, (1,): 1}
Inside decorator {(2,): 2, (0,): 1, (3,): 3, (1,): 1}
Inside decorator {(2,): 2, (0,): 1, (3,): 3, (1,): 1, (4,): 5}
Inside decorator {(0,): 1, (1,): 1, (2,): 2, (3,): 3, (4,): 5, (5,): 8}
Inside decorator {(0,): 1, (1,): 1, (2,): 2, (3,): 3, (4,): 5, (5,): 8, (6,): 13}
Inside decorator {(0,): 1, (1,): 1, (2,): 2, (3,): 3, (4,): 5, (5,): 8, (6,): 13, (7,): 21}
Inside decorator {(0,): 1, (1,): 1, (2,): 2, (8,): 34, (3,): 3, (4,): 5, (5,): 8, (6,): 13, (7,): 21}
Inside decorator {(0,): 1, (1,): 1, (2,): 2, (8,): 34, (3,): 3, (9,): 55, (4,): 5, (5,): 8, (6,): 13, (7,): 21}
89
Outside {(2,): 2, (0,): 1, (3,): 3, (1,): 1, (4,): 5}

正如你所看到的，内部的变化并没有在外部得到呼应。问题是在模块decorator内部，有一行（在它用来制作装饰器的类内部）：

self.dict = func.__dict__.copy()

然后稍后：

func.__dict__ = getattr(self, 'dict', {})

所以基本上，__dict__外面和里面是不同的__dict__。这意味着：

  • 由__dict__装饰器复制（未引用）
  • 当cache改变时，它改变的是内部__dict__，而不是外部__dict__
  • 因此，被cache使用的_dynamic_programming被清除了，但是从外部看不到，因为装饰器__dict__仍然指向旧的cache（如上所示，内部cache更新，而外部cache保持不变）

所以，总而言之，这是decorator模块的问题。

于 2014-10-29T17:14:11.593 回答
3

所以@matsjoyce 的回答非常有趣和深入，我知道你已经有了解决方案，但我总是觉得编写自己的装饰器更清楚一些：

def dynamic_programming(f):
    def wrapper(*args, **kwargs):
        try:
            return wrapper.cache[args]            
        except KeyError:
            res = wrapper.cache[args] = f(*args, **kwargs)
            return res
    wrapper.cache = {}
    wrapper.clear = wrapper.cache.clear
    return wrapper
于 2014-10-29T19:09:48.173 回答