我有一个像下面这样的装饰器。
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 个给定）
为什么函数没有自动传递？如何将函数显式传递给装饰器函数？
由于您像调用函数一样调用装饰器，因此它需要返回另一个作为实际装饰器的函数：
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.wraps调用将名称和文档字符串等内容复制到包装函数，以使其与原始函数更相似。
示例用法：
>>> @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可以是一个装饰器工厂：你给它一些参数，它给你一个装饰器。因此，了解您的情况的更好方法可能是
dec = decorator_factory(*args)
@dec
def func(...):
然后可以缩短为
@decorator_factory(*args)
def func(...):
当然，由于它看起来像是decorator_factory一个装饰器，所以人们倾向于将其命名以反映这一点。当您尝试遵循间接级别时，这可能会令人困惑。
只是想添加一些有用的技巧，允许装饰器参数可选。它还将允许重用装饰器并减少嵌套
import functools
def myDecorator(test_func=None,logIt=None):
if test_func is None:
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()
现在，如果你想function1用装饰器调用一个函数decorator_with_arg，在这种情况下，函数和装饰器都带参数，
def function1(a, b):
print (a, b)
decorator_with_arg(10)(function1)(1, 2)