在Python 3.5中，可以将@重载为运算符。它被命名为__matmul__，因为它被设计用于矩阵乘法，但它可以是任何你想要的。详见PEP465。

这是矩阵乘法的简单实现。

class Mat(list):
    def __matmul__(self, B):
        A = self
        return Mat([[sum(A[i][k]*B[k][j] for k in range(len(B)))
                    for j in range(len(B[0])) ] for i in range(len(A))])

A = Mat([[1,3],[7,5]])
B = Mat([[6,8],[4,2]])

print(A @ B)

此代码产生：

[[18, 14], [62, 66]]

此代码段：

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 3.5开始，“@”用作矩阵乘法的专用中缀符号（PEP 0465——请参见https://www.python.org/dev/peps/pep-0465/)

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

在Python 3.5中，可以将@重载为运算符。它被命名为__matmul__，因为它被设计用于矩阵乘法，但它可以是任何你想要的。详见PEP465。

这是矩阵乘法的简单实现。

class Mat(list):
    def __matmul__(self, B):
        A = self
        return Mat([[sum(A[i][k]*B[k][j] for k in range(len(B)))
                    for j in range(len(B[0])) ] for i in range(len(A))])

A = Mat([[1,3],[7,5]])
B = Mat([[6,8],[4,2]])

print(A @ B)

此代码产生：

[[18, 14], [62, 66]]

如果您引用的是python笔记本中使用Numpy库的一些代码，则@operator表示矩阵乘法。例如：

import numpy as np
def forward(xi, W1, b1, W2, b2):
    z1 = W1 @ xi + b1
    a1 = sigma(z1)
    z2 = W2 @ a1 + b2
    return z2, a1