python 装饰器详解

时间 2019-11-14

标签 python 装饰详解栏目 Python 繁體版

原文原文链接

【转】做为许多语言都存在的高级语法之一，装饰器是你必须掌握的知识点。python

装饰器（Decorator）：从字面上理解，就是装饰对象的器件。能够在不修改原有代码的状况下，为被装饰的对象增长新的功能或者附加限制条件或者帮助输出。shell

装饰器有不少种，有函数的装饰器，也有类的装饰器。装饰器在不少语言中的名字也不尽相同，它体现的是设计模式中的装饰模式，强调的是开放封闭原则。
装饰器的语法是将 @ 装饰器名，放在被装饰对象上面。
```
# 语法
@dec
def func():
    pass
```

在进行装饰器的介绍以前，咱们必须先明确几个概念和原则：设计模式

首先，Python 程序是从上往下顺序执行的,并且碰到函数的定义代码块是不会当即执行的，只有等到该函数被调用时，才会执行其内部的代码块。关于这一点，其实咱们在前面的章节已经介绍过了。安全

def foo():
    print("foo函数被运行了！")

# 若是就这么样，foo 里的语句是不会被执行的。 # 程序只是简单的将定义代码块读入内存中。 # foo() 只有调用了，才会执行

其次，因为顺序执行的缘由，若是你真的对同一个函数定义了两次，那么，后面的定义会覆盖前面的定义。所以，在 Python 中代码的放置位置是有区别的，不能随意摆放，一般函数体要放在调用的语句以前。架构

def foo():
    print("我是上面的函数定义！")

foo()

def foo():
    print("我是下面的函数定义！")

foo()
#---------------- 执行结果：
我是上面的函数定义！
我是下面的函数定义！

而后，咱们还要先搞清楚几样东西：函数名、函数体、返回值，函数的内存地址、函数名加括号、函数名被看成参数、函数名加括号被看成参数、返回函数名、返回函数名加括号。app

def outer(func):
    def inner():
        print("我是内层函数！")
    return inner

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 、f二、f3......f100的内部进行代码修改，可是能够在外部对它们进行扩展。

第五天：已经没有时间让主管找别人来干这活了，他决定亲自上阵，使用装饰器完成这一任务，而且打算在函数执行后再增长个日志功能。主管的代码以下：

def outer(func):
    def inner():
        print("认证成功！")
        result = func()
        print("日志添加成功")
        return result
    return inner

@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("日志添加成功")
        return result
    return inner

@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("日志添加成功")
    return result

@outer
def f1():
    print("业务部门1数据接口......")

# 业务部门并无调用 f1 函数 ------------------------------------------ 执行结果：

认证成功！
业务部门1数据接口......
日志添加成功

看见了吗？咱们只是定义好了装饰器，业务部门尚未调用f1函数呢，程序就把工做全作了。这就是为何要封装一层函数的缘由。

细心的同窗可能已经发现了，上面的例子中，f1 函数没有参数，在实际状况中确定会须要参数的，函数的参数怎么传递的呢？

def outer(func):
    def inner(username):
        print("认证成功！")
        result = func(username)
        print("日志添加成功")
        return result
    return inner

@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("日志添加成功")
        return result
    return inner

@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("日志添加成功")
        return result
    return inner


def outer2(func):
    def inner(*args,**kwargs):
        print("一条欢迎信息。。。")
        result = func(*args,**kwargs)
        print("一条欢送信息。。。")
        return result
    return inner


@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):
                return before_result;

            main_result = main_func(request,kargs)
            if(main_result != None):
                return main_result;

            after_result = log(request,kargs)
            if(after_result != None):
                return after_result;

        return wrapper
    return outer
# 注意了，这里的装饰器函数有参数哦，它的意思是先执行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数据接口......
日志添加成功

装饰器的学问博大精深，须要咱们不断的学习思考。官方文档和框架源码是比较好的学习对象。

转载：http://www.liujiangblog.com/course/python/39