Python当歌（八）：装饰器

前言

讲 Python 装饰器前，我想先举个例子，虽有点污，但跟装饰器这个话题很贴切。每个人都有的内裤主要功能是用来遮羞，但是到了冬天它没法为我们防风御寒，咋办？我们想到的一个办法就是把内裤改造一下，让它变得更厚更长，这样一来，它不仅有遮羞功能，还能提供保暖，不过有个问题，这个内裤被我们改造成了长裤后，虽然还有遮羞功能，但本质上它不再是一条真正的内裤了。于是聪明的人们发明长裤，在不影响内裤的前提下，直接把长裤套在了内裤外面，这样内裤还是内裤，有了长裤后宝宝再也不冷了。装饰器就像我们这里说的长裤，在不影响内裤作用的前提下，给我们的身子提供了保暖的功效。

谈装饰器前，还要先要明白一件事，Python 中的函数和 Java、C++不太一样，Python 中的函数可以像普通变量一样当做参数传递给另外一个函数，例如：

def foo():
    print("foo")

def bar(func):
    func()

bar(foo)

正式回到我们的主题。装饰器本质上是一个 Python 函数或类，它可以让其他函数或类在不需要做任何代码修改的前提下增加额外功能，装饰器的返回值也是一个函数/类对象。它经常用于有切面需求的场景，比如：时间计算、性能测试、事务处理、缓存、权限校验等场景，装饰器是解决这类问题的绝佳设计。有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码到装饰器中并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

先来看一个简单例子：

import time

def foo():
    time.sleep(3)
    print("运行时间是%s" %(stop_time - start_time))

现在有一个新的需求，希望可以记录下函数运行的时间，于是在代码中添加计算时间的代码：

import time

def foo():
    start_time = time.time()
    time.sleep(3)
    stop_time = time.time()
    print("运行时间是%s" %(stop_time - start_time))

如果函数 bar()、bar2() 也有类似的需求，怎么做？再写一个 类似的代码在 bar 函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个新的函数：专门计算函数运行时间 ，时间计算完成之后再执行真正的业务代码。

import time

def timmer(func): #func=test
    start_time=time.time()
    func() #就是在运行test()
    stop_time = time.time()
    print('运行时间是%s' %(stop_time-start_time))

def test():
     time.sleep(3)
     print('test函数运行完毕')

timmer(test)

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

简单装饰器

import time
def timmer(func): #func=test
    def wrapper():
        start_time=time.time()
        func() #就是在运行test()
        stop_time = time.time()
        print('运行时间是%s' %(stop_time-start_time))
    return wrapper

def test():
    time.sleep(3)
print('test函数运行完毕')

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

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

@ 语法糖

如果你接触 Python 有一段时间了的话，想必你对 @ 符号一定不陌生了，没错 @ 符号就是装饰器的语法糖，它放在函数开始定义的地方，这样就可以省略最后一步再次赋值的操作。

import time
def timmer(func): #func=test
    def wrapper():
        start_time=time.time()
        func() #就是在运行test()
        stop_time = time.time()
        print('运行时间是%s' %(stop_time-start_time))
    return wrapper

@timmer
def test():
    time.sleep(3)
print('test函数运行完毕')

test()

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

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

*args、**kwargs

如果我的业务逻辑函数 foo 需要参数怎么办？比如：

def test(name):
    time.sleep(3)
    print(“test函数运行完毕,名字是【%s】” %name)

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

def wrapper(name):
    start_time=time.time()
    func(name)        
    stop_time = time.time()
    print('运行时间是%s' %(stop_time-start_time))
    return wrapper

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

def wrapper(*args):
    start_time=time.time()
    func(*args)        
    stop_time = time.time()
    print('运行时间是%s' %(stop_time-start_time))
    return wrapper

如此一来，甭管 test定义了多少个参数，我都可以完整地传递到 func 中去。这样就不影响 test的业务逻辑了。这时还有读者会问，如果 test函数还定义了一些关键字参数呢？比如：

def test(name,age,gender):
    time.sleep(1)
    print('test1函数运行完毕,名字是【%s】 年龄是【%s】 性别【%s】' %(name,age,gender))
    return '这是test的返回值'

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

def wrapper(*args,**kwargs):
    start_time=time.time()
    func(*args,**kwargs)
    stop_time = time.time()
    print('运行时间是%s' %(stop_time-start_time))
    return wrapper

带参数的装饰器

装饰器还有更大的灵活性，例如带参数的装饰器，在上面的装饰器调用中，该装饰器接收唯一的参数就是执行业务的函数test 。装饰器的语法允许我们在调用时，提供其它参数，比如@timmer()。这样，就为装饰器的编写和使用提供了更大的灵活性。比如，我们可以在装饰器中指定如何计算时间，因为不同业务函数可能需要的计算时间方式是不一样的。

import time

def cal_time(timing):
    def timmer(func):
        def wrapper(*args, **kwargs):
                start_time = time.time()
                func(*args, **kwargs)
                stop_time = time.time()
                if timing == "True":
                    print("运行时间是%s" %(stop_time - start_time))
                else:
                    print("鬼知道他运行了多长时间")
        return wrapper
    return timmer

@cal_time(timing="True")
def test():
    time.sleep(3)
    print("test函数运行完毕")

test()

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

@cal_time(timing="True”等价于@timmer