当参数是递归函数时，修饰器如何工作？

Question

import time
def clock(func):
   def clocked(*args):
       t0 = time.perf_counter()
       result = func(*args) 
       elapsed = time.perf_counter() - t0
       name = func.__name__
       arg_str = ', '.join(repr(arg) for arg in args)
       print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result))
       return result
   return clocked

this is the decorator.

@clock
def factorial(n):
    return 1 if n < 2 else n*factorial(n-1)

the parts of result is:

[0.00000191s] factorial(1) -> 1
[0.00004911s] factorial(2) -> 2
[0.00008488s] factorial(3) -> 6
[0.00013208s] factorial(4) -> 24
[0.00019193s] factorial(5) -> 120
[0.00026107s] factorial(6) -> 720
6! = 720

how this decorator works when the argument is recursive function? why the decorator can be executed for many times. how it works?

Answer 1

In your example, the clock decorator is executed once, when it replaces the original version of factorial with the clocked version. The original factorial is recursive and therefore the decorated version is recursive too. And so you get the timing data printed for each recursive call - the decorated factorial calls itself, not the original version, because the name factorial now refers to the decorated version.

---

It's a good idea to use functools.wraps in decorators. This copies various attributes of the original function to the decorated version.

For example, without wraps :

import time

def clock(func):
    def clocked(*args):
        ''' Clocking decoration wrapper '''
        t0 = time.perf_counter()
        result = func(*args) 
        elapsed = time.perf_counter() - t0
        name = func.__name__
        arg_str = ', '.join(repr(arg) for arg in args)
        print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result))
        return result
    return clocked

@clock
def factorial(n):
    ''' Recursive factorial '''
    return 1 if n < 2 else n * factorial(n-1)

print(factorial.__name__, factorial.__doc__)

output

clocked  Clocking decoration wrapper 

With wraps :

import time
from functools import wraps

def clock(func):
    @wraps(func)
    def clocked(*args):
        ''' Clocking decoration wrapper '''
        t0 = time.perf_counter()
        result = func(*args) 
        elapsed = time.perf_counter() - t0
        name = func.__name__
        arg_str = ', '.join(repr(arg) for arg in args)
        print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result))
        return result
    return clocked

@clock
def factorial(n):
    ''' Recursive factorial '''
    return 1 if n < 2 else n * factorial(n-1)

print(factorial.__name__, factorial.__doc__)

output

factorial  Recursive factorial 

which is what we'd get if we did print(factorial.__name__, factorial.__doc__) on the undecorated version.

---

If you don't want the clock -decorated recursive function to print the timing info for all of the recursive calls, it gets a bit tricky.

The simplest way is to not use the decorator syntax and just call clock as a normal function so we get a new name for the clocked version of the function:

def factorial(n):
    return 1 if n < 2 else n * factorial(n-1)

clocked_factorial = clock(factorial)

for n in range(7):
    print('%d! = %d' % (n, clocked_factorial(n)))

output

[0.00000602s] factorial(0) -> 1
0! = 1
[0.00000302s] factorial(1) -> 1
1! = 1
[0.00000581s] factorial(2) -> 2
2! = 2
[0.00000539s] factorial(3) -> 6
3! = 6
[0.00000651s] factorial(4) -> 24
4! = 24
[0.00000742s] factorial(5) -> 120
5! = 120
[0.00000834s] factorial(6) -> 720
6! = 720

Another way is to wrap the recursive function in a non-recursive function and apply the decorator to the new function.

def factorial(n):
    return 1 if n < 2 else n * factorial(n-1)

@clock
def nr_factorial(n):
    return factorial(n)

for n in range(3, 7):
    print('%d! = %d' % (n, nr_factorial(n)))

output

[0.00001018s] nr_factorial(3) -> 6
3! = 6
[0.00000799s] nr_factorial(4) -> 24
4! = 24
[0.00000801s] nr_factorial(5) -> 120
5! = 120
[0.00000916s] nr_factorial(6) -> 720
6! = 720

