解释这种高阶函数的行为

Question

Can someone explain why version 1 and 2 execute at the same speed? I expected versions 2, 3, and 4 to take about the same amount of time.

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)

Results:

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

Your memoize function isn't actually replacing fib with memo_fib , it's just returning a new function.

That new function still recursively calls the original, un-memoized fib .

So, basically, you're only memoizing the very top level.

---

Within fib , the recursive call to fib is just using the module-global name. (Functions are basically no different from any other kind of value, and function names no different from any other kind of name, so if you define a function at the module global level, that's what it does. If you, eg, disassemble the bytecode with dis.dis(fib) , you will see a LOAD_GLOBAL on the name fib .)

So, the easy fix is:

fib = memoize(fib)

Or just use memoize as a decorator, to make this harder to get wrong.

In other words, your examples 3 and 4.

Or, even more simply, use the built-in lru_cache decorator. (Notice the second example in its documentation.)

---

If you want to be really sneaky: Define fib within a function body. It will end up referencing fib as a closure cell from the defining scope, rather than a global ( LOAD_DEREF instead of LOAD_GLOBAL in disassembly). You can then reach into that scope and replace its fib , which means that your recursive function is now memoized "secretly" (the actual global fib isn't memoized, but the function it recursively calls is) and "safely" (nobody else has a reference to the closure cell except through fib itself).

Answer 2

In version 2, you've stored the memoized version with a different name, so you wind up calling fib just as many times as in the first version. Your call stack looks like this:

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

etc.

So you aren't actually receiving any benefit from the memoization in this case.