【转】作为许多语言都存在的高级语法之一,装饰器是你必须掌握的知识点。
装饰器(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数据接口......
日志添加成功
装饰器的学问博大精深,需要我们不断的学习思考。官方文档和框架源码是比较好的学习对象。