装饰器(Decorators)是 Python 的个重要部分。简单地说： 们是修改其 函数的功能的函数。 们有助于让 的代码更简短 也更Pythonic（Python范儿）。大多数初学者不知道在哪儿使用它们 所以我将要分享下 哪些区域里装饰器可以让你的代码更简洁。首先 让 讨论下如何写你自己的装饰器。
这可能是最难掌握的概念之一。 会每次只讨论个步骤 这样你能完全理解它。
一切皆对象
首先 来理解下 Python 中的函数:
def hi(name="yasoob"):return "hi " + nameprint(hi())greet = hiprint(greet())del hiprint(hi())print(greet())
在函数中定义函数
刚才那些就是函数的基本知识了。 来让你的知识更进一步。在 Python 中 可以在个函数中定义另个函数：
def hi(name="yasoob"):print("now you are inside the hi() function")def greet():return "now you are in the greet() function"def welcome():return "now you are in the welcome() function"print(greet())print(welcome())print("now you are back in the hi() function")hi()greet()
那现在 知道了可以在函数中定义另外的函数。也就是说： 可以创建嵌套的函数。现在你需要再多学一点 就是函数也能返回函数。
从函数中返回函数
其实并不需要在个函数里去执行另个函数 也可以将其作为输出返回出来：
def hi(name="yasoob"):def greet():return "now you are in the greet() function"def welcome():return "now you are in the welcome() function"if name == "yasoob":return greetelse:return welcomea = hi()print(a)print(a())
再次看看这个代码。在 if/else 语句中 返回 greet 和 welcome 而不是 greet() 和 welcome()。为什么那样？这是因为当你把一对小括号放在后面 这个函数就会执行；然而如果你不放括号在它后面 那它可以被到处传递 并且可以赋值给别的变量而不去执行它。你明白了吗？让我再稍微多解释点细节。
当 写下 a = hi() hi() 会被执行 而由于 name 参数默认是 yasoob 所以函数 greet 被返回了。如果 把语句改为 a = hi(name = "ali") 那么 welcome 函数将被返回。 还可以打印出 hi()() 这会输出 now you are in the greet() function。
将函数作为参数传给另个函数
def hi():return "hi yasoob!"def doSomethingBeforeHi(func):print("I am doing some boring work before executing hi()")print(func())doSomethingBeforeHi(hi)
现在你已经具备所有必需知识 来进一步学习装饰器真正是什么了。装饰器让你在个函数的前后去执行代码。
你的第个装饰器
在上个例子里 其实 已经创建了个装饰器！现在 修改下上个装饰器 并编写个稍微更有用点的程序：
def a_new_decorator(a_func):def wrapTheFunction():print("I am doing some boring work before executing a_func()")a_func()print("I am doing some boring work after executing a_func()")return wrapTheFunctiondef a_function_requiring_decoration():print("I am the function which needs some decoration to remove my foul smell")a_function_requiring_decoration()a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)a_function_requiring_decoration()
你看明白了吗？ 刚刚应用了之前学习到的原理。这正是 python 中装饰器做的事情！它们封装个函数 并且用这样或那样的方式来修改它的行为。现在你也许疑惑 在代码里并没有使用 @ 符号？那只是个简短的方式来生成个被装饰的函数。这里是 如何使用 @ 来运行之前的代码：
@a_new_decoratordef a_function_requiring_decoration():"""Hey you! Decorate me!"""print("I am the function which needs some decoration to ""remove my foul smell")a_function_requiring_decoration()a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
希望你现在对 Python 装饰器的工作原理有个基本的理解。如果 运行如下代码会存在个问题：
print(a_function_requiring_decoration.__name__)# Output: wrapTheFunction
这并不是 想要的！Ouput输出应该是"a_function_requiring_decoration"。这里的函数被warpTheFunction替代了。它重写了 函数的名字和注释文档(docstring)。幸运的是Python提供给 个简单的函数来解决这个问题 那就是functools.wraps。 修改上个例子来使用functools.wraps：
from functools import wrapsdef a_new_decorator(a_func):@wraps(a_func)def wrapTheFunction():print("I am doing some boring work before executing a_func()")a_func()print("I am doing some boring work after executing a_func()")return wrapTheFunction@a_new_decoratordef a_function_requiring_decoration():"""Hey yo! Decorate me!"""print("I am the function which needs some decoration to ""remove my foul smell")print(a_function_requiring_decoration.__name__)
现在好多了。 接下来学习装饰器的一些常用场景。
蓝本规范:
from functools import wrapsdef decorator_name(f):@wraps(f)def decorated(*args, **kwargs):if not can_run:return "Function will not run"return f(*args, **kwargs)return decorated@decorator_namedef func():return("Function is running")can_run = Trueprint(func())can_run = Falseprint(func())
注意：@wraps接受个函数来进行装饰 并加入了复制函数名称、注释文档、参数列表等等的功能。这可以让 在装饰器里面访问在装饰之前的函数的属性。
使用场景
现在 来看一下装饰器在哪些地方特别耀眼 以及使用它可以让一些事情管理起来变得更简单。
授权(Authorization)
装饰器能有助于检查某个人是否被授权去使用个web应用的端点(endpoint)。它们被大量使用于Flask和Django web框架中。这里是个例子来使用基于装饰器的授权：
from functools import wrapsdef requires_auth(f):@wraps(f)def decorated(*args, **kwargs):auth = request.authorizationif not auth or not check_auth(auth.username, auth.password):authenticate()return f(*args, **kwargs)return decorated
日志(Logging)
日志是装饰器运用的另个亮点。这是个例子：
from functools import wrapsdef logit(func):@wraps(func)def with_logging(*args, **kwargs):print(func.__name__ + " was called")return func(*args, **kwargs)return with_logging@logitdef addition_func(x):"""Do some math."""return x + xresult = addition_func(4)
我敢肯定你已经在思考装饰器的个其 聪明用法了。
带参数的装饰器
来想想这个问题 难道@wraps不也是个装饰器吗？但是 它接收个参数 就像任何普通的函数能做的那样。那么 为什么 不也那样做呢？这是因为 当你使用@my_decorator语法时 你是在应用个以单个函数作为参数的个包裹函数。记住 Python里每个东西都是个对象 而且这包括函数！记住了这些 可以编写一下能返回个包裹函数的函数。
在函数中嵌入装饰器
回到日志的例子 并创建个包裹函数 能让 指定个用于输出的日志文件。
from functools import wrapsdef logit(logfile='out.log'):def logging_decorator(func):@wraps(func)def wrapped_function(*args, **kwargs):log_string = func.__name__ + " was called"print(log_string)with open(logfile, 'a') as opened_file:opened_file.write(log_string + 'n')return func(*args, **kwargs)return wrapped_functionreturn logging_decorator@logit()def myfunc1():passmyfunc1()@logit(logfile='func2.log')def myfunc2():passmyfunc2()
装饰器类
现在 有了能用于正式环境的logit装饰器 但当 的应用的某些部分还比较脆弱时 异常也许是需要更紧急关注的事情。比方说有时你只想打日志到个文件。而有时你想把引起你注意的问题发送到个email 同时也保留日志 留个记录。这是个使用继承的场景 但目前为止 只看到过用来构建装饰器的函数。
幸运的是 类也可以用来构建装饰器。那 现在以个类而不是个函数的方式 来重新构建logit。
from functools import wrapsclass logit(object):def __init__(self, logfile='out.log'):self.logfile = logfiledef __call__(self, func):@wraps(func)def wrapped_function(*args, **kwargs):log_string = func.__name__ + " was called"print(log_string)with open(self.logfile, 'a') as opened_file:opened_file.write(log_string + 'n')self.notify()return func(*args, **kwargs)return wrapped_functiondef notify(self):pass
这个实现有个附加优势 在于比嵌套函数的方式更加整洁 而且包裹个函数还是使用跟以前一样的语法：
@logit()def myfunc1(): pass
现在 给 logit 创建子类 来添加 email 的功能(虽然 email 这个话题不会在这里展开)。
class email_logit(logit):'''个logit的实现版本 可以在函数调用时发送email给管理员'''def __init__(self, email='admin@myproject.com', *args, **kwargs):self.email = emailsuper(email_logit, self).__init__(*args, **kwargs)def notify(self):pass
从现在起 @email_logit 将会和 @logit 产生同样的效果 但是在打日志的基础上 还会多发送一封邮件给管理员。
原文地址：https://eastlakeside.gitbooks.io/interpy-zh/content/decorators/
文人墨客
讲 Python 装饰器前，我想先举个例子，虽有点污，但跟装饰器这个话题很贴切。
每个人都有的内裤主要功能是用来遮羞，但是到了冬天它没法为我们防风御寒，咋办？我们想到的一个办法就是把内裤改造一下，让它变得更厚更长，这样一来，它不仅有遮羞功能，还能提供保暖，不过有个问题，这个内裤被我们改造成了长裤后，虽然还有遮羞功能，但本质上它不再是一条真正的内裤了。于是聪明的人们发明长裤，在不影响内裤的前提下，直接把长裤套在了内裤外面，这样内裤还是内裤，有了长裤后宝宝再也不冷了。装饰器就像我们这里说的长裤，在不影响内裤作用的前提下，给我们的身子提供了保暖的功效。
谈装饰器前，还要先要明白一件事，Python 中的函数和 Java、C++不太一样，Python 中的函数可以像普通变量一样当做参数传递给另外一个函数，例如：
def foo(): print("foo")def bar(func): func()bar(foo)正式回到我们的主题。装饰器本质上是一个 Python 函数或类，它可以让其他函数或类在不需要做任何代码修改的前提下增加额外功能，装饰器的返回值也是一个函数/类对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景，装饰器是解决这类问题的绝佳设计。有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码到装饰器中并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。
先来看一个简单例子，虽然实际代码可能比这复杂很多：
def foo(): print('i am foo')现在有一个新的需求，希望可以记录下函数的执行日志，于是在代码中添加日志代码：
def foo(): print('i am foo') logging.info("foo is running")如果函数 bar()、bar2() 也有类似的需求，怎么做？再写一个 logging 在 bar 函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个新的函数：专门处理日志 ，日志处理完之后再执行真正的业务代码
def use_logging(func): logging.warn("%s is running" % func.__name__) func()def foo(): print('i am foo')use_logging(foo)这样做逻辑上是没问题的，功能是实现了，但是我们调用的时候不再是调用真正的业务逻辑 foo 函数，而是换成了 use_logging 函数，这就破坏了原有的代码结构， 现在我们不得不每次都要把原来的那个 foo 函数作为参数传递给 use_logging 函数，那么有没有更好的方式的呢？当然有，答案就是装饰器。
简单装饰器
def use_logging(func): def wrapper(): logging.warn("%s is running" % func.__name__) return func() # 把 foo 当做参数传递进来时，执行func()就相当于执行foo() return wrapperdef foo(): print('i am foo')foo = use_logging(foo) # 因为装饰器 use_logging(foo) 返回的时函数对象 wrapper，这条语句相当于 foo = wrapperfoo() # 执行foo()就相当于执行 wrapper()use_logging 就是一个装饰器，它一个普通的函数，它把执行真正业务逻辑的函数 func 包裹在其中，看起来像 foo 被 use_logging 装饰了一样，use_logging 返回的也是一个函数，这个函数的名字叫 wrapper。在这个例子中，函数进入和退出时 ，被称为一个横切面，这种编程方式被称为面向切面的编程。
@ 语法糖
如果你接触 Python 有一段时间了的话，想必你对 @ 符号一定不陌生了，没错 @ 符号就是装饰器的语法糖，它放在函数开始定义的地方，这样就可以省略最后一步再次赋值的操作。
def use_logging(func): def wrapper(): logging.warn("%s is running" % func.__name__) return func() return wrapper@use_loggingdef foo(): print("i am foo")foo()如上所示，有了 @ ，我们就可以省去foo = use_logging(foo)这一句了，直接调用 foo() 即可得到想要的结果。你们看到了没有，foo() 函数不需要做任何修改，只需在定义的地方加上装饰器，调用的时候还是和以前一样，如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。
装饰器在 Python 使用如此方便都要归因于 Python 的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。
*args、**kwargs
可能有人问，如果我的业务逻辑函数 foo 需要参数怎么办？比如：
def foo(name): print("i am %s" % name)我们可以在定义 wrapper 函数的时候指定参数：
def wrapper(name): logging.warn("%s is running" % func.__name__) return func(name) return wrapper这样 foo 函数定义的参数就可以定义在 wrapper 函数中。这时，又有人要问了，如果 foo 函数接收两个参数呢？三个参数呢？更有甚者，我可能传很多个。当装饰器不知道 foo 到底有多少个参数时，我们可以用 *args 来代替：
def wrapper(*args): logging.warn("%s is running" % func.__name__) return func(*args) return wrapper如此一来，甭管 foo 定义了多少个参数，我都可以完整地传递到 func 中去。这样就不影响 foo 的业务逻辑了。这时还有读者会问，如果 foo 函数还定义了一些关键字参数呢？比如：
def foo(name, age=None, height=None): print("I am %s, age %s, height %s" % (name, age, height))这时，你就可以把 wrapper 函数指定关键字函数：
def wrapper(*args, **kwargs): # args是一个数组，kwargs一个字典 logging.warn("%s is running" % func.__name__) return func(*args, **kwargs) return wrapper带参数的装饰器
装饰器还有更大的灵活性，例如带参数的装饰器，在上面的装饰器调用中，该装饰器接收唯一的参数就是执行业务的函数 foo 。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。比如，我们可以在装饰器中指定日志的等级，因为不同业务函数可能需要的日志级别是不一样的。
def use_logging(level): def decorator(func): def wrapper(*args, **kwargs): if level == "warn": logging.warn("%s is running" % func.__name__) elif level == "info": logging.info("%s is running" % func.__name__) return func(*args) return wrapper return decorator@use_logging(level="warn")def foo(name='foo'): print("i am %s" % name)foo()上面的 use_logging 是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level="warn")调用的时候，Python 能够发现这一层的封装，并把参数传递到装饰器的环境中。
@use_logging(level="warn") 等价于 @decorator
类装饰器
没错，装饰器不仅可以是函数，还可以是类，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器主要依靠类的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。
class Foo(object): def __init__(self, func): self._func = func def __call__(self): print ('class decorator runing') self._func() print ('class decorator ending')@Foodef bar(): print ('bar')bar()functools.wraps使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：
不难发现，函数 f 被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器里面的 func 函数中，这使得装饰器里面的 func 函数也有和原函数 foo 一样的元信息了。
装饰器顺序
一个函数还可以同时定义多个装饰器，比如：
它的执行顺序是从里到外，最先调用最里层的装饰器，最后调用最外层的装饰器，它等效于