这是Python装饰器讲解的第二部分，上一篇：Python装饰器Part I：装饰器简介

回顾：不带参数的装饰器

在Python装饰器Part I：装饰器简介中，我演示了怎么样使用无参数的装饰器，主要是使用类式装饰器，因为这样更容易理解。
如果我们创建了一个不带参数的装饰器，被装饰的方法会传递给装饰器的构造器，然后在被装饰的函数被调用的时候，装饰器的__call__()方法就会执行。

class decoratorWithoutArguments(object):

    def __init__(self, f):
        \"\"\"
        If there are no decorator arguments, the function
        to be decorated is passed to the constructor.
        \"\"\"
        print \"Inside __init__()\"
        self.f = f

    def __call__(self, *args):
        \"\"\"
        The __call__ method is not called until the
        decorated function is called.
        \"\"\"
        print \"Inside __call__()\"
        self.f(*args)
        print \"After self.f(*args)\"

@decoratorWithoutArguments
def sayHello(a1, a2, a3, a4):
    print \'sayHello arguments:\', a1, a2, a3, a4

print \"After decoration\"

print \"Preparing to call sayHello()\"
sayHello(\"say\", \"hello\", \"argument\", \"list\")
print \"After first sayHello() call\"
sayHello(\"a\", \"different\", \"set of\", \"arguments\")
print \"After second sayHello() call\"

任何传递给被装饰方法的参数都将传递给__call__()，输出日志是：

Inside __init__()
After decoration
Preparing to call sayHello()
Inside __call__()
sayHello arguments: say hello argument list
After self.f(*args)
After first sayHello() call
Inside __call__()
sayHello arguments: a different set of arguments
After self.f(*args)
After second sayHello() call

需要注意的是，在“装饰”阶段，只有__init__()会被调用；同时只有在被装饰方法被调用的时候，__call__()才会被调用。

带参数的装饰器

现在我们把上面的那个例子简单的改动一下，看看在添加装饰器参数的情况下会发生什么情况：

class decoratorWithArguments(object):

    def __init__(self, arg1, arg2, arg3):
        \"\"\"
        If there are decorator arguments, the function
        to be decorated is not passed to the constructor!
        \"\"\"
        print \"Inside __init__()\"
        self.arg1 = arg1
        self.arg2 = arg2
        self.arg3 = arg3

    def __call__(self, f):
        \"\"\"
        If there are decorator arguments, __call__() is only called
        once, as part of the decoration process! You can only give
        it a single argument, which is the function object.
        \"\"\"
        print \"Inside __call__()\"
        def wrapped_f(*args):
            print \"Inside wrapped_f()\"
            print \"Decorator arguments:\", self.arg1, self.arg2, self.arg3
            f(*args)
            print \"After f(*args)\"
        return wrapped_f

@decoratorWithArguments(\"hello\", \"world\", 42)
def sayHello(a1, a2, a3, a4):
    print \'sayHello arguments:\', a1, a2, a3, a4

print \"After decoration\"

print \"Preparing to call sayHello()\"
sayHello(\"say\", \"hello\", \"argument\", \"list\")
print \"after first sayHello() call\"
sayHello(\"a\", \"different\", \"set of\", \"arguments\")
print \"after second sayHello() call\"

从输出结果来看，运行的效果发生了明显的变化：

Inside __init__()
Inside __call__()
After decoration
Preparing to call sayHello()
Inside wrapped_f()
Decorator arguments: hello world 42
sayHello arguments: say hello argument list
After f(*args)
after first sayHello() call
Inside wrapped_f()
Decorator arguments: hello world 42
sayHello arguments: a different set of arguments
After f(*args)
after second sayHello() call

现在，在“装饰”阶段，构造器和__call__()都会被依次调用，__call__()也只接受一个函数对象类型的参数，而且必须返回一个装饰方法去替换原有的方法，__call__()只会在“装饰”阶段被调用一次，接着返回的装饰方法会被实际用在调用过程中。
尽管这个行为很合理，构造器现在被用来捕捉装饰器的参数，而且__call__()不能再被当做装饰方法，相反要利用它来完成装饰的过程。尽管如此，第一次见到这种与不带参数的装饰器迥然不同的行为还是会让人大吃一惊，而且它们的编程范式也有很大的不同。

带参数的函数式装饰器

最后，让我们看一下更复杂的函数式装饰器，在这里你不得不一次完成所有的事情：

def decoratorFunctionWithArguments(arg1, arg2, arg3):
    def wrap(f):
        print \"Inside wrap()\"
        def wrapped_f(*args):
            print \"Inside wrapped_f()\"
            print \"Decorator arguments:\", arg1, arg2, arg3
            f(*args)
            print \"After f(*args)\"
        return wrapped_f
    return wrap

@decoratorFunctionWithArguments(\"hello\", \"world\", 42)
def sayHello(a1, a2, a3, a4):
    print \'sayHello arguments:\', a1, a2, a3, a4

print \"After decoration\"

print \"Preparing to call sayHello()\"
sayHello(\"say\", \"hello\", \"argument\", \"list\")
print \"after first sayHello() call\"
sayHello(\"a\", \"different\", \"set of\", \"arguments\")
print \"after second sayHello() call\"

输出结果：

Inside wrap()
After decoration
Preparing to call sayHello()
Inside wrapped_f()
Decorator arguments: hello world 42
sayHello arguments: say hello argument list
After f(*args)
after first sayHello() call
Inside wrapped_f()
Decorator arguments: hello world 42
sayHello arguments: a different set of arguments
After f(*args)
after second sayHello() call

函数式装饰器的返回值必须是一个函数，能包装原有被包装函数。也就是说，Python会在装饰发生的时候拿到并且调用这个返回的函数结果，然后传递给被装饰的函数，这就是为什么我们在装饰器的实现里嵌套定义了三层的函数，最里层的那个函数是新的替换函数。
因为闭包的特性， wrapped_f()在不需要像在类式装饰器例子中一样显示存储arg1, arg2, arg3这些值的情况下，就能够访问这些参数。不过，这恰巧是我觉得“显式比隐式更好”的例子。尽管函数式装饰器可能更加精简一点，但类式装饰器会更加容易理解并因此更容易被修改和维护。

原文地址：Python Decorators II: Decorator Arguments