如何创建函数装饰器并将它们链接在一起？

Question

如何创建函数装饰器并将它们链接在一起？

pythonfunctiondecoratorpython-decoratorschain

3146

我该如何在Python中创建两个装饰器以实现以下功能？

@make_bold
@make_italic
def say():
   return "Hello"

调用 say() 应该返回：

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

- Imran

1

参见：Python中“at”（@）符号有什么作用？ - Karl Knechtel

22个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- v4gil · Answer 1

这个问题早已有了答案，但我想分享我的装饰器类，可以使编写新的装饰器更加简单、紧凑。

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类型，因此在最终打印语句中，该方法被应用于列表本身，而不是列表的元素。

- nickleefly · Answer 2

#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.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")

- resigned · Answer 3

这里是一个简单的链接修饰器的例子。注意最后一行 - 它显示了在底层发生了什么。

############################################################
#
#    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>

- smarie · Answer 4

Paolo Bergantino的答案非常优秀，因为它仅使用标准库，并适用于此简单示例，其中没有装饰器参数或装饰函数参数。

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

如已在多个答案中提到的那样，您无法轻松修改代码以添加可选的装饰器参数。例如，创建一个makestyle（style ='bold'）装饰器是不容易的。
除此之外，使用@functools.wraps创建的包装器不会保留签名，因此如果提供了错误的参数，则它们将开始执行，并可能引发与通常的TypeError不同的错误。
最后，在使用@functools.wraps创建的包装器中，根据其名称访问参数相当困难。实际上，该参数可以出现在* args 、** kwargs 中，也可能根本不出现（如果它是可选的）。



我编写了decopatch来解决第一个问题，并编写了makefun.wraps来解决另外两个问题。请注意，makefun利用了与著名的decorator库相同的技巧。

这是如何创建具有参数的装饰器并返回真正保留签名的包装器的方法：

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


decopatch 提供了两种其他开发风格，根据您的喜好，隐藏或显示各种 Python 概念。 最紧凑的样式如下:

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

在这两种情况下，您可以检查装饰器是否按预期工作：
@makestyle
@makestyle('i')
def hello(who):
    return "hello %s" % who

assert hello('world') == '<b><i>hello world</i></b>'    


请参考文档获取详细信息。

- marqueed · Answer 5

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

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)），并且计数器变量将保持对每个函数私有。

- rabin utam · Answer 6

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

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

- user3844097 · Answer 7

考虑以下装饰器，请注意我们将wrapper()函数作为对象返回。

def make_bold(func):
    def wrapper():
        return '<b>'+func()+'</b>'
    return wrapper

所以这个

@make_bold
def say():
    return "Hello"

评估为

x = make_bold(say)

请注意，x不是say()函数本身，而是调用say()函数的包装器对象。这就是装饰器的工作方式。它始终返回调用实际函数的包装器对象。在链式调用的情况下。

@make_italic
@make_bold
def say():
    return "Hello"

会被转换成这个

x = make_bold(say)
y = make_italic(x)

以下是完整的代码。

def make_italic(func):
    def wrapper():
        return '<i>'+func()+'</i>'
    return wrapper


def make_bold(func):
    def wrapper():
        return '<b>'+func()+'</b>'
    return wrapper


@make_italic
@make_bold
def say():
    return "Hello"


if __name__ == '__main__':
    # x = make_bold(say) When you wrap say with make_bold decorator
    # y = make_italic(x) When you also add make_italic as part of chaining
    # print(y())
    print(say())

上述代码将返回

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

希望这有所帮助

- Sandipan Dey · Answer 8

嵌套装饰器绘制图像的另一个示例：

import matplotlib.pylab as plt

def remove_axis(func):
    def inner(img, alpha):
        plt.axis('off')
        func(img, alpha)
    return inner

def plot_gray(func):
    def inner(img, alpha):
        plt.gray()
        func(img, alpha)
    return inner

@remove_axis
@plot_gray
def plot_image(img, alpha):
    plt.imshow(img, alpha=alpha)
    plt.show()

现在，让我们使用嵌套的修饰符首先显示一个无坐标轴标签的彩色图像：

plot_image(plt.imread('lena_color.jpg'), 0.4)

接下来，让我们使用嵌套修饰符remove_axis和plot_gray展示一张没有坐标轴标签的灰度图像（我们需要cmap='gray'，否则默认的颜色映射是viridis，因此灰度图像默认不会以黑白阴影显示，除非明确指定）。

plot_image(plt.imread('lena_bw.jpg'), 0.8)

上述函数调用简化为以下嵌套调用

remove_axis(plot_gray(plot_image))(img, alpha)

- Kai - Kazuya Ito · Answer 9

使用下面的make_bold()和make_italic()：

def make_bold(func):
    def core(*args, **kwargs):
        result = func(*args, **kwargs)
        return "<b>" + result + "</b>"
    return core

def make_italic(func):
    def core(*args, **kwargs):
        result = func(*args, **kwargs)
        return "<i>" + result + "</i>"
    return core

您可以像下面展示的那样，将它们作为装饰器与say()一起使用：

@make_bold
@make_italic
def say():
   return "Hello"

print(say())

输出：

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

当然，您可以直接使用make_bold()和make_italic()而不使用装饰器，如下所示：

def say():
    return "Hello"
    
f1 = make_italic(say)
f2 = make_bold(f1)
result = f2()
print(result)

简而言之：

def say():
    return "Hello"
    
result = make_bold(make_italic(say))()
print(result)

输出：

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

- Alexey Nikonov · Answer 10

当您需要在装饰器中添加自定义参数并将其传递给最终函数进行处理时，我添加了一个案例。

以下是一些示例装饰器：

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']