Python基础之装饰器

一、什么是装饰器？

装饰器本质上就是一个Python函数，它可以让其它函数在不需要做任何代码变动的前提下，增加额外的功能，装饰器的返回值也是一个函数对象。

装饰器的应用场景：比如插入日志，性能测试，事物处理，缓存等等场景。

二、装饰器的形成过程

现在我有一个需求，我想让你在不改变函数代码的情况下，测试出这个函数的执行时间：

import time


def func1():
    print("in func1")


def timer(func):
    def inner():
        start = time.time()
        func()
        print(time.time() - start)
    return inner


func1 = timer(func1)
func1()

但是如果有多个函数，我都想让你测试他们的执行时间，你岂不是每个函数都要写一遍func1 = timer(func1)？

这样写非常麻烦，因为这些函数的函数名都是不相同的，有func1、func2，func3等等。

针对这种情况，python给我们提供了一个简单快捷的方法，那就是语法糖。

import time


def timer(func):
    def inner():
        start = time.time()
        func()
        print(time.time() - start)
    return inner


@timer  # ==> func1 = timer(func1)
def func1():
    print("in func1")
    
    
func1()

刚刚我们讨论的装饰器都是装饰不带参数的函数，现在要装饰一个带参数的函数要怎么办呢？

import time

def timer(func):
    def inner(a):
        start = time.time()
        func(a)
        print(time.time() - start)
    return inner


@timer
def func1(a):
    print(a)

func1(1)

import time


def timer(func):
    def inner(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(time.time() - start)
        return result
    return inner


@timer #==> func1 = timer(func1)
def func1(a, b):
    print("in func1")
    

@timer #==> func2 = timer(func2)
def func2(a):
    print("in func2 and get a:%s" % a)
    return "func2 end"


func1("aaa", "bbb")
print(func2("aa"))

上面的装饰器已经非常完美了，但是我们在正常情况下查看函数信息的方法却在此处全部失效了：

def index():
    """
    这是一个主页信息
    :return:
    """
    print("from index")


print(index.__doc__)    # 查看函数注释的方法
print(index.__name__)   # 查看函数名的方法

那么如何解决这个问题呢？

from functools import wraps


def deco(func):
    @wraps(func)    # 放在最内层函数最上方
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@deco
def index():
    """
    显示首页信息
    :return:
    """
    print("from index")


print(index.__doc__)
print(index.__name__)

三、开放封闭原则

装饰器是完美的遵循了这个开放封闭原则的。

那么什么是开放封闭原则呢？

我们可以从下面两个方面来看。

1. 对扩展是开放的

为什么要对扩展开放呢？

我们说，任何一个程序，不可能在设计之初就已经想好了所有的功能，并且未来不做任何更新和修改。所以我们必须允许代码扩展、添加新功能。

2. 对修改是封闭的

为什么要对修改封闭呢？

就像我们刚刚提到的，因为我们写的一个函数，很有可能已经交付给其他人使用了，如果这个我们对其进行了修改，很有可能影响其他已经在使用该函数的用户。

四、装饰器的主要功能和固定结构

def timer(func):
    def inner(*args, **kwargs):
        """执行函数之前要做的"""
        result = func(*args, **kwargs)
        """执行函数之后要做的"""
        return result
    return inner

from functools import wraps

def deco(func):
    @wraps(func)    # 加在最内层函数最上方
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

五、带参数的装饰器

假如你有成千上万个函数使用了一个装饰器，现在你想把这些装饰器都取消掉，你要怎么做？

如果一个一个的取消，那任务量也太大了吧。

万一，没过几天，你又需要用这些装饰器，岂不是要吐血。

那么解决办法，就是在装饰器上加上参数：

def wrapper_out(flag):
    def wrapper(func):
        @wraps(func)
        def inner(*args, **kwargs):
            if flag:
                print("执行函数之前要做的")

            result = func(*args, **kwargs)

            if flag:
                print("执行函数之后要做的")

            return result
        return inner
    return wrapper


@wrapper_out(False)     # 通过传递True和False来控制装饰器内部的运行效果
def func():
    pass


func()

六、多个装饰器装饰一个函数

先执行下面这样一个代码

def wrapper1(func):
    def inner(*args, **kwargs):
        print("111")
        result = func(*args, **kwargs)
        print("222")
        return result
    return inner


def wrapper2(func):
    def inner(*args, **kwargs):
        print("333")
        result = func(*args, **kwargs)
        print("444")
        return result
    return inner


@wrapper2
@wrapper1
def func():
    print("this is func")

func()

当执行完毕后，可以看到执行结果为：

333
111
this is func
222
444

执行顺序：首先@warpper1装饰器来，然后获取到一个新函数是wrapper1中的inner，然后执行@wrapper2。这个时候，wrapper2装饰的就是wrapper1中的inner了。

所以，执行顺序就像：第二层装饰器前（第一层装饰器前（目标）第一层装饰器后）第二层装饰器后。程序从左到右执行起来，这就是我们看到的结果。