装饰装饰器：尝试让我的头脑理解它

Question

我试图了解如何装饰装饰器，并想尝试以下操作：

假设我有两个装饰器并将它们应用于函数 hello()：

def wrap(f):
    def wrapper():
        return " ".join(f())
    return wrapper


def upper(f):
    def uppercase(*args, **kargs):
        a,b = f(*args, **kargs)
        return a.upper(), b.upper()
    return uppercase

@wrap
@upper
def hello():
    return "hello","world"

print(hello())

然后我必须开始添加其他装饰器对于其他函数，但通常 @wrap 装饰器将“包装所有这些”

def lower(f):
    def lowercase(*args, **kargs):
        a,b = f(*args, **kargs)
        return a.lower(), b.lower()
    return lowercase

@wrap
@lower
def byebye():
    return "bye", "bye"

我如何编写一个装饰器，它装饰我的 @lower 和 @upper装饰器？参见下文：

@wrap
def lower():
    ...

@wrap
def upper():
    ...

只需执行以下操作即可获得与上述相同的结果：

@upper
def hello():
    ...

@lower
def byebye():
    ...

Answer 1

def upper(f):
    @wrap
    def uppercase(*args, **kargs):
        a,b = f(*args, **kargs)
        return a.upper(), b.upper()
    return uppercase

---

Python 中的装饰器

 @foo
 def bar(...): ...

相当于

 def bar(...): ...
 bar = foo(bar)

您想要获得的效果

@wrap
@upper
def hello(): ....

，

hello = wrap(upper(hello))

因此应该在 upper 的返回值上调用 wrap：

def upper_with_wrap(f):
   def uppercase(...): ...
   return wrap(uppercase)

这也相当于在该函数上应用装饰器：

def upper_with_wrap(f):
   @wrap
   def uppercase(...): ...
   # ^ equivalent to 'uppercase = wrap(uppercase)'
   return uppercase

Answer 2

这是一个用装饰器装饰装饰器的通用（有点复杂）的解决方案（耶！）。

# A second-order decorator
def decdec(inner_dec):
    def ddmain(outer_dec):
        def decwrapper(f):
            wrapped = inner_dec(outer_dec(f))
            def fwrapper(*args, **kwargs):
               return wrapped(*args, **kwargs)
            return fwrapper
        return decwrapper
    return ddmain

def wrap(f):
    def wrapper():
        return " ".join(f())
    return wrapper


# Decorate upper (a decorator) with wrap (another decorator)
@decdec(wrap)
def upper(f):
    def uppercase(*args, **kargs):
        a,b = f(*args, **kargs)
        return a.upper(), b.upper()
    return uppercase

@upper
def hello():
    return "hello","world"

print(hello())

Answer 3

Boaz Yaniv 接受的答案可以稍微简化一下，如下所示：

def wrap(decorator):                # lowercase/uppercase decorator as argument
    def wrapperA(fn):               # decorated (hello) function as argument
        def wrapperB(*fn_args):     # decorated (hello) functions' arguments as arguments
            # Here, you tell your 'wrap' decorator to get the
            # result that we want to process/wrap further this way:
            t = decorator(fn)(*fn_args)
            return " ".join(t)
        return wrapperB
    return wrapperA


@wrap
def lower(f):
    def lowercase(*args, **kwargs):
        a, b = f(*args, **kwargs)
        return a.lower(), b.lower(), 'in lowercase'
    return lowercase


@wrap
def upper(f):
    def uppercase(*args, **kwargs):
        a, b = f(*args, **kwargs)
        return a.upper(), b.upper(), 'in uppercase'
    return uppercase


@lower
def hello_in_lc():
    return "HELLO", "WORLD"


@upper
def hello_in_uc():
    return "hello", "world"


x = hello_in_lc()
y = hello_in_uc()
print(x)
print(y)

输出：

hello world in lowercase
HELLO WORLD in uppercase

现在，wrap 装饰器具有如此多嵌套的原因是因为一旦您装饰了另一个装饰器的定义，整个执行过程变得与垂直嵌套装饰有点不同。这就是我要说的：

@wrap        # this wrap decorator is the one provided in the question
@upper
def hello()
    return "Hello", "World"

这就是 Python 对上述代码所做的事情。它以 upper 函数作为参数调用 wrap 装饰器。在 wrap 装饰器的 wrapper 内部，它发现装饰器正在被调用。因此它调用了 upper 函数。由于 upper 本身是函数的装饰器，因此在调用期间 upper 接收 hello 函数作为引用，其参数由包装器 接收>大写。

在 uppercase 内部调用了 hello 函数，因此随后调用 hello 函数，处理其结果，并将其返回给 hello 函数wrap 装饰器中的 >wrapper 函数最终返回到主模块的全局作用域，其中 hello() 在底部被调用。

然而，装饰装饰器的定义是一个不同的故事。采取以下代码：

@wrap        # that's the wrap decorator from my answer
def upper()

@upper
def hello()

这里将发生的事情是，一旦您调用 hello()，wrap 装饰器就会像前面的情况一样被调用，带有 upper > 函数作为参数传递给wrap。但是，如果您尝试在 wrapper 中调用 decorator 作为 decorator() Python 会抛出错误，指出 upper 函数是没有争论就打电话！

要修复 wrap 装饰器中的包装器（此处称为 wrapperA）需要接收参数。这个参数是对 upper 已修饰的函数的引用，在我们的例子中是 hello 函数。因此，wrapperA 必须使用 hello 函数 (fn) 作为参数来调用 装饰器。

但是执行decorator(fn)将为我们提供对upper装饰器的uppercase包装器的引用。为了执行它并传递 fn 需要的任何参数，我们需要另一个名为 wrapperB 的包装器，嵌套在 wrapperA 中。在这里，wrapper A 实际上充当 fn 的装饰器，其 wrapperB 将采用 fn 的参数。

因此，用于获取对中间装饰器（下部和上部）结果进行任何处理的结果的复合最终调用应该如下所示：

def wrapperB(*fn_args):
    decorator(fn)(*fn_args)

# Alternative
    wrapped_fn = decorator(fn)
    result = wrapped_fn(*fn_args) 

这就是为什么必须嵌套的原因。

垂直装饰或 kennytm 此处 建议的替代方案显然对眼睛要好得多。