跳转至

装饰器

装饰器的定义


点击这里,边看视频讲解,边学习以下内容

装饰器 ,英文称之为decorator

我们开发Python代码,会经常碰到装饰器。

Python中装饰器通常用来装饰函数、或者类的方法。

通常被装饰后的函数, 会在原有的函数基础上,增加一点功能。

比如 前面我们在学习到类里面的静态方法,就是使用了staticmethod 这个装饰器,被装饰的方法 就增加了一层含义,表示这个方法是个静态方法。

通常装饰器本身是也一个函数。 那么装饰器是怎么装饰另外的函数的呢?

假设你进入一个公司,领导要求你在老代码的基础上继续开发。

假设代码里面有好多函数,都是返回时间的,比如像下面这样。

import time
def getXXXTime():
    print()
    return time.strftime('%Y_%m_%d %H:%M:%S',time.localtime())

如果我们需要在所有这样的函数 返回字符串前面 都加上开头: 当地时间

这时候,我们完全可以 不去修改原来的函数 , 而是 使用装饰器 ,像这样

import time

# 定义一个装饰器函数
def sayLocal(func):
    def wrapper():
        curTime = func()
        return f'当地时间: {curTime}'
    return wrapper

def getXXXTime():
    return time.strftime('%Y_%m_%d %H:%M:%S',time.localtime())

# 装饰 getXXXTime
getXXXTime = sayLocal(getXXXTime)

print (getXXXTime())  

执行下面这行代码之前 ,

getXXXTime = sayLocal(getXXXTime)

getXXXTime 这个名字 对应一个函数对象 内容如下

return time.strftime('%Y_%m_%d %H:%M:%S',time.localtime())

但是当解释器执行完这行代码, 它重新定义了 getXXXTime 这个变量 为 后面 sayLocal(getXXXTime) 调用的返回值。

sayLocal(getXXXTime) 调用的返回值是什么呢?

我们看到 sayLocal(getXXXTime) 函数的定义是这样的:

def sayLocal(func):
    def wrapper():
        curTime = func()
        return f'当地时间: {curTime}'
    return wrapper

所以, 它的参数 func 传入的是一个函数对象 ,就是原来的 getXXXTime 函数。

然后这个函数 内部 又定义了一个函数 wrapper, 这个内部的函数 实现了在原来的getXXXTime 函数 调用的结果前面加上 当地时间: 这样的前缀。

这个sayLocal 函数调用的返回值 就是 这个内部函数 wrapper。

那么getXXXTime 经过装饰后,其实 已经变成了 内部函数 wrapper

所以后面我执行调用 getXXXTime 函数,其实就是调用 wrapper。

所以我们说 sayLocal 函数 就是一个装饰器,它装饰了参数函数的行为。

而 第 14行代码,就是 把一个函数名 对应的行为改变为 装饰后的 行为。

Python 中 对应第14行代码, 可以有更方便的写法,如下

import time

def sayLocal(func):
    def wrapper():
        curTime = func()
        return f'当地时间: {curTime}'
    return wrapper

@sayLocal
def getXXXTime():
    return time.strftime('%Y_%m_%d %H:%M:%S',time.localtime())

print (getXXXTime())   

@sayLocal 开头后面接装饰器函数 的这种写法,是一种 语法糖 ,也就是便捷写法。

当Python解释器执行 完 下面语句的时候,

@sayLocal
def getXXXTime():
    ....

就等于执行了这样的一条语句

getXXXTime = sayLocal(getXXXTime)

这样写起来比较方便快捷。


可能有的读者会问,干嘛要这么麻烦? 我们直接改这个函数的内容,不是更简单吗?像这样

import time
def getXXXTime():
    curTime = time.strftime('%Y_%m_%d %H:%M:%S',time.localtime())
    return f'当地时间: {curTime}'

装饰器经常被用在库和框架中, 给别的开发者使用。

这些库的开发者预料到 使用者 开发的函数可能需要 一些增强的功能。

但是 这些库的开发者 没法去改使用者的代码, 就可以把这些增强的部分做在 装饰器函数中。

这样使用者,只需要在他们的函数前面上@xxx 就使用了这些增强的功能了。

被装饰的函数有参数

如果要装饰函数有 未知个数的参数, 怎么办呢?

像这样的2个函数,都要装饰

import time
def getXXXTimeFormat1(name):
    curTime = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())
    return f'{curTime} ,数据采集者:{name} '


def getXXXTimeFormat2(name,place):
    curTime = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())
    return f'{curTime} ,数据采集者:{name} , 采集地:{place}'

这时,可以使用函数的可变参数,像这样

import time

def sayLocal(func):
    def wrapper(*args,**kargs):
        curTime = func(*args,**kargs)
        return f'当地时间: {curTime}'
    return wrapper

@sayLocal
def getXXXTimeFormat1(name):
    curTime = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())
    return f'{curTime} ,数据采集者:{name} '

@sayLocal
def getXXXTimeFormat2(name,place):
    curTime = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())
    return f'{curTime} ,数据采集者:{name} , 采集地:{place}'

print (getXXXTimeFormat1('张三'))    
print (getXXXTimeFormat2('张三',place='北京'))    

其中 *args 可以接受一切 不指定参数名 的传参方式 , 比如 '张三'

**kargs 可以接受一切 指定参数名 的传参方式 , 比如 place='北京'

您需要高效学习,找工作? 点击咨询 报名实战班

点击查看学员就业情况

装饰器函数自身有参数

有时候,装饰器函数自身需要有参数。比如要web服务端开发,对执行某个API处理前,要检查系统是否激活了对应功能,那么我们的装饰器函数需要有参数。

比如:

# 需要激活自动化测试功能
@activation_check('自动化测试')
def autotest_scene1(request):
    ...


# 需要激活性能测试功能
@activation_check('性能测试')
def loadtest_scene1(request):
    ...


使用 有参数的装饰器 装饰一个函数,其本质等同于

func_name = (decorator(params))(func_name)

所以,我们应该这样定义

from activations import activatedCapList
def activation_check(capability):
    def wrapper1(func):
        def wrapper2(*args, **kwargs):
            # 如果该功能没有激活,直接返回
            if capability not in activatedCapList:
                return Response('功能未激活')

            # 已经激活,调用被装饰的函数进行处理
            return func(*args, **kwargs)
        return wrapper2
    return wrapper1

@activation_check('自动化测试')
def autotest_scene1(request):
    ...

@activation_check('性能测试')
def loadtest_scene1(request):
    ...

autotest_scene1 函数被装饰后,就等于调用了 :

autotest_scene1 = (activation_check(capability))(autotest_scene1)

过程是这样的:

activation_check(capability) 的返回值 就是 wrapper1 函数,

wrapper1(autotest_scene1) 的返回值 就是 wrapper2 函数,

所以被装饰后,实际上调用 autotest_scene1 就变成了调用 wrapper2,

wrapper2是包含了两个外部对象 capability、 func 的闭包函数

课后练习

去做练习