此代码段：

def decorator(func):
   return func

@decorator
def some_func():
    pass

相当于此代码：

def decorator(func):
    return func

def some_func():
    pass

some_func = decorator(some_func)

在装饰器的定义中，您可以添加一些通常不会由函数返回的修改后的内容。

Python中添加了修饰符，以使函数和方法包装（一种接收函数并返回增强函数的函数）更易于阅读和理解。最初的用例是能够将方法定义为类方法或静态方法。如果没有decorator语法，它将需要一个相当稀疏和重复的定义：

class WithoutDecorators:
def some_static_method():
    print("this is static method")
some_static_method = staticmethod(some_static_method)

def some_class_method(cls):
    print("this is class method")
some_class_method = classmethod(some_class_method)

如果decorator语法用于相同目的，则代码更短，更易于理解：

class WithDecorators:
    @staticmethod
    def some_static_method():
        print("this is static method")

    @classmethod
    def some_class_method(cls):
        print("this is class method")

一般语法和可能的实现

装饰器通常是一个命名对象（不允许使用lambda表达式），它在调用时接受一个参数（它将是装饰函数）并返回另一个可调用对象。这里使用“Callable”而不是有预谋的“function”。虽然装饰器通常在方法和函数的范围内讨论，但它们并不局限于它们。事实上，任何可调用的对象（任何实现_call__方法的对象都被认为是可调用的）都可以用作装饰器，它们返回的对象通常不是简单的函数，而是实现自己__call__方法的更复杂类的更多实例。

decorator语法只是一种语法糖。考虑以下装饰器用法：

@some_decorator
def decorated_function():
    pass

这总是可以通过显式的装饰器调用和函数重新分配来替换：

def decorated_function():
    pass
decorated_function = some_decorator(decorated_function)

然而，如果在单个函数上使用多个修饰符，则后者的可读性较差，也很难理解。装饰器可以多种不同的方式使用，如下所示：

作为一项功能

有许多方法可以编写自定义修饰符，但最简单的方法是编写一个函数，该函数返回一个子函数，该子函数包装原始函数调用。

通用模式如下：

def mydecorator(function):
    def wrapped(*args, **kwargs):
        # do some stuff before the original
        # function gets called
        result = function(*args, **kwargs)
        # do some stuff after function call and
        # return the result
        return result
    # return wrapper as a decorated function
    return wrapped

作为一个班级

虽然装饰器几乎总是可以使用函数实现，但在某些情况下，使用用户定义的类是更好的选择。当装饰器需要复杂的参数化或取决于特定状态时，这通常是正确的。

作为类的非参数化装饰器的通用模式如下：

class DecoratorAsClass:
    def __init__(self, function):
        self.function = function

    def __call__(self, *args, **kwargs):
        # do some stuff before the original
        # function gets called
        result = self.function(*args, **kwargs)
        # do some stuff after function call and
        # return the result
        return result

参数化装饰器

在实际代码中，通常需要使用可参数化的修饰符。当函数用作装饰器时，解决方案很简单——必须使用第二层包装。下面是一个装饰器的简单示例，它在每次调用装饰函数时都会重复执行指定次数的装饰函数：

def repeat(number=3):
"""Cause decorated function to be repeated a number of times.

Last value of original function call is returned as a result
:param number: number of repetitions, 3 if not specified
"""
def actual_decorator(function):
    def wrapper(*args, **kwargs):
        result = None
        for _ in range(number):
            result = function(*args, **kwargs)
        return result
    return wrapper
return actual_decorator

以这种方式定义的装饰器可以接受参数：

>>> @repeat(2)
... def foo():
...     print("foo")
...
>>> foo()
foo
foo

注意，即使参数化装饰器的参数具有默认值，其名称后面的括号也是必需的。将前面的修饰符与默认参数一起使用的正确方法如下：

>>> @repeat()
... def bar():
...     print("bar")
...
>>> bar()
bar
bar
bar

最后，让我们看看具有财产的装饰器。

财产

财产提供了一个内置的描述符类型，该类型知道如何将属性链接到一组方法。属性接受四个可选参数：fget、fset、fdel和doc。最后一个可以用来定义链接到属性的文档字符串，就像它是一个方法一样。下面是一个Rectangle类的示例，它可以通过直接访问存储两个角点的属性或使用宽度和高度财产进行控制：

class Rectangle:
    def __init__(self, x1, y1, x2, y2):
        self.x1, self.y1 = x1, y1
        self.x2, self.y2 = x2, y2

    def _width_get(self):
        return self.x2 - self.x1

    def _width_set(self, value):
        self.x2 = self.x1 + value

    def _height_get(self):
        return self.y2 - self.y1

    def _height_set(self, value):
        self.y2 = self.y1 + value

    width = property(
        _width_get, _width_set,
        doc="rectangle width measured from left"
    )
    height = property(
        _height_get, _height_set,
        doc="rectangle height measured from top"
    )

    def __repr__(self):
        return "{}({}, {}, {}, {})".format(
            self.__class__.__name__,
            self.x1, self.y1, self.x2, self.y2
    )

创建财产的最佳语法是将属性用作装饰器。这将减少类内方法签名的数量并使代码更加可读和可维护。对于decorator，上述类变为：

class Rectangle:
    def __init__(self, x1, y1, x2, y2):
        self.x1, self.y1 = x1, y1
        self.x2, self.y2 = x2, y2

    @property
    def width(self):
        """rectangle height measured from top"""
        return self.x2 - self.x1

    @width.setter
    def width(self, value):
        self.x2 = self.x1 + value

    @property
    def height(self):
        """rectangle height measured from top"""
        return self.y2 - self.y1

    @height.setter
    def height(self, value):
        self.y2 = self.y1 + value

行开头的@符号用于类和函数修饰符：

PEP 318：装饰Python装饰器

最常见的Python装饰器有：

@财产@分类法@静态方法

行中间的@可能是矩阵乘法：

@作为二进制运算符。

Python装饰器就像函数或类的包装器。这还是太概念化了。

def function_decorator(func):
    def wrapped_func():
        # Do something before the function is executed
        func()
        # Do something after the function has been executed
    return wrapped_func

上面的代码是装饰函数的装饰器的定义。function_decorator是装饰器的名称。

wrapped_func是内部函数的名称，实际上它只在这个decorator定义中使用。func是被修饰的函数。在内部函数wrapped_func中，我们可以在调用func之前和之后执行任何操作。在定义了decorator之后，我们只需按如下方式使用它。

@function_decorator
def func():
    pass

然后，每当我们调用函数func时，我们在decorator中定义的行为也将被执行。

例子：

from functools import wraps

def mydecorator(f):
    @wraps(f)
    def wrapped(*args, **kwargs):
        print "Before decorated function"
        r = f(*args, **kwargs)
        print "After decorated function"
        return r
    return wrapped

@mydecorator
def myfunc(myarg):
    print "my function", myarg
    return "return value"

r = myfunc('asdf')
print r

输出：

    Before decorated function
    my function asdf
    After decorated function
    return value

用不同的方式来表达别人的想法：是的，这是一个装饰师。

在Python中，它类似于：

创建函数（在@call下面）调用另一个函数对创建的函数进行操作。这将返回一个新函数。您调用的函数是@的参数。用返回的新函数替换定义的函数。

这可以用于各种有用的事情，因为函数是对象，只是必要的指令。

此代码段：

def decorator(func):
   return func

@decorator
def some_func():
    pass

相当于此代码：

def decorator(func):
    return func

def some_func():
    pass

some_func = decorator(some_func)

在装饰器的定义中，您可以添加一些通常不会由函数返回的修改后的内容。