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"

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

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

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

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'

or

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

不要忘了decorator语法是一种简写的构造：

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

Paolo Bergan蒂诺的答案具有只使用stdlib的巨大优势，适用于这个简单的示例，其中既没有修饰器参数，也没有修饰函数参数。

然而，如果您想处理更一般的情况，它有三个主要限制：

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

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

这是如何创建带有参数的装饰器，返回真正的签名保护包装器：

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

有关详细信息，请参阅文档。

当然，您也可以从decorator函数返回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()

装饰只是语法上的糖。

This

@decorator
def func():
    ...

扩展到

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

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

@deco
def do():
    ...

相当于：

do = deco(do)

例子：

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

This

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

相当于这个

def do2(number):
    return chr(number)

do2 = deco(do2)

65<=>“a”

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

要理解decorator，需要注意的是，decorator创建了一个新的函数do，它在内部执行函数并转换结果。