Python装饰器概念及实现

1.什么是装饰器？

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

2.使用场景

装饰器经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景，装饰器是解决这类问题的绝佳设计。
有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码到装饰器中并继续重用。
概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

3.实现

先来看一个简单例子，虽然实际代码可能比这复杂很多：

def cal():
    print('hello cal')

现在有一个新的需求，希望可以记录下函数的执行日志，于是在代码中添加日志代码：

def cal():
    logging.info("cal is running")
    print('hello cal')

如果函数 cal2()、cal3() 也有类似的需求，怎么做？再写一个 logging 在 cal 函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个新的函数：专门处理日志 ，日志处理完之后再执行真正的业务代码：

def use_logging(func):
    logging.info("%s is running" % func.__name__)
    func()

def cal():
    print('hello cal')

use_logging(cal)

这样做逻辑上是没问题的，功能是实现了，但是我们调用的时候不再是调用真正的业务逻辑 cal 函数，而是换成了 use_logging 函数，这就破坏了原有的代码结构，不符合程序设计的开闭原则，现在我们不得不每次都要把原来的那个 cal 函数作为参数传递给 use_logging 函数，那么有没有更好的方式的呢？当然有，答案就是装饰器。

开闭原则：对扩展开放，对修改关闭。

装饰器两大原则：

• 不修改被修饰函数的源代码
• 不修改被修饰函数的调用（运行）方式

3.1闭包

在正式进入装饰器之前，不得不先提一个概念：闭包。

闭包是指函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。
闭包的使用，可以隐藏内部函数的工作细节，只给外部使用者提供一个可以执行的内部函数的引用。

装饰器是通过闭包的方式实现的，外函数接收一个函数作为外函数的临时变量，然后在内函数中执行这个函数。

内函数将需要的参数接收进来并传给执行的函数，然后将执行结果返回。在内函数中，可以添加额外的功能的代码，这些额外的功能就是装饰器添加的功能。

最后外函数将内函数返回。

3.2 简单装饰器

def use_logging(func):

    def wrapper():
        logging.info("%s is running" % func.__name__)
        return func()   # 把 cal 当做参数传递进来时，执行func()就相当于执行cal()
    return wrapper

def cal():
    print('hello  cal')

cal = use_logging(cal)  # 因为装饰器 use_logging(cal) 返回的是函数对象 wrapper，这条语句相当于 cal = wrapper
cal()  # 执行cal()就相当于执行 wrapper()

use_logging 就是一个装饰器，它一个普通的函数，它把执行真正业务逻辑的函数 func 包裹在其中，看起来像 cal 被 use_logging 装饰了一样，use_logging 返回的也是一个函数，这个函数的名字叫 wrapper。在这个例子中，函数进入和退出时 ，被称为一个横切面，这种编程方式被称为面向切面的编程。

3.3 @语法糖

@ 符号是装饰器的语法糖，它放在函数开始定义的地方，这样就可以省略最后一步再次赋值的操作。

def use_logging(func):

    def wrapper():
        logging.warn("%s is running" % func.__name__)
        return func()
    return wrapper

@use_logging
def cal():
    print('hello cal')

cal()

如上所示，有了 @ ，我们就可以省去cal = use_logging(cal)这一句了，直接调用 cal() 即可得到想要的结果。
通过这样的方式，cal() 函数不需要做任何修改，只需在定义的地方加上装饰器，调用的时候还是和以前一样，如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。

装饰器在 Python 使用如此方便都要归因于 Python 的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。这是Python函数和Java、C++不一样的地方。

3.4 函数传参

上面简单装饰器的例子中，cal() 函数是没有参数的，那如果业务逻辑函数 cal 需要参数怎么办？比如：

def cal(name):
    print("hello cal, I'm %s" % name)

我们可以在定义 wrapper 函数的时候指定参数：

def wrapper(name):
    logging.info("%s is running" % func.__name__)
    return func(name)
return wrapper

这样 cal 函数定义的参数就可以定义在 wrapper 函数中。那如果 cal 函数接收两个参数呢？三个参数呢？更有甚者，我可能传很多个。当装饰器不知道 cal 到底有多少个参数时，我们可以用 *args 来代替：

def wrapper(*args):
    logging.info("%s is running" % func.__name__)
    return func(*args)
return wrapper

如此一来，不管 cal 定义了多少个参数，我都可以完整地传递到 func 中去。这样就不影响 cal 的业务逻辑了。如果 cal 函数还定义了一些关键字参数怎么处理呢？比如：

def cal(name, age=None, height=None):
    print("hello cal, I'm %s, age %s, height %s" % (name, age, height))

这时，你就可以把 wrapper 函数指定关键字函数：

def wrapper(*args, **kwargs):
    # args是一个数组，kwargs是一个字典
    logging.info("%s is running" % func.__name__)
    return func(*args, **kwargs)
return wrapper

3.5 装饰器传参

装饰器还有更大的灵活性，例如带参数的装饰器，在上面的装饰器调用中，该装饰器接收唯一的参数就是执行业务的函数 cal 。装饰器的语法允许我们在调用时，提供其它参数，比如@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 cal(name='dog'):
    print("hello cal, I'm %s" % name)

cal()

上面的 use_logging 是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我们使用@use_logging(level=“warn”)调用的时候，Python 能够发现这一层的封装，并把参数传递到装饰器的环境中。

3.6 类装饰器

装饰器不仅可以是函数，还可以是类，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器主要依靠类的 __call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

class Log(object):
    def __init__(self, func):
        self._func = func

    def __call__(self):
        print ('class decorator running')
        self._func()
        print ('class decorator ending')

@Log
def cal():
    print ('hello cal')

cal()

3.7 装饰器顺序

一个函数可以同时定义多个装饰器，比如：

@a
@b
@c
def cal():
    print ('hello cal')

它的执行顺序是从里到外，最先调用最里层的装饰器，最后调用最外层的装饰器，它等效于：

cal = a(b(c(f)))