如何在Python中创建两个执行以下操作的装饰器？

Question

如何在Python中创建两个可以执行以下操作的装饰器？

@makebold
@makeitalic
def say():
   return "Hello"

......应该返回：

"<b><i>Hello</i></b>"

我不是试图在一个真实的应用程序中以这种方式制作HTML - 只是想了解装饰器和装饰器链是如何工作的。

Answer 1

查看the documentation以了解装饰器的工作原理。这是你要求的：

from functools import wraps

def makebold(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return "<b>" + fn(*args, **kwargs) + "</b>"
    return wrapped

def makeitalic(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return "<i>" + fn(*args, **kwargs) + "</i>"
    return wrapped

@makebold
@makeitalic
def hello():
    return "hello world"

@makebold
@makeitalic
def log(s):
    return s

print hello()        # returns "<b><i>hello world</i></b>"
print hello.__name__ # with functools.wraps() this returns "hello"
print log('hello')   # returns "<b><i>hello</i></b>"

Answer 2

或者，您可以编写一个返回装饰器的工厂函数，该装饰器将装饰函数的返回值包装在传递给工厂函数的标记中。例如：

from functools import wraps

def wrap_in_tag(tag):
    def factory(func):
        @wraps(func)
        def decorator():
            return '<%(tag)s>%(rv)s</%(tag)s>' % (
                {'tag': tag, 'rv': func()})
        return decorator
    return factory

这使您可以写：

@wrap_in_tag('b')
@wrap_in_tag('i')
def say():
    return 'hello'

或

makebold = wrap_in_tag('b')
makeitalic = wrap_in_tag('i')

@makebold
@makeitalic
def say():
    return 'hello'

就我个人而言，我会以不同的方式编写装饰器：

from functools import wraps

def wrap_in_tag(tag):
    def factory(func):
        @wraps(func)
        def decorator(val):
            return func('<%(tag)s>%(val)s</%(tag)s>' %
                        {'tag': tag, 'val': val})
        return decorator
    return factory

会产生：

@wrap_in_tag('b')
@wrap_in_tag('i')
def say(val):
    return val
say('hello')

不要忘记装饰器语法是简写的构造：

say = wrap_in_tag('b')(wrap_in_tag('i')(say)))

Answer 3

看起来其他人已经告诉过你如何解决这个问题。我希望这能帮助你理解装饰器是什么。

装饰者只是语法糖。

此

@decorator
def func():
    ...

扩展为

def func():
    ...
func = decorator(func)

Answer 4

当然，您也可以从装饰器函数返回lambdas：

def makebold(f): 
    return lambda: "<b>" + f() + "</b>"
def makeitalic(f): 
    return lambda: "<i>" + f() + "</i>"

@makebold
@makeitalic
def say():
    return "Hello"

print say()

Answer 5

Python装饰器为另一个函数添加额外的功能

斜体装饰器可能就像

def makeitalic(fn):
    def newFunc():
        return "<i>" + fn() + "</i>"
    return newFunc

请注意，函数是在函数内定义的。它基本上做的是用新定义的函数替换函数。例如，我有这个类

class foo:
    def bar(self):
        print "hi"
    def foobar(self):
        print "hi again"

现在说，我希望两个函数在完成之后和之前打印“---”。我可以在每个print语句之前和之后添加一个打印“---”。但因为我不喜欢重复自己，我会做一个装饰师

def addDashes(fn): # notice it takes a function as an argument
    def newFunction(self): # define a new function
        print "---"
        fn(self) # call the original function
        print "---"
    return newFunction
    # Return the newly defined function - it will "replace" the original

所以现在我可以将课程改为

class foo:
    @addDashes
    def bar(self):
        print "hi"

    @addDashes
    def foobar(self):
        print "hi again"

有关装饰器的更多信息，请检查 http://www.ibm.com/developerworks/linux/library/l-cpdecor.html

Answer 6

你可以制作两个独立的装饰器来做你想要的，如下图所示。请注意在*args, **kwargs函数的声明中使用wrapped()，该函数支持具有多个参数的修饰函数（对于示例say()函数来说这不是必需的，但是为了通用性而包括在内）。

出于类似的原因，functools.wraps装饰器用于将包装函数的元属性更改为正在装饰的元属性。这使得错误消息和嵌入式函数文档（func.__doc__）成为装饰函数而不是wrapped()的函数。

from functools import wraps

def makebold(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return "<b>" + fn(*args, **kwargs) + "</b>"
    return wrapped

def makeitalic(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return "<i>" + fn(*args, **kwargs) + "</i>"
    return wrapped

@makebold
@makeitalic
def say():
    return 'Hello'

print(say())  # -> <b><i>Hello</i></b>

加细

正如您所看到的，这两个装饰器中有很多重复的代码。鉴于这种相似性，你最好制作一个实际上是装饰工厂的通用工具 - 换句话说，就是制作其他装饰器的装饰器。这样就可以减少代码重复次数 - 并允许遵循DRY原则。

def html_deco(tag):
    def decorator(fn):
        @wraps(fn)
        def wrapped(*args, **kwargs):
            return '<%s>' % tag + fn(*args, **kwargs) + '</%s>' % tag
        return wrapped
    return decorator

@html_deco('b')
@html_deco('i')
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>

为了使代码更具可读性，您可以为工厂生成的装饰器分配更具描述性的名称：

makebold = html_deco('b')
makeitalic = html_deco('i')

@makebold
@makeitalic
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>

甚至将它们组合起来：

makebolditalic = lambda fn: makebold(makeitalic(fn))

@makebolditalic
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>

效率

虽然上面的示例都可以正常工作，但是当一次应用多个装饰器时，生成的代码会以无关函数调用的形式涉及相当大的开销。这可能无关紧要，具体取决于具体用法（例如，可能是I / O绑定）。

如果装饰函数的速度很重要，可以通过编写稍微不同的装饰工厂函数来保持一个额外的函数调用，该函数实现一次添加所有标签，因此它可以生成避免附加的代码通过为每个标记使用单独的装饰器而产生的函数调用。

这需要装饰器本身有更多的代码，但这仅在它被应用于函数定义时运行，而不是在它们自身被调用时运行。当使用前面所示的lambda函数创建更易读的名称时，这也适用。样品：

def multi_html_deco(*tags):
    start_tags, end_tags = [], []
    for tag in tags:
        start_tags.append('<%s>' % tag)
        end_tags.append('</%s>' % tag)
    start_tags = ''.join(start_tags)
    end_tags = ''.join(reversed(end_tags))

    def decorator(fn):
        @wraps(fn)
        def wrapped(*args, **kwargs):
            return start_tags + fn(*args, **kwargs) + end_tags
        return wrapped
    return decorator

makebolditalic = multi_html_deco('b', 'i')

@makebolditalic
def greet(whom=''):
    return 'Hello' + (' ' + whom) if whom else ''

print(greet('world'))  # -> <b><i>Hello world</i></b>

Answer 7

另一种做同样事情的方法：

class bol(object):
  def __init__(self, f):
    self.f = f
  def __call__(self):
    return "<b>{}</b>".format(self.f())

class ita(object):
  def __init__(self, f):
    self.f = f
  def __call__(self):
    return "<i>{}</i>".format(self.f())

@bol
@ita
def sayhi():
  return 'hi'

或者，更灵活：

class sty(object):
  def __init__(self, tag):
    self.tag = tag
  def __call__(self, f):
    def newf():
      return "<{tag}>{res}</{tag}>".format(res=f(), tag=self.tag)
    return newf

@sty('b')
@sty('i')
def sayhi():
  return 'hi'

Answer 8

如何在Python中创建两个执行以下操作的装饰器？

调用时需要以下函数：

@makebold
@makeitalic
def say():
    return "Hello"

要返回：

<b><i>Hello</i></b>

简单解决方案

最简单的做法是，使装饰器返回关闭函数（闭包）的lambdas（匿名函数）并调用它：

def makeitalic(fn):
    return lambda: '<i>' + fn() + '</i>'

def makebold(fn):
    return lambda: '<b>' + fn() + '</b>'

现在根据需要使用它们：

@makebold
@makeitalic
def say():
    return 'Hello'

现在：

>>> say()
'<b><i>Hello</i></b>'

简单解决方案的问题

但我们似乎几乎失去了原有的功能。

>>> say
<function <lambda> at 0x4ACFA070>

为了找到它，我们需要挖掘每个lambda的闭合，其中一个被埋在另一个中：

>>> say.__closure__[0].cell_contents
<function <lambda> at 0x4ACFA030>
>>> say.__closure__[0].cell_contents.__closure__[0].cell_contents
<function say at 0x4ACFA730>

因此，如果我们将文档放在这个函数上，或者希望能够装饰带有多个参数的函数，或者我们只是想知道我们在调试会话中看到了什么函数，我们需要做一些更多与我们的包装。

全功能解决方案 - 克服大多数这些问题

我们有来自标准库中wraps模块的装饰器functools！

from functools import wraps

def makeitalic(fn):
    # must assign/update attributes from wrapped function to wrapper
    # __module__, __name__, __doc__, and __dict__ by default
    @wraps(fn) # explicitly give function whose attributes it is applying
    def wrapped(*args, **kwargs):
        return '<i>' + fn(*args, **kwargs) + '</i>'
    return wrapped

def makebold(fn):
    @wraps(fn)
    def wrapped(*args, **kwargs):
        return '<b>' + fn(*args, **kwargs) + '</b>'
    return wrapped

遗憾的是还有一些样板，但这就像我们能做到的那样简单。

在Python 3中，默认情况下您还会分配__qualname__和__annotations__。

现在：

@makebold
@makeitalic
def say():
    """This function returns a bolded, italicized 'hello'"""
    return 'Hello'

现在：

>>> say
<function say at 0x14BB8F70>
>>> help(say)
Help on function say in module __main__:

say(*args, **kwargs)
    This function returns a bolded, italicized 'hello'

结论

所以我们看到wraps使包装函数几乎完成所有操作，除了告诉我们函数作为参数的确切内容。

还有其他模块可能会尝试解决此问题，但该解决方案尚未出现在标准库中。

Answer 9

装饰器接受函数定义并创建一个执行此函数并转换结果的新函数。

@deco
def do():
    ...

完全符合：

do = deco(do)

实施例

def deco(func):
    def inner(letter):
        return func(letter).upper()  #upper
    return inner

此

@deco
def do(number):
    return chr(number)  # number to letter

与此等效 def do2（数字）： return chr（number）

do2 = deco(do2)

65＆lt; =＆gt; 'A'

print(do(65))
print(do2(65))
>>> B
>>> B

要理解装饰器，重要的是要注意，装饰器创建了一个新的函数do，它执行func并转换结果。

Answer 10

以更简单的方式解释装饰器：

使用：

@decor1
@decor2
def func(*args, **kwargs):
    pass

何时：

func(*args, **kwargs)

你真的这样做：

decor1(decor2(func))(*args, **kwargs)

Answer 11

#decorator.py
def makeHtmlTag(tag, *args, **kwds):
    def real_decorator(fn):
        css_class = " class='{0}'".format(kwds["css_class"]) \
                                 if "css_class" in kwds else ""
        def wrapped(*args, **kwds):
            return "<"+tag+css_class+">" + fn(*args, **kwds) + "</"+tag+">"
        return wrapped
    # return decorator dont call it
    return real_decorator

@makeHtmlTag(tag="b", css_class="bold_css")
@makeHtmlTag(tag="i", css_class="italic_css")
def hello():
    return "hello world"

print hello()

你也可以在Class

中编写装饰器

#class.py
class makeHtmlTagClass(object):
    def __init__(self, tag, css_class=""):
        self._tag = tag
        self._css_class = " class='{0}'".format(css_class) \
                                       if css_class != "" else ""

    def __call__(self, fn):
        def wrapped(*args, **kwargs):
            return "<" + self._tag + self._css_class+">"  \
                       + fn(*args, **kwargs) + "</" + self._tag + ">"
        return wrapped

@makeHtmlTagClass(tag="b", css_class="bold_css")
@makeHtmlTagClass(tag="i", css_class="italic_css")
def hello(name):
    return "Hello, {}".format(name)

print hello("Your name")

Answer 12

这是一个链接装饰器的简单示例。请注意最后一行 - 它显示了幕后的内容。

############################################################
#
#    decorators
#
############################################################

def bold(fn):
    def decorate():
        # surround with bold tags before calling original function
        return "<b>" + fn() + "</b>"
    return decorate


def uk(fn):
    def decorate():
        # swap month and day
        fields = fn().split('/')
        date = fields[1] + "/" + fields[0] + "/" + fields[2]
        return date
    return decorate

import datetime
def getDate():
    now = datetime.datetime.now()
    return "%d/%d/%d" % (now.day, now.month, now.year)

@bold
def getBoldDate(): 
    return getDate()

@uk
def getUkDate():
    return getDate()

@bold
@uk
def getBoldUkDate():
    return getDate()


print getDate()
print getBoldDate()
print getUkDate()
print getBoldUkDate()
# what is happening under the covers
print bold(uk(getDate))()

输出如下：

17/6/2013
<b>17/6/2013</b>
6/17/2013
<b>6/17/2013</b>
<b>6/17/2013</b>

Answer 13

这个答案已经很久了，但是我想我应该分享我的Decorator类，它使编写新的装饰器变得简单而紧凑。

from abc import ABCMeta, abstractclassmethod

class Decorator(metaclass=ABCMeta):
    """ Acts as a base class for all decorators """

    def __init__(self):
        self.method = None

    def __call__(self, method):
        self.method = method
        return self.call

    @abstractclassmethod
    def call(self, *args, **kwargs):
        return self.method(*args, **kwargs)

我认为这可以使装饰器的行为非常清楚，但是也可以使简洁地定义新装饰器变得容易。对于上面列出的示例，您可以将其解决为：

class MakeBold(Decorator):
    def call():
        return "<b>" + self.method() + "</b>"

class MakeItalic(Decorator):
    def call():
        return "<i>" + self.method() + "</i>"

@MakeBold()
@MakeItalic()
def say():
   return "Hello"

您还可以使用它来执行更复杂的任务，例如装饰器，它会自动使该函数递归地应用于迭代器中的所有参数：

class ApplyRecursive(Decorator):
    def __init__(self, *types):
        super().__init__()
        if not len(types):
            types = (dict, list, tuple, set)
        self._types = types

    def call(self, arg):
        if dict in self._types and isinstance(arg, dict):
            return {key: self.call(value) for key, value in arg.items()}

        if set in self._types and isinstance(arg, set):
            return set(self.call(value) for value in arg)

        if tuple in self._types and isinstance(arg, tuple):
            return tuple(self.call(value) for value in arg)

        if list in self._types and isinstance(arg, list):
            return list(self.call(value) for value in arg)

        return self.method(arg)


@ApplyRecursive(tuple, set, dict)
def double(arg):
    return 2*arg

print(double(1))
print(double({'a': 1, 'b': 2}))
print(double({1, 2, 3}))
print(double((1, 2, 3, 4)))
print(double([1, 2, 3, 4, 5]))

哪些印刷品：

2
{'a': 2, 'b': 4}
{2, 4, 6}
(2, 4, 6, 8)
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

请注意，此示例在装饰器的实例中未包括list类型，因此在最终的打印语句中，该方法将应用于列表本身，而不是列表的元素。

Answer 14

说到反例 - 如上所述，计数器将在使用装饰器的所有函数之间共享：

def counter(func):
    def wrapped(*args, **kws):
        print 'Called #%i' % wrapped.count
        wrapped.count += 1
        return func(*args, **kws)
    wrapped.count = 0
    return wrapped

这样，您的装饰器可以重复用于不同的函数（或用于多次装饰相同的函数：func_counter1 = counter(func); func_counter2 = counter(func)），并且计数器变量将保持对每个函数都是私有的。

Answer 15

用不同数量的参数装饰函数：

def frame_tests(fn):
    def wrapper(*args):
        print "\nStart: %s" %(fn.__name__)
        fn(*args)
        print "End: %s\n" %(fn.__name__)
    return wrapper

@frame_tests
def test_fn1():
    print "This is only a test!"

@frame_tests
def test_fn2(s1):
    print "This is only a test! %s" %(s1)

@frame_tests
def test_fn3(s1, s2):
    print "This is only a test! %s %s" %(s1, s2)

if __name__ == "__main__":
    test_fn1()
    test_fn2('OK!')
    test_fn3('OK!', 'Just a test!')

结果：

Start: test_fn1  
This is only a test!  
End: test_fn1  


Start: test_fn2  
This is only a test! OK!  
End: test_fn2  


Start: test_fn3  
This is only a test! OK! Just a test!  
End: test_fn3

Answer 16

Paolo Bergantino's answer具有仅使用stdlib的巨大优势，并且适用于没有 decorator 参数或 decorated function 参数的简单示例。

但是，如果要处理更一般的情况，它有3个主要限制：

已经在几个答案中指出，您不能轻松地修改代码以添加可选的装饰器参数。例如，创建一个makestyle(style='bold')装饰器并非易事。
此外，使用@functools.wraps创建的包装器不会保留签名，因此，如果提供了错误的参数，它们将开始执行，并且可能会引发与通常的{{ 1}}。
最后，在用TypeError创建的包装器中，很难基于其名称访问参数。实际上，该参数可以出现在@functools.wraps，*args中，也可以根本不出现（如果它是可选的）。

我写了decopatch解决了第一个问题，写了makefun.wraps解决了另外两个问题。请注意，**kwargs与著名的decorator lib具有相同的技巧。

这是创建带有参数的装饰器的方法，返回真正保留签名的包装器：

makefun

from decopatch import function_decorator, DECORATED from makefun import wraps @function_decorator def makestyle(st='b', fn=DECORATED): open_tag = "<%s>" % st close_tag = "</%s>" % st @wraps(fn) def wrapped(*args, **kwargs): return open_tag + fn(*args, **kwargs) + close_tag return wrapped为您提供了另外两种开发样式，它们根据您的喜好隐藏或显示各种python概念。最紧凑的样式如下：

decopatch

在两种情况下，您都可以检查装饰器是否按预期工作：

from decopatch import function_decorator, WRAPPED, F_ARGS, F_KWARGS

@function_decorator
def makestyle(st='b', fn=WRAPPED, f_args=F_ARGS, f_kwargs=F_KWARGS):
    open_tag = "<%s>" % st
    close_tag = "</%s>" % st
    return open_tag + fn(*f_args, **f_kwargs) + close_tag

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

Answer 17

当您需要在装饰器中添加自定义参数时，我添加了一个案例，将其传递给最终函数然后使用它。

装饰者：

def jwt_or_redirect(fn):
  @wraps(fn)
  def decorator(*args, **kwargs):
    ...
    return fn(*args, **kwargs)
  return decorator

def jwt_refresh(fn):
  @wraps(fn)
  def decorator(*args, **kwargs):
    ...
    new_kwargs = {'refreshed_jwt': 'xxxxx-xxxxxx'}
    new_kwargs.update(kwargs)
    return fn(*args, **new_kwargs)
  return decorator

和最终函数：

@app.route('/')
@jwt_or_redirect
@jwt_refresh
def home_page(*args, **kwargs):
  return kwargs['refreched_jwt']

如何制作一系列功能装饰器？

18 个答案:

加细

效率

如何在Python中创建两个执行以下操作的装饰器？

简单解决方案

简单解决方案的问题

全功能解决方案 - 克服大多数这些问题

结论

实施例

用不同数量的参数装饰函数：