@符号在Python中做什么？
当前回答
行开头的@符号用于类和函数修饰符：
PEP 318：装饰Python装饰器
最常见的Python装饰器有：
@财产@分类法@静态方法
行中间的@可能是矩阵乘法：
@作为二进制运算符。
其他回答
实例
class Pizza(object):
def __init__(self):
self.toppings = []
def __call__(self, topping):
# When using '@instance_of_pizza' before a function definition
# the function gets passed onto 'topping'.
self.toppings.append(topping())
def __repr__(self):
return str(self.toppings)
pizza = Pizza()
@pizza
def cheese():
return 'cheese'
@pizza
def sauce():
return 'sauce'
print pizza
# ['cheese', 'sauce']
这表明，在装饰器之后定义的函数/方法/类基本上只是作为参数传递给@符号之后的函数/函数。
第一次目击
微框架Flask从一开始就以以下格式介绍装饰器：
from flask import Flask
app = Flask(__name__)
@app.route("/")
def hello():
return "Hello World!"
这反过来又转化为：
rule = "/"
view_func = hello
# They go as arguments here in 'flask/app.py'
def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
pass
意识到这一点，我终于可以和弗拉斯克和平相处了。
“at”（@）符号在Python中做什么？
@符号是python提供的利用装饰器的语法糖，套用一个问题，这正是关于decorator在Python中做什么的？
简单地说，decorator允许您修改给定函数的定义，而不触及其最内部（它是闭包）。当你从第三方进口精彩的包装时，这是最常见的情况。你可以想象它，你可以使用它，但你不能触摸它的内心和内心。
这里是一个快速示例，假设我在Ipython上定义了read_a_book函数
In [9]: def read_a_book():
...: return "I am reading the book: "
...:
In [10]: read_a_book()
Out[10]: 'I am reading the book: '
你看，我忘了给它加个名字。如何解决这样的问题？当然，我可以将函数重新定义为：
def read_a_book():
return "I am reading the book: 'Python Cookbook'"
然而，如果不允许我操作原始函数，或者如果有数千个这样的函数需要处理，该怎么办。
通过不同的思维来解决问题，并定义一个新的函数
def add_a_book(func):
def wrapper():
return func() + "Python Cookbook"
return wrapper
然后使用它。
In [14]: read_a_book = add_a_book(read_a_book)
In [15]: read_a_book()
Out[15]: 'I am reading the book: Python Cookbook'
塔达，你看，我修改了read_a_book，但没有触及它的内部封口。没有什么能阻止我配备装修工。
关于什么@
@add_a_book
def read_a_book():
return "I am reading the book: "
In [17]: read_a_book()
Out[17]: 'I am reading the book: Python Cookbook'
@add_a_book是一种新奇而方便的方式来表示read_a_book=add_a_bok（read_a_bok），这是一种语法糖，没有什么比它更令人着迷的了。
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
此代码段：
def decorator(func):
return func
@decorator
def some_func():
pass
相当于此代码：
def decorator(func):
return func
def some_func():
pass
some_func = decorator(some_func)
在装饰器的定义中，您可以添加一些通常不会由函数返回的修改后的内容。
@符号还用于访问plydata/pandas数据帧查询pandas.dataframe.query中的变量。例子：
df = pandas.DataFrame({'foo': [1,2,15,17]})
y = 10
df >> query('foo > @y') # plydata
df.query('foo > @y') # pandas
