如何将额外参数传递给Python装饰器？

我有一个像下面这样的装饰师

def myDecorator(test_func):
    return callSomeWrapper(test_func)
def callSomeWrapper(test_func):
    return test_func
@myDecorator
def someFunc():
    print 'hello'

我想让这个装饰师接受下面的另一个论点

def myDecorator(test_func,logIt):
    if logIt:
        print "Calling Function: " + test_func.__name__
    return callSomeWrapper(test_func)
@myDecorator(False)
def someFunc():
    print 'Hello'

但是这个代码给出了错误

TypeError:myDecorator（）正好接受2个参数（给定1个）

---

为什么函数不能自动传递？如何显式地将函数传递给decorator函数？

因为您像调用函数一样调用decorator，它需要返回另一个函数，即实际的decorator：

def my_decorator(param):
    def actual_decorator(func):
        print("Decorating function {}, with parameter {}".format(func.__name__, param))
        return function_wrapper(func)  # assume we defined a wrapper somewhere
    return actual_decorator

外部函数将被赋予显式传递的任何参数，并且应该返回内部函数。内部函数将传递函数进行装饰，并返回修改后的函数

通常，您希望装饰程序通过将其包装到包装器函数中来更改函数行为。下面是一个示例，在调用函数时可以选择添加日志记录：

def log_decorator(log_enabled):
    def actual_decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            if log_enabled:
                print("Calling Function: " + func.__name__)
            return func(*args, **kwargs)
        return wrapper
    return actual_decorator

functools.wrapps

调用将名称和docstring之类的内容复制到包装器函数中，使其与原始函数更为相似

用法示例：

>>> @log_decorator(True)
... def f(x):
...     return x+1
...
>>> f(4)
Calling Function: f
5

---

由于您像调用函数一样调用decorator，因此它需要返回另一个函数，即实际的decorator：

def my_decorator(param):
    def actual_decorator(func):
        print("Decorating function {}, with parameter {}".format(func.__name__, param))
        return function_wrapper(func)  # assume we defined a wrapper somewhere
    return actual_decorator

外部函数将被赋予显式传递的任何参数，并且应该返回内部函数。内部函数将传递函数进行装饰，并返回修改后的函数

通常，您希望装饰程序通过将其包装到包装器函数中来更改函数行为。下面是一个示例，在调用函数时可以选择添加日志记录：

def log_decorator(log_enabled):
    def actual_decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            if log_enabled:
                print("Calling Function: " + func.__name__)
            return func(*args, **kwargs)
        return wrapper
    return actual_decorator

functools.wrapps

调用将名称和docstring之类的内容复制到包装器函数中，使其与原始函数更为相似

用法示例：

>>> @log_decorator(True)
... def f(x):
...     return x+1
...
>>> f(4)
Calling Function: f
5

---

只是为了提供一个不同的观点：语法

@expr
def func(...): #stuff

相当于

def func(...): #stuff
func = expr(func)

特别是，

expr

可以是您喜欢的任何内容，只要它的计算结果是可调用的。特别是，

expr

可以是一个decorator工厂：你给它一些参数，它给你一个decorator。因此，了解你的处境更好的方法可能是

dec = decorator_factory(*args)
@dec
def func(...):

然后可以缩短为

@decorator_factory(*args)
def func(...):

---

当然，由于它看起来像是一个装饰者，人们倾向于给它命名来反映这一点。当您试图遵循间接层次时，这可能会令人困惑。

只是为了提供一个不同的视角：语法

@expr
def func(...): #stuff

相当于

def func(...): #stuff
func = expr(func)

特别是，

expr

可以是您喜欢的任何内容，只要它的计算结果是可调用的。特别是，

expr

可以是一个decorator工厂：你给它一些参数，它给你一个decorator。因此，了解你的处境更好的方法可能是

dec = decorator_factory(*args)
@dec
def func(...):

然后可以缩短为

@decorator_factory(*args)
def func(...):

---

当然，由于它看起来像是一个装饰者，人们倾向于给它命名来反映这一点。当您尝试遵循间接寻址的级别时，这可能会令人困惑。

只想添加一些有用的技巧，使装饰参数成为可选参数。它还将有助于重用装饰器和减少嵌套

import functools

def myDecorator(test_func=None,logIt=None):
    if not test_func:
        return functools.partial(myDecorator, logIt=logIt)
    @functools.wraps(test_func)
    def f(*args, **kwargs):
        if logIt==1:
            print 'Logging level 1 for {}'.format(test_func.__name__)
        if logIt==2:
            print 'Logging level 2 for {}'.format(test_func.__name__)
        return test_func(*args, **kwargs)
    return f

#new decorator 
myDecorator_2 = myDecorator(logIt=2)

