对于python装饰器结合递归的进一步理解

对于python装饰器结合递归的进一步理解

代码如下：

import functools

def memoize(fn):

    print('start memoize')

    known = dict()

    @functools.wraps(fn)

    def memoizer(*args):

        if args not in known:

            print('memorize %s'%args)

            # known[args] = fn(*args)

        for k in known.keys():

                print('%s : %s'%(k, known[k]), end = ' ')

        print()

        # return known[args]

    return memoizer

@memoize

def nsum(n):

    print('now is %s'%n)

    assert (n >= 0), 'n must be >= 0'

    return 0 if n == 0 else n + nsum(n - 1)

@memoize

def fibonacci(n):

    assert (n >= 0), 'n must be >= 0'

    return n if n in (0, 1) else fibonacci(n - 1) + fibonacci(n - 2)

if __name__ == '__main__':

    print(nsum(10))

    print(fibonacci(10))

输出如下：

start memoize

start memoize

memorize 10

None

memorize 10

None

对比代码（把注释的地方去掉后）的输出：

start memoize

start memoize

memorize 10

now is 10

memorize 9

now is 9

memorize 8

now is 8

memorize 7

now is 7

memorize 6

now is 6

memorize 5

now is 5

memorize 4

now is 4

memorize 3

now is 3

memorize 2

now is 2

memorize 1

now is 1

memorize 0

now is 0

(0,) : 0

(0,) : 0 (1,) : 1

(0,) : 0 (1,) : 1 (2,) : 3

(0,) : 0 (1,) : 1 (2,) : 3 (3,) : 6

(0,) : 0 (1,) : 1 (2,) : 3 (3,) : 6 (4,) : 10

(0,) : 0 (1,) : 1 (2,) : 3 (3,) : 6 (4,) : 10 (5,) : 15

(0,) : 0 (1,) : 1 (2,) : 3 (3,) : 6 (4,) : 10 (5,) : 15 (6,) : 21

(0,) : 0 (1,) : 1 (2,) : 3 (3,) : 6 (4,) : 10 (5,) : 15 (6,) : 21 (7,) : 28

(0,) : 0 (1,) : 1 (2,) : 3 (3,) : 6 (4,) : 10 (5,) : 15 (6,) : 21 (7,) : 28 (8,) : 36

(0,) : 0 (1,) : 1 (2,) : 3 (3,) : 6 (4,) : 10 (5,) : 15 (6,) : 21 (7,) : 28 (8,) : 36 (9,) : 45

(0,) : 0 (1,) : 1 (2,) : 3 (3,) : 6 (4,) : 10 (5,) : 15 (6,) : 21 (7,) : 28 (8,) : 36 (9,) : 45 (10,) : 55

通过取消注释的对比，可以得到如下结论：

• 装饰器memoize实际上对于函数nsum()只执行了第一次加载的时候的预处理，然后就是nsum = memoizer。

• 装饰器的实质是通过functools.wraps(fn)获得函数的名字，便于nsum.__name__ ==nsum，并将参数传至memoize(*args)，也就是*args。

• 装饰器通过memory()，和外面的装饰器获得的函数，在内部对函数进行功能改造。在上例子中，通过known[args] = fn(*args)先执行fn函数，即上例子中nsum(10)，然后就进入递归，t同时调用memoizer()和nsum()函数10次，且先memoizer再nsum，而且每次都在``known[args] = fn(*args)`进入递归，也就是每次nsum的执行，故，对于为什么打印konwn中的元素是集中在一起的解释就知道了，到了n == 0，才跳出递归，故，known的第一个元素是0，然后就循环往复。

• 最后，其实，递归函数执行的是fn(*args)，即nsum()。