为什么嵌套函数比未嵌套的版本要慢得多？

Question

I'm trying to contain memo dict inside fibonacci as I'm trying to pickle the function. However, in my tests, it seems that the nested function is significantly slower, but I don't see this with other versions of fibonacci only when I'm using the memoized function.

All my tests: https://gist.github.com/dasickis/4733353

#!/usr/bin/env python

memo = {0: 0, 1: 1}

# Contract: [int > 0] -> [int > 0]
def fibonacci(n):
    """ Return the `x`th number in the fibonacci series. """
    if not n in memo:
        memo[n] = fibonacci(n - 1) + fibonacci(n - 2)
    return memo[n]

#--------------------------#

# Contract: [int > 0] -> [int > 0]
def fibonacci_nested(n):
    memo = {0: 0, 1: 1}

    def fib(n):
        """ Return the `x`th number in the fibonacci series. """
        if not n in memo:
            memo[n] = fib(n - 1) + fib(n - 2)
        return memo[n]

    return fib(n)

#--------------------------#

import timeit
stmt = "assert fib(20) == 6765"

print "fibonacci"
print timeit.timeit(stmt, setup="from __main__ import fibonacci as fib")
print 

print "fibonacci_nested"
print timeit.timeit(stmt, setup="from __main__ import fibonacci_nested as fib")

Outputs:

fibonacci
0.263559103012

fibonacci_nested
11.4014730453

Answer 1

You don't clean the memo dictionary between runs giving the version without nesting an unfair advantage. The first time timeit runs fib it'll fill the memo dict and then subsequent runs re-use it.

The nested function sets up a new, empty memo each time.