什么时候使用装饰器和装饰工厂？

Question

当decorator工厂接受参数并仍然装饰一个函数时，装饰器不带参数会让人感到困惑

在描述时使用它会很有帮助。

编辑：混淆是一个例子：

def before_run(func):
    print "hello from before run"
    def handle_arg(a,b):
        if(a>0):
            a= 100
        return func(a,b)

    return handle_arg

@before_run
def running_func(a,b):
    print "a",a,"b", b
    return a+b

编辑：有没有办法通过添加日志选项（true或false）使用装饰工厂来做到这一点？

Answer 1

装饰器工厂只是一个可调用的，可以生成实际的装饰器。它用于“配置”装饰器。

所以代替：

@decorator
def decorated_function():

你用的是：

@decorator_factory(arg1, arg2)
def decorated_function():

并且该调用将返回使用的实际装饰器。

这通常通过将装饰器嵌套在另一个函数中来实现，并使用该新外部函数的参数来调整返回的装饰器的行为。

对于你的样本装饰器，缩进你的装饰器（你可能想重命名它以减少混淆）并将它包装在一个带有logging参数的工厂函数中：

def before_run(logging=True):
    def decorator(func):
        print "hello from before run"
        def handle_arg(a,b):
            if(a>0):
                if logging:
                    print "Altering argument a to 100"
                a = 100
            return func(a,b)

        return handle_arg

    return decorator

我将原来的before_run()装饰器功能重命名为decorator，以明确这是工厂生产的装饰器。它最后返回;这个装饰器函数使用logging作为闭包来打开或关闭日志记录。

Answer 2

如果您希望通过参数动态控制装饰器的行为（就像使用任何常规函数一样），您可以使用装饰器工厂。例如，假设我想要一个在调用函数之前打印消息的装饰器。我可以这样做：

# Our decorator:
def print_message_decorator(func):
    # The wrapper (what we replace our decorated function with):
    def wrapper(*args, **kwargs):
        print('A function is being called.')
        result = func(*args, **kwargs)
        return result
    return wrapper

@print_message_decorator
def add(a, b):
    return a + b

@print_message_decorator
def subtract(a, b):
    return a - b

现在，如果我打电话给add或subtract，每个人都会打印A function is being called.

然而，现在说，我实际上想要动态生成装饰器，并且我希望能够自定义每个装饰函数打印出的消息。我通过让装饰师成为装饰工厂来解决这个问题。

# Our decorator factory:
def print_message_decorator_factory(msg):
    # The decorator it creates:
    def print_message_decorator(func):
        # The wrapper (what we replace our decorated function with):
        def wrapper(*args, **kwargs):
            print(msg)
            result = func(*args, **kwargs)
            return result
        return wrapper
    return print_message_decorator

@print_message_decorator_factory('Calling the add function.')
def add(a, b):
    return a + b

@print_message_decorator_factory('Calling the subtract function.')
def subtract(a, b):
    return a - b

现在，如果我打电话给add它打印Calling the add function.，如果我打电话给subtract它打印Calling the subtract function.

Answer 3

在python中，装饰器确实存在一些混淆。

这是因为：

• 正如其他人所指出的那样，带参数的装饰者实际上并不是装饰者而是装饰工厂。因此，要实现一个可以在没有参数和带参数的情况下调用的装饰器，这有点棘手。
• 人们倾向于认为装饰器必然是函数包装器，就像你的例子一样。但情况并非如此：装饰器可以完全用其他东西（甚至不是函数或类！）替换装饰的函数或类。

为了简化装饰师的发展，我写了decopatch。有了它，您不必关心：您的装饰器正确处理无括号和括号调用。

它支持两种开发风格：嵌套（如在python decorator工厂中）和flat（一个较少的嵌套级别）。这是您在平面模式下实现示例的方式：

from __future__ import print_function
from decopatch import function_decorator, DECORATED
from makefun import wraps

@function_decorator
def before_run(func=DECORATED):
    # (1) create a signature-preserving wrapper
    @wraps(func)
    def _func_wrapper(*f_args, **f_kwargs):
        print("hello from before run")
        if f_kwargs['a'] > 0:
            f_kwargs['a'] = 100
        return func(*f_args, **f_kwargs)

    # (2) return it
    return _func_wrapper

最后，它支持一种额外的开发风格，我称之为双平面，专门用于创建签名保留函数包装器。您的示例将实现如下：

from __future__ import print_function
from decopatch import function_decorator, WRAPPED, F_ARGS, F_KWARGS

@function_decorator
def before_run(func=WRAPPED, f_args=F_ARGS, f_kwargs=F_KWARGS):
    # this is directly the signature-preserving wrapper body
    print("hello from before run")
    if f_kwargs['a'] > 0:
        f_kwargs['a'] = 100
    return func(*f_args, **f_kwargs)

在这两种情况下，您都可以检查它是否正确运行：

@before_run
def running_func(a, b):
    print("a", a, "b", b)
    return a + b

assert running_func(-1, 2) == 1
assert running_func(1, 2) == 102

有关详细信息，请参阅documentation。