Question

有人可以解释为什么版本1和版本2以相同的速度执行吗？我期望版本2,3和4花费大约相同的时间。

def fib(n):
    return n if n in [0, 1] else fib(n-2)+fib(n-1)

def memoize(fn):
    stored_results = {}

    def memoized(*args):
        try:
            return stored_results[args]
        except KeyError:
            #nothing cached
            result = stored_results[args] = fn(*args)
            return result

    return memoized

#version 1 (unmemoized)
print timeit.timeit('fib(35)', 'from __main__ import fib', number=1)
print fib, '\n'

#version 2
memo_fib = memoize(fib)
print timeit.timeit('memo_fib(35)', 'from __main__ import memo_fib', number=1)
print memo_fib, '\n'

#version 3 (wrapped)
fib = memoize(fib)
print timeit.timeit('fib(35)', 'from __main__ import fib', number=1)
print fib, '\n'

#version 4 (w/ decoration line)
@memoize
def fib(n):
    return n if n in [0, 1] else fib(n-2)+fib(n-1)

print timeit.timeit('fib(35)', 'from __main__ import fib', number=1)

结果：

version 1:  4.95815300941
<function fib at 0x102c2b320> 

version 2:  4.94982290268
<function memoized at 0x102c2b410> 

version 3:  0.000107049942017
<function memoized at 0x102c2b488> 

version 4:  0.000118970870972

Answer 1

您的memoize函数实际上并没有用fib替换memo_fib，它只是返回一个新函数。

新函数仍然以递归方式调用原始的，未记忆的fib。

所以，基本上，你只记得最高级别。

在fib内，对fib的递归调用只是使用模块全局名称。（函数基本上没有任何其他类型的值，函数名称与任何其他类型的名称没有区别，所以如果你在模块全局级别定义一个函数，那就是它的作用。如果你，例如，反汇编字节码使用dis.dis(fib)，您会在名称LOAD_GLOBAL上看到fib。）

所以，简单的解决方法是：

fib = memoize(fib)

或者只是使用memoize作为装饰器，以使这更容易出错。

换句话说，你的例子3和4。

或者，更简单地说，使用内置的lru_cache装饰器。（请注意其文档中的第二个示例。）

如果你想真的偷偷摸摸：在函数体中定义fib。它将最终引用fib作为定义范围的闭包单元，而不是全局（LOAD_DEREF而不是反汇编中的LOAD_GLOBAL）。然后，您可以进入该范围并替换其 fib，这意味着您的递归函数现在已经“秘密”备忘（实际的全局fib未被记忆，但是它递归调用的函数是）和“安全”（除了通过fib本身之外，没有其他人对闭包单元格有引用）。

Answer 2

在版本2中，您已经使用不同的名称存储了memoized版本，因此您最终调用fib的次数与第一个版本相同。您的调用堆栈如下所示：

memo_fib(35)
    fib(35)
        fib(34)
            fib(33)
        fib(33)

等

因此，在这种情况下，您实际上并没有从备忘录中获得任何好处。

解释这个高阶函数行为

2 个答案: