python装饰器分析_python 装饰器详解
【转】作为许多语言都存在的高级语法之一，装饰器是你必须掌握的知识点。
装饰器(Decorator)：从字面上理解，就是装饰对象的器件。可以在不修改原有代码的情况下，为被装饰的对象增加新的功能或者附加限制条件或者帮助输出。
装饰器有很多种，有函数的装饰器，也有类的装饰器。装饰器在很多语言中的名字也不尽相同，它体现的是设计模式中的装饰模式，强调的是开放封闭原则。
装饰器的语法是将 @ 装饰器名，放在被装饰对象上面 。
# 语法
@dec
def func():
pass
在进行装饰器的介绍之前，我们必须先明确几个概念和原则：
首先，Python 程序是从上往下顺序执行的,而且碰到函数的定义代码块是不会立即执行的，只有等到该函数被调用时，才会执行其内部的代码块。关于这一点，其实我们在前面的章节已经介绍过了。
def foo():
print("foo函数被运行了！")
# 如果就这么样，foo 里的语句是不会被执行的。
# 程序只是简单的将定义代码块读入内存中。
# foo() 只有调用了，才会执行
其次，由于顺序执行的原因，如果你真的对同一个函数定义了两次，那么，后面的定义会覆盖前面的定义。因此，在 Python 中代码的放置位置是有区别的，不能随意摆放，通常函数体要放在调用的语句之前。
def foo():
print("我是上面的函数定义！")
foo()
def foo():
print("我是下面的函数定义！")
foo()
#----------------执行结果：
我是上面的函数定义！
我是下面的函数定义！
然后，我们还要先搞清楚几样东西： 函数名、函数体、返回值，函数的内存地址、函数名加括号、函数名被当作参数、函数名加括号被当作参数、返回函数名、返回函数名加括号 。
def outer(func):
def inner():
print("我是内层函数！")returninner
def foo():
print("我是原始函数！")
outer(foo)
outer(foo())
函数名：foo、outer、inner
函数体：函数的整个代码结构
返回值： return后面的表达式
函数的内存地址： id(foo)、id(outer) 等等
函数名加括号：对函数进行调用，比如 foo()、outer(foo)
函数名作为参数：outer(foo) 中的 foo 本身是个函数，但作为参数被传递给了outer 函数
函数名加括号被当做参数：其实就是先调用函数，再将它的返回值当做别的函数的参数，例如 outer(foo())
返回函数名： return inner
返回函数名加括号： return inner() ，其实就是先执行inner函数，再将其返回值作为别的函数的返回值。
如果你能理解函数也是一个对象，就能很容易地理解上面的概念。
有了这些基本的概念，我们就可以通过一个实例来讲解 Python 中装饰器的作用了。下例是针对函数的装饰器。
虚拟场景
有一个大公司，下属的基础平台部负责内部应用程序及 API 的开发。另外还有上百个业务部门负责不同的业务，这些业务部门各自调用基础平台部提供的不同函数，也就是 API 处理自己的业务，情况如下：
# 基础平台部门开发了上百个函数 API
def f1():
print("业务部门1的数据接口......")
def f2():
print("业务部门2的数据接口......")
def f3():
print("业务部门3的数据接口......")
def f100():
print("业务部门100的数据接口......")
# 各部门分别调用自己需要的 API
f1()
f2()
f3()
f100()
公司还在创业初期时，基础平台部就开发了这些函数。由于各种原因，比如时间紧，比如人手不足，比如架构缺陷，比如考虑不周等等，没有为函数的调用进行安全认证。现在，公司发展壮大了，不能再像初创时期的“草台班子”一样将就下去了，基础平台部主管决定弥补这个缺陷，于是(以下场景纯属虚构，调侃之言，切勿对号入座)：
第一天：主管叫来了一个运维工程师，工程师跑上跑下逐个部门进行通知，让他们在代码里加上认证功能，然后，当天他被开除了。
第二天：主管又叫来了一个运维工程师，工程师用shell写了个复杂的脚本，勉强实现了功能。但他很快就回去接着做运维了，不会开发的运维不是好运维....
第三天：主管叫来了一个 python 自动化开发工程师。哥们是这么干的，只对基础平台的代码进行重构，让 N 个业务部门无需做任何修改。这哥们很快也被开了，连运维也没得做。
def f1():
#加入认证程序代码
print("业务部门1数据接口......")
def f2():
# 加入认证程序代码
print("业务部门2数据接口......")
def f3():
# 加入认证程序代码
print("业务部门3数据接口......")
def f100():
#加入认证程序代码
print("业务部门100数据接口......")
# 各部门分别调用
f1()
f2()
f3()
f100()
第四天：主管又换了个开发工程师。他是这么干的：定义个认证函数，在原来其他的函数中调用它，代码如下。
def login():
print("认证成功！")
def f1():
login()
print("业务部门1数据接口......")
def f2():
login()
print("业务部门2数据接口......")
def f3():
login()
print("业务部门3数据接口......")
def f100():
login()
print("业务部门100数据接口......")
# 各部门分别调用
f1()
f2()
f3()
f100()
但是主管依然不满意，不过这一次他解释了为什么。主管说：写代码要遵循开放封闭原则，简单来说，已经实现的功能代码内部不允许被修改，但外部可以被扩展。如果将开放封闭原则应用在上面的需求中，那么就是不允许在函数f1 、f2、f3......f100的内部进行代码修改，但是可以在外部对它们进行扩展。
第五天：已经没有时间让主管找别人来干这活了，他决定亲自上阵，使用装饰器完成这一任务，并且打算在函数执行后再增加个日志功能。主管的代码如下：
def outer(func):
def inner():
print("认证成功！")
result=func()
print("日志添加成功")returnresultreturninner
@outer
def f1():
print("业务部门1数据接口......")
@outer
def f2():
print("业务部门2数据接口......")
@outer
def f3():
print("业务部门3数据接口......")
@outer
def f100():
print("业务部门100数据接口......")
#各部门分别调用
f1()
f2()
f3()
f100()
使用装饰器 @outer，也是仅需对基础平台的代码进行拓展，就可以实现在其他部门调用函数 API 之前都进行认证操作，在操作结束后保存日志，并且其他业务部门无需对他们自己的代码做任何修改，调用方式也不用变。
装饰器机制分析
下面以f1函数为例，对装饰器的运行机制进行分析：
def outer(func):
def inner():
print("认证成功！")
result=func()
print("日志添加成功")returnresultreturninner
@outer
def f1():
print("业务部门1数据接口......")
程序开始运行，从上往下解释，读到 def outer(func): 的时候，发现这是个“一等公民”函数，于是把函数体加载到内存里，然后过。
读到@outer的时候，程序被@这个语法糖吸引住了，知道这是个装饰器，按规矩要立即执行的，于是程序开始运行@后面那个名字outer所定义的函数。
程序返回到outer函数，开始执行装饰器的语法规则。规则是：被装饰的函数的名字会被当作参数传递给装饰函数。装饰函数执行它自己内部的代码后，会将它的返回值赋值给被装饰的函数。原来的f1函数被当做参数传递给了func，而f1这个函数名之后会指向inner函数。
注意：@outer 和 @outer() 有区别，没有括号时，outer函数 依然会被执行，这和传统的用括号才能调用函数不同，需要特别注意！
另外，是f1这个函数名(而不是f1()这样被调用后)当做参数传递给 装饰函数outer，也就是： func = f1 ， @outer 等于 outer(f1) ,实际上传递了 f1 的函数体，而不是执行 f1 后的返回值。
还有，outer函数 return 的是 inner 这个函数名，而不是 inner() 这样被调用后的返回值。
4. 程序开始执行 outer 函数 内部的内容，一开始它又碰到了一个函数 inner，inner 函数定义块被程序观察到后不会立刻执行，而是读入内存中(这是默认规则)。
5. 再往下，碰到 return inner ，返回值是个函数名，并且这个函数名会被赋值给 f1 这个被装饰的函数，也就是 f1 = inner 。根据前面的知识，我们知道，此时 f1函数 被新的函数 inner 覆盖了(实际上是 f1 这个函数名更改成指向 inner 这个函数名指向的函数体内存地址，f1 不再指向它原来的函数体的内存地址)，再往后调用 f1 的时候将执行 inner 函数内的代码，而不是先前的函数体。那么先前的函数体去哪了？还记得我们将 f1 当做参数传递给 func 这个形参么？func 这个变量保存了老的函数在内存中的地址，通过它就可以执行老的函数体，你能在 inner 函数里看到 result = func() 这句代码，它就是这么干的！
6.接下来，还没有结束。当业务部门，依然通过 f1() 的方式调用 f1函数 时，执行的就不再是旧的 f1函数 的代码，而是 inner函数 的代码。在本例中，它首先会打印个“认证成功”的提示，很显然你可以换成任意的代码，这只是个示例；然后，它会执行 func函数 并将返回值赋值给变量 result，这个 func函数 就是旧的 f1函数；接着，它又打印了“日志保存”的提示，这也只是个示例，可以换成任何你想要的；最后返回result 这个变量。我们在业务部门的代码上可以用 r = f1() 的方式接受 result 的值。
7. 以上流程走完后，你应该看出来了，在没有对业务部门的代码和接口调用方式做任何修改的同时，也没有对基础平台部原有的代码做内部修改，仅仅是添加了一个装饰函数，就实现了我们的需求，在函数调用前进行认证，调用后写入日志。这就是装饰器的最大作用。
那么为什么我们要搞一个 outer 函数一个 inner 函数这么复杂呢？一层函数不行吗？
答：请注意，@outer 这句代码在程序执行到这里的时候就会自动执行 outer函数 内部的代码，如果不封装一下，在业务部门还未进行调用的时候，就执行了，这和初衷不符。当然，如果你对这个有需求也不是不行。请看下面的例子，它只有一层函数。
def outer(func):
print("认证成功！")
result=func()
print("日志添加成功")returnresult
@outer
def f1():
print("业务部门1数据接口......")
# 业务部门并没有调用 f1 函数------------------------------------------执行结果：
认证成功！
业务部门1数据接口......
日志添加成功
看见了吗？我们只是定义好了装饰器，业务部门还没有调用f1函数呢，程序就把工作全做了。这就是为什么要封装一层函数的原因。
细心的同学可能已经发现了，上面的例子中，f1 函数没有参数，在实际情况中肯定会需要参数的，函数的参数怎么传递的呢？
def outer(func):
def inner(username):
print("认证成功！")
result=func(username)
print("日志添加成功")returnresultreturninner
@outer
def f1(name):
print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack")
在 inner函数 的定义部分也加上一个参数，调用 func函数 的时候传递这个参数，很好理解吧？可问题又来了，那么另外一个部门调用的 f2 有2个参数呢？f3 有 3 个参数呢？你怎么传递？很简单，我们有 *args 和 **kwargs 嘛！号称“万能参数”！简单修改一下上面的代码：
ef outer(func):
def inner(*args,**kwargs):
print("认证成功！")
result= func(*args,**kwargs)
print("日志添加成功")returnresultreturninner
@outer
def f1(name,age):
print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack",18)
介绍到这里，装饰器的基本概念和初级使用方法，你应该有了一定的了解了。那么进一步思考一下，一个函数可以被多个函数装饰吗？可以的！看下面的例子！
def outer1(func):
def inner(*args,**kwargs):
print("认证成功！")
result= func(*args,**kwargs)
print("日志添加成功")returnresultreturninner
def outer2(func):
def inner(*args,**kwargs):
print("一条欢迎信息。。。")
result= func(*args,**kwargs)
print("一条欢送信息。。。")returnresultreturninner
@outer1
@outer2
def f1(name,age):
print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack",18)
#--------------------------------------------------执行结果：
认证成功！
一条欢迎信息。。。
jack 正在连接业务部门1数据接口......
一条欢送信息。。。
日志添加成功
更更进一步，装饰器自己可以有参数吗？可以的！看下面的例子：
# 认证函数
def auth(request,kargs):
print("认证成功！")
# 日志函数
def log(request,kargs):
print("日志添加成功")
# 装饰器函数。接收两个参数，这两个参数应该是某个函数的名字。
def Filter(auth_func,log_func):# 第一层封装，f1函数实际上被传递给了main_fuc这个参数
def outer(main_func):# 第二层封装，auth和log函数的参数值被传递到了这里
def wrapper(request,kargs):# 下面代码的判断逻辑不重要，重要的是参数的引用和返回值
before_result=auth(request,kargs)if(before_result !=None):returnbefore_result;
main_result=main_func(request,kargs)if(main_result !=None):returnmain_result;
after_result=log(request,kargs)if(after_result !=None):returnafter_result;returnwrapperreturnouter
# 注意了，这里的装饰器函数有参数哦，它的意思是先执行filter函数
# 然后将filter函数的返回值作为装饰器函数的名字返回到这里，所以，
# 其实这里，Filter(auth,log)= outer , @Filter(auth,log) =@outer
@Filter(auth,log)
def f1(name,age):
print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack",18)
#-----------------------------------------------运行结果：
认证成功！
jack 正在连接业务部门1数据接口......
日志添加成功
装饰器的学问博大精深，需要我们不断的学习思考。官方文档和框架源码是比较好的学习对象。