Another way is to modify the decorator so that it keeps track of whether it's executing the top level of the recursion or one of the inner levels, and only print the timing info for the top level. This version uses the nonlocal directive so it only works in Python 3, not Python 2.

def rclock(func):
    top = True
    @wraps(func)
    def clocked(*args):
        nonlocal top
        if top:
            top = False
            t0 = time.perf_counter()
            result = func(*args) 
            elapsed = time.perf_counter() - t0
            name = func.__name__
            arg_str = ', '.join(repr(arg) for arg in args)
            print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result))
        else:
            result = func(*args)
            top = True
        return result
    return clocked

@rclock
def factorial(n):
    return 1 if n < 2 else n * factorial(n-1)

for n in range(3, 7):
    print('%d! = %d' % (n, factorial(n))) 

output

[0.00001253s] factorial(3) -> 6
3! = 6
[0.00001205s] factorial(4) -> 24
4! = 24
[0.00001227s] factorial(5) -> 120
5! = 120
[0.00001422s] factorial(6) -> 720
6! = 720

The rclock function can be used on non-recursive functions, but it's a little more efficient to just use the original version of clock .

---

Another handy function in functools that you should know about if you're using recursive functions is lru_cache . This keeps a cache of recently computed results so they don't need to be re-computed. This can enormously speed up recursive functions. Please see the docs for details.

We can use lru_cache in conjunction with clock or rclock .

@lru_cache(None)
@clock
def factorial(n):
    return 1 if n < 2 else n * factorial(n-1)

for n in range(3, 7):
    print('%d! = %d' % (n, factorial(n)))

output

[0.00000306s] factorial(1) -> 1
[0.00017850s] factorial(2) -> 2
[0.00022049s] factorial(3) -> 6
3! = 6
[0.00000542s] factorial(4) -> 24
4! = 24
[0.00000417s] factorial(5) -> 120
5! = 120
[0.00000409s] factorial(6) -> 720
6! = 720

As you can see, even though we used the plain clock decorator only a single line of timing info gets printed for the factorials of 4, 5, and 6 because the smaller factorials are read from the cache instead of being re-computed.

Answer 2

When you apply a decorator to a function, the function is passed as a parameter to the decorator. Whether the function is recursive or not does not matter.

The code

@clock
def factorial(n):
    return 1 if n < 2 else n*factorial(n-1)

is equivalent to

def factorial(n):
    return 1 if n < 2 else n*factorial(n-1)
factorial = clock(factorial)

Answer 3

The decorated function is passed to the decorator as an argument and returned another function to replace the original one, the returned function is no recursive function, but when you call it, it'll call the original recursive function:

def clock(func):
  def clocked(*args):
   t0 = time.perf_counter()
   result = func(*args) # You call your original recursive function here
   elapsed = time.perf_counter() - t0
   name = func.__name__
   arg_str = ', '.join(repr(arg) for arg in args)
   print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result))
   return result
return clocked

When you call your decorated function factorial , what you actually called is clocked , and it actually call factorial in the following line:

result = func(*args)

The decorator is executed only once.

For understanding, you can think your function becomes to the following one after @clock :

def factorial(*args):
    def _factorial(n):
        return 1 if n < 2 else n*_factorial(n-1)
    t0 = time.perf_counter()
    result = _factorial(*args)
    elapsed = time.perf_counter() - t0
    name = _factorial.__name__
    arg_str = ', '.join(repr(arg) for arg in args)
    print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result))
    return result

Answer 4

Maybe it helps to assume the "syntactic sugar" point of view. This is from PEP 318 with modifications (I simplified the example)

The current syntax for function decorators as implemented in Python 2.4a2 is:

@dec
def func(arg1, arg2, ...):
    pass

This is equivalent to:

def func(arg1, arg2, ...):
    pass
func = dec(func)

As you can see the decorator function is called only once and the wrapper it returns is assigned to the name of the decorated function.

Thus whenever the original function is called by its name (for example in a recursion) the wrapper (but not the decorator function) is called instead.