@myDecorator(logIt=2)
def pow2(i):
    return i**2

@myDecorator
def pow3(i):
    return i**3

@myDecorator_2
def pow4(i):
    return i**4

print pow2(2)
print pow3(2)
print pow4(2)

---

只是想添加一些有用的技巧，使装饰参数成为可选的。它还将有助于重用装饰器和减少嵌套

import functools

def myDecorator(test_func=None,logIt=None):
    if not test_func:
        return functools.partial(myDecorator, logIt=logIt)
    @functools.wraps(test_func)
    def f(*args, **kwargs):
        if logIt==1:
            print 'Logging level 1 for {}'.format(test_func.__name__)
        if logIt==2:
            print 'Logging level 2 for {}'.format(test_func.__name__)
        return test_func(*args, **kwargs)
    return f

#new decorator 
myDecorator_2 = myDecorator(logIt=2)

@myDecorator(logIt=2)
def pow2(i):
    return i**2

@myDecorator
def pow3(i):
    return i**3

@myDecorator_2
def pow4(i):
    return i**4

print pow2(2)
print pow3(2)
print pow4(2)

---

只是做装饰的另一种方式。 我发现这种方法最容易让我感到困惑

class NiceDecorator:
    def __init__(self, param_foo='a', param_bar='b'):
        self.param_foo = param_foo
        self.param_bar = param_bar

    def __call__(self, func):
        def my_logic(*args, **kwargs):
            # whatever logic your decorator is supposed to implement goes in here
            print('pre action baz')
            print(self.param_bar)
            # including the call to the decorated function (if you want to do that)
            result = func(*args, **kwargs)
            print('post action beep')
            return result

        return my_logic

# usage example from here on
@NiceDecorator(param_bar='baaar')
def example():
    print('example yay')


example()

---

只是做装饰的另一种方式。 我发现这种方法最容易让我感到困惑

class NiceDecorator:
    def __init__(self, param_foo='a', param_bar='b'):
        self.param_foo = param_foo
        self.param_bar = param_bar

    def __call__(self, func):
        def my_logic(*args, **kwargs):
            # whatever logic your decorator is supposed to implement goes in here
            print('pre action baz')
            print(self.param_bar)
            # including the call to the decorated function (if you want to do that)
            result = func(*args, **kwargs)
            print('post action beep')
            return result

        return my_logic

# usage example from here on
@NiceDecorator(param_bar='baaar')
def example():
    print('example yay')


example()

---

现在，如果要使用decorator调用函数

function1

，并且在这种情况下，函数和decorator都采用参数

def function1(a, b):
    print (a, b)

decorator_with_arg(10)(function1)(1, 2)

---

现在，如果要使用decorator调用函数

function1

，并且在这种情况下，函数和decorator都采用参数

def function1(a, b):
    print (a, b)

decorator_with_arg(10)(function1)(1, 2)

---

balki：请避免使用boolean作为您的参数，它不是gd方法，并减少代码的复杂性readliability@KitHo--这是一个布尔标志，所以使用布尔值是正确的方法。@KitHo--什么是“gd”？它“好”吗？balki：请避免使用boolean作为您的参数，它不是gd方法，并减少代码的复杂性readliability@KitHo--这是一个布尔标志，所以使用布尔值是正确的方法。@KitHo--什么是“gd”？它是否“好”？使用它是可取的——它保留了包装函数的原始名称、docstring等。@AKX：谢谢，我在第二个示例中添加了这一点。因此基本上，decorator只接受一个参数，即函数。但是decorator可以是一个函数的返回值，该函数可能包含参数。这是对的吗？@balki:是的，没错。令人困惑的是，许多人还将外部函数（

myDecorator

此处）称为decorator。这对decorator的用户来说很方便，但在您尝试编写decorator时可能会让人困惑。让我困惑的小细节是：如果您的

log\u decorator

采用默认参数，则不能使用

@log\u decorator

，它必须是

@log\u decorator（）

，并且建议使用它保留原始名称docstring，等等。@AKX:谢谢，我在第二个示例中添加了这个。所以基本上装饰器只接受一个参数，即函数。但是decorator可以是一个函数的返回值，该函数可能包含参数。这是对的吗？@balki:是的，没错。令人困惑的是，许多人还将外部函数（

myDecorator

此处）称为decorator。这对decorator的用户来说很方便，但当您试图编写一个decorator时可能会感到困惑。让我困惑的小细节是：如果您的

log\u decorator

采用默认参数，您不能使用

@log\u decorator

，它必须是

@log\u decorator（）

谢谢！我花了大约30分钟研究了一些令人费解的“解决方案”，这是第一个真正有意义的解决方案。谢谢！本，我一直在想些什么