我想创建一个可以与参数一起使用的Python装饰器：
@redirect_output("somewhere.log")
def foo():
....
或没有它们（例如，默认情况下将输出重定向到stderr）：
@redirect_output
def foo():
....
那可能吗？
请注意，我不是在寻找重定向输出问题的不同解决方案，它只是我想要实现的语法的一个示例。
答案 0 :(得分：49)
我知道这个问题很老，但有些评论是新的，虽然所有可行的解决方案基本相同，但大多数都不是很干净或易于阅读。
就像thobe的回答所说，处理这两种情况的唯一方法是检查这两种情况。最简单的方法就是检查是否有一个参数并且它是callabe（注意：如果你的装饰器只接受1个参数并且碰巧是一个可调用的对象，则需要额外的检查）：
def decorator(*args, **kwargs):
if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
# called as @decorator
else:
# called as @decorator(*args, **kwargs)
在第一种情况下，您执行任何普通装饰器所做的操作，返回传入函数的修改或包装版本。
在第二种情况下，你返回一个'new'装饰器，它以某种方式使用* args传递的信息，** kwargs。
这很好，但是必须为你制作的每个装饰师写出来都可能非常烦人而且不那么干净。相反，能够自动修改我们的装饰器而不必重新编写它们会很好......但这就是装饰器的用途！
使用以下装饰器装饰器，我们可以取消装饰器，以便它们可以使用或不使用参数：
def doublewrap(f):
'''
a decorator decorator, allowing the decorator to be used as:
@decorator(with, arguments, and=kwargs)
or
@decorator
'''
@wraps(f)
def new_dec(*args, **kwargs):
if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
# actual decorated function
return f(args[0])
else:
# decorator arguments
return lambda realf: f(realf, *args, **kwargs)
return new_dec
现在，我们可以使用@doublewrap来装饰我们的装饰器，它们可以使用和不使用参数，但需要注意一点：
我在上面已经注意到了，但是应该重复一遍，这个装饰器中的检查假设装饰器可以接收的参数（即它不能接收单个可调用的参数）。由于我们现在使其适用于任何发电机，因此需要牢记，或者如果它会发生矛盾则进行修改。
以下说明了它的用法：
def test_doublewrap():
from util import doublewrap
from functools import wraps
@doublewrap
def mult(f, factor=2):
'''multiply a function's return value'''
@wraps(f)
def wrap(*args, **kwargs):
return factor*f(*args,**kwargs)
return wrap
# try normal
@mult
def f(x, y):
return x + y
# try args
@mult(3)
def f2(x, y):
return x*y
# try kwargs
@mult(factor=5)
def f3(x, y):
return x - y
assert f(2,3) == 10
assert f2(2,5) == 30
assert f3(8,1) == 5*7
答案 1 :(得分：29)
使用带有默认值的关键字参数（如kquinn所建议）是一个好主意，但需要包含括号：
@redirect_output()
def foo():
...
如果您希望版本在装饰器上没有括号的情况下工作，则必须在装饰器代码中考虑这两种情况。
如果您使用的是Python 3.0，则可以使用仅限关键字的参数：
def redirect_output(fn=None,*,destination=None):
destination = sys.stderr if destination is None else destination
def wrapper(*args, **kwargs):
... # your code here
if fn is None:
def decorator(fn):
return functools.update_wrapper(wrapper, fn)
return decorator
else:
return functools.update_wrapper(wrapper, fn)
在Python 2.x中，可以使用varargs技巧模拟：
def redirected_output(*fn,**options):
destination = options.pop('destination', sys.stderr)
if options:
raise TypeError("unsupported keyword arguments: %s" %
",".join(options.keys()))
def wrapper(*args, **kwargs):
... # your code here
if fn:
return functools.update_wrapper(wrapper, fn[0])
else:
def decorator(fn):
return functools.update_wrapper(wrapper, fn)
return decorator
任何这些版本都允许您编写如下代码：
@redirected_output
def foo():
...
@redirected_output(destination="somewhere.log")
def bar():
...
答案 2 :(得分：12)
您需要检测这两种情况，例如使用第一个参数的类型，并相应地返回包装器（在没有参数的情况下使用时）或装饰器（当与参数一起使用时）。
from functools import wraps
import inspect
def redirect_output(fn_or_output):
def decorator(fn):
@wraps(fn)
def wrapper(*args, **args):
# Redirect output
try:
return fn(*args, **args)
finally:
# Restore output
return wrapper
if inspect.isfunction(fn_or_output):
# Called with no parameter
return decorator(fn_or_output)
else:
# Called with a parameter
return decorator
使用@redirect_output("output.log")语法时，使用单个参数redirect_output调用"output.log"，并且它必须返回一个装饰器，接受要作为参数装饰的函数。当用作@redirect_output时，它将直接调用函数作为参数进行修饰。
或者换句话说：@语法后面必须跟一个表达式，该表达式的结果是一个函数，它接受一个要作为其唯一参数进行修饰的函数，并返回修饰函数。表达式本身可以是函数调用，@redirect_output("output.log")就是这种情况。令人困惑，但确实如此： - ）
答案 3 :(得分：8)
根据您是否给出参数，以一种根本不同的方式调用python decorator。装饰实际上只是一个（语法限制）表达。
在你的第一个例子中：
@redirect_output("somewhere.log")
def foo():
....
使用函数调用函数redirect_output
给定的参数，预计会返回装饰器
函数，它本身以foo为参数调用，
哪个（最后！）预计将返回最终的装饰函数。
等效代码如下所示：
def foo():
....
d = redirect_output("somewhere.log")
foo = d(foo)
第二个示例的等效代码如下：
def foo():
....
d = redirect_output
foo = d(foo)
所以你可以做你想做的事，但不是完全无缝的：
import types
def redirect_output(arg):
def decorator(file, f):
def df(*args, **kwargs):
print 'redirecting to ', file
return f(*args, **kwargs)
return df
if type(arg) is types.FunctionType:
return decorator(sys.stderr, arg)
return lambda f: decorator(arg, f)
除非你想使用一个函数，否则这应该没问题 装饰器的参数，在这种情况下装饰器 将错误地认为它没有参数。它也会失败 如果这种装饰适用于另一种装饰 不返回函数类型。
另一种方法就是要求 总是调用decorator函数，即使它没有参数。 在这种情况下，您的第二个示例如下所示：
@redirect_output()
def foo():
....
装饰器功能代码如下所示：
def redirect_output(file = sys.stderr):
def decorator(file, f):
def df(*args, **kwargs):
print 'redirecting to ', file
return f(*args, **kwargs)
return df
return lambda f: decorator(file, f)
答案 4 :(得分：6)
我知道这是一个老问题，但我真的不喜欢任何提议的技术，所以我想添加另一种方法。我看到django在login_required decorator in django.contrib.auth.decorators中使用了一种非常干净的方法。正如您在decorator's docs中所看到的，它可以单独用作@login_required或带参数@login_required(redirect_field_name='my_redirect_field')。
他们这样做很简单。他们在装饰器参数之前添加kwarg（function=None）。如果单独使用装饰器，function将是它正在装饰的实际功能，而如果使用参数调用它，function将是None。
示例：
from functools import wraps
def custom_decorator(function=None, some_arg=None, some_other_arg=None):
def actual_decorator(f):
@wraps(f)
def wrapper(*args, **kwargs):
# Do stuff with args here...
if some_arg:
print(some_arg)
if some_other_arg:
print(some_other_arg)
return f(*args, **kwargs)
return wrapper
if function:
return actual_decorator(function)
return actual_decorator
@custom_decorator
def test1():
print('test1')
>>> test1()
test1
@custom_decorator(some_arg='hello')
def test2():
print('test2')
>>> test2()
hello
test2
@custom_decorator(some_arg='hello', some_other_arg='world')
def test3():
print('test3')
>>> test3()
hello
world
test3
我发现django使用的这种方法比这里提出的任何其他技术更优雅，更容易理解。
答案 5 :(得分：4)
这里的几个答案已经很好地解决了你的问题。然而，就风格而言，我更喜欢使用functools.partial来解决这个装饰困境，正如David Beazley的 Python Cookbook 3 中所建议的那样：
from functools import partial, wraps
def decorator(func=None, foo='spam'):
if func is None:
return partial(decorator, foo=foo)
@wraps(func)
def wrapper(*args, **kwargs):
# do something with `func` and `foo`, if you're so inclined
pass
return wrapper
虽然是，但你可以做到
@decorator()
def f(*args, **kwargs):
pass
没有时髦的解决方法，我觉得它看起来很奇怪，而且我喜欢选择简单地用@decorator进行装饰。
至于次要任务目标，在Stack Overflow post中解决了重定向函数输出的问题。
如果您想深入了解，请查看 Python Cookbook 3 中的第9章（元编程），该版本可免费提供给read online。
Beazley的精彩YouTube视频Python 3 Metaprogramming中有些资料是现场演示（还有更多！）。
快乐编码：）
答案 6 :(得分：1)
事实上，@ bj0解决方案中的警告案例很容易检查：
def meta_wrap(decor):
@functools.wraps(decor)
def new_decor(*args, **kwargs):
if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
# this is the double-decorated f.
# Its first argument should not be a callable
doubled_f = decor(args[0])
@functools.wraps(doubled_f)
def checked_doubled_f(*f_args, **f_kwargs):
if callable(f_args[0]):
raise ValueError('meta_wrap failure: '
'first positional argument cannot be callable.')
return doubled_f(*f_args, **f_kwargs)
return checked_doubled_f
else:
# decorator arguments
return lambda real_f: decor(real_f, *args, **kwargs)
return new_decor
以下是此meta_wrap的故障安全版本的一些测试用例。
@meta_wrap
def baddecor(f, caller=lambda x: -1*x):
@functools.wraps(f)
def _f(*args, **kwargs):
return caller(f(args[0]))
return _f
@baddecor # used without arg: no problem
def f_call1(x):
return x + 1
assert f_call1(5) == -6
@baddecor(lambda x : 2*x) # bad case
def f_call2(x):
return x + 1
f_call2(5) # raises ValueError
# explicit keyword: no problem
@baddecor(caller=lambda x : 100*x)
def f_call3(x):
return x + 1
assert f_call3(5) == 600
答案 7 :(得分：0)
要给出比上述更完整的答案：
“有没有一种方法可以构建既可以带参数也可以不带参数的装饰器？”
否没有通用的方法，因为python语言目前缺少某些东西来检测两个不同的用例。
然而，如其他答案（如bj0s所指出的，是），有一种笨拙的解决方法，用于检查第一个方法的类型和值收到位置参数（并检查是否没有其他参数具有非默认值）。如果您保证用户不会从不传递可调用方法作为装饰器的第一个参数，则可以使用此替代方法。请注意，这对于类装饰器是相同的（替换可在上一句中由类调用）。
为确保上述内容，我在那里进行了大量研究，甚至实现了一个名为decopatch的库，该库结合了以上引用的所有策略（包括内省在内的更多策略）来执行“哪种方法最聪明”，具体取决于您的需求。
但是坦率地说，最好的办法是这里不需要任何库并直接从python语言获得该功能。如果像我一样，您认为python语言到今天还没有能力提供这个问题的简洁答案是很可惜的，请不要犹豫在python bugtracker中支持该想法： https://bugs.python.org/issue36553！
非常感谢您为使python成为更好的语言而提供的帮助：）
答案 8 :(得分：0)
这可以毫不费力地完成这项工作：
from functools import wraps
def memoize(fn=None, hours=48.0):
def deco(fn):
@wraps(fn)
def wrapper(*args, **kwargs):
return fn(*args, **kwargs)
return wrapper
if callable(fn): return deco(fn)
return deco
答案 9 :(得分：0)
由于没有人提到这一点，所以还有一种使用可调用类的解决方案，我发现它更优雅，特别是在装饰器很复杂并且可能希望将其拆分为多个方法（函数）的情况下。该解决方案利用__new__魔术方法来完成其他人指出的操作。首先检测装饰器的使用方式，然后适当地调整回报率。
class decorator_with_arguments(object):
def __new__(cls, decorated_function=None, **kwargs):
self = super().__new__(cls)
self._init(**kwargs)
if not decorated_function:
return self
else:
return self.__call__(decorated_function)
def _init(self, arg1="default", arg2="default", arg3="default"):
self.arg1 = arg1
self.arg2 = arg2
self.arg3 = arg3
def __call__(self, decorated_function):
def wrapped_f(*args):
print("Decorator arguments:", self.arg1, self.arg2, self.arg3)
print("decorated_function arguments:", *args)
decorated_function(*args)
return wrapped_f
@decorator_with_arguments(arg1=5)
def sayHello(a1, a2, a3, a4):
print('sayHello arguments:', a1, a2, a3, a4)
@decorator_with_arguments()
def sayHello(a1, a2, a3, a4):
print('sayHello arguments:', a1, a2, a3, a4)
@decorator_with_arguments
def sayHello(a1, a2, a3, a4):
print('sayHello arguments:', a1, a2, a3, a4)
如果装饰器与参数一起使用，则等于：
result = decorator_with_arguments(arg1=5)(sayHello)(a1, a2, a3, a4)
可以看到参数arg1已正确传递给构造函数，修饰后的函数已传递给__call__
但是如果装饰器不带参数使用，则等于：
result = decorator_with_arguments(sayHello)(a1, a2, a3, a4)
您会看到在这种情况下，修饰后的函数直接传递给构造函数，并且完全省略了对__call__的调用。这就是为什么我们需要采用逻辑来解决__new__魔术方法中的这种情况。
为什么我们不能使用__init__而不是__new__？原因很简单：python禁止从__init__
警告
这种方法有一个副作用。它不会保留功能签名！
答案 10 :(得分：-1)
您是否尝试过使用默认值的关键字参数？像
这样的东西def decorate_something(foo=bar, baz=quux):
pass
答案 11 :(得分：-2)
通常你可以在Python中给出默认参数......
def redirect_output(fn, output = stderr):
# whatever
不确定是否适用于装饰器。我不知道为什么不会这样做。
答案 12 :(得分：-2)
以vartec的回答为基础：
imports sys
def redirect_output(func, output=None):
if output is None:
output = sys.stderr
if isinstance(output, basestring):
output = open(output, 'w') # etc...
# everything else...