大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

装饰器

装饰器放在一个函数开始定义的地方，它就像一顶帽子一样戴在这个函数的头上。和这个函数绑定在一起。在我们调用这个函数的时候，第一件事并不是执行这个函数，而是将这个函数做为参数传入它头顶上这顶帽子，这顶帽子我们称之为 装饰器 。
 

装饰器的功能

1. 引入日志
2. 函数执行时间统计
3. 执行函数前预备处理
4. 执行函数后清理功能
5. 权限校验等场景
6. 缓存
    

Hello，装饰器

装饰器的使用方法很固定

• 先定义一个装饰器（帽子）
• 再定义你的业务函数或者类
• 最后把装饰器（帽子）扣在这个函数头上

def decorator(func):
    def wrapper(*args, **kw):
        return func()
    return wrapper

@decorator  # 也可以不用装饰器，在最底部加上function = decorator(function),效果是一样的
def function():
    print("hello, decorator")

实际上，装饰器并不是编码必须性，意思就是说，你不使用装饰器完全可以
 

装饰器的优点

• 更加优雅，代码结构更加清晰
• 将实现特定的功能代码封装成装饰器，提高代码复用率，增强代码可读性

接下来，我将以实例讲解，如何编写出各种简单及复杂的装饰器。
 

日志打印器

首先是日志打印器。 实现的功能：

• 在函数执行前，先打印一行日志告知一下主人，我要执行函数了。
• 在函数执行完，也不能拍拍屁股就走人了，咱可是有礼貌的代码，再打印一行日志告知下主人，我执行完啦。

# 这是装饰器函数，参数 func 是被装饰的函数
def logger(func):
    def wrapper(*args, **kwargs):
        print('主人，我准备开始执行：{} 函数了:'.format(func.__name__))
        # 真正执行的是这行。
        func(*args, **kwargs)
        print('主人，我执行完啦。')
    return wrapper


@logger  # 相当于add = logger(add)
def add(x, y):
    print("{} + {} = {}".format(x, y, x + y))


add(200, 50)

>>> 主人，我准备开始执行：add 函数了:
>>> 200 + 50 = 250
>>> 主人，我执行完啦。

代码解析

python解释器从上往下执行，先定义了有一个logger函数，返回的是wrapper函数的引用，当执行到@logger时候，此时内部已经生成了一个闭包，实际上这句哈就相当于add = logger(add)，add变量指向了logger函数，logger函数又返回了wrapper，所以add变量其实是指向了def wrapper函数，当执行add(200, 50)，如果没有@logger装饰器，正常来说是执行add函数下面的print语句，但是现在add变量已经指向了wrapper函数，所以此时，执行的是wrapper函数里面的内容。
 
所以输出的第一句内容是print('主人，我准备开始执行')，接着是执行func函数，此时func指向的是add函数，为什么？因为add = logger(add)是传入了变量add，所以def logger(func)就变成了def logger(add)，自然而然func(*args, **kwargs)就变成了add(*args, **kwargs)，调用的是add函数
 
所以输出的第二句是x和y的和，输出的第三句就是主人，我执行完了
结论:@logger完全可以用add = logger(add)来代替，使用@logger这种语法糖是更加方便，清晰
 

时间装饰器

实现功能：顾名思义，就是计算一个函数的执行时长。

# 定义一个计算函数时长的装饰器
def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        func(*args, **kwargs)
        end_time = time.time()
        cost = end_time - start_time
        print("花费了{}s".format(cost))
    return wrapper


# 定义一个下载图片并保存到本地
def downloadPicture(url):
    r = requests.get(url)
    data = r.content
    with open((str(random.random()) + '.jpg'), 'wb') as f:
        f.write(data)

# 使用多线程下载4张图片
@timer
def time1():
    t1 = threading.Thread(target=downloadPicture, args=('https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=2106474246,1283617636&fm=26&gp=0.jpg', ))
    t1.start()
    t2 = threading.Thread(target=downloadPicture, args=('https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=3083490177,4087830236&fm=26&gp=0.jpg', ))
    t2.start()
    t3 = threading.Thread(target=downloadPicture, args=('https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=1828982182,1114677948&fm=26&gp=0.jpg', ))
    t3.start()
    t4 = threading.Thread(target=downloadPicture, args=('https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=45058783,2028528740&fm=11&gp=0.jpg', ))
    t4.start()

# 调用time1函数
time1()

>>> 花费了0.0011370182037353516s

带参数的装饰器

通过上面两个简单的入门示例，你应该能体会到装饰器的工作原理了。
 
不过，装饰器的用法还远不止如此，深究下去，还大有文章。今天就一起来把这个知识点学透。
 
回过头去看看上面的例子，装饰器是不能接收参数的。其用法，只能适用于一些简单的场景。不传参的装饰器，只能对被装饰函数，执行固定逻辑。
 
装饰器本身是一个函数，做为一个函数，如果不能传参，那这个函数的功能就会很受限，只能执行固定的逻辑。这意味着，如果装饰器的逻辑代码的执行需要根据不同场景进行调整，若不能传参的话，我们就要写两个装饰器，这显然是不合理的。
 
比如我们要实现一个可以定时发送邮件的任务（一分钟发送一封），定时进行时间同步的任务（一天同步一次），就可以自己实现一个 periodic_task （定时任务）的装饰器，这个装饰器可以接收一个时间间隔的参数，间隔多长时间执行一次任务。
 
那我们来自己创造一个伪场景，可以在装饰器里传入一个参数，指明国籍，并在函数执行前，用自己国家的母语打一个招呼。

def say_hello(country):
    def wrapper(func):
        def deco(*args, **kwargs):
            if country == "china":
                print("你好!")
            elif country == "america":
                print('hello.')
            else:
                return
            # 真正执行函数的地方
            func(*args, **kwargs)
        return deco
    return wrapper


@say_hello("china")
def a():
    pass


@say_hello("america")
def b():
    pass


a()
b()


>>> 你好!
>>> hello.

不带参数的类装饰器

以上都是基于函数实现的装饰器，在阅读别人代码时，还可以时常发现还有基于类实现的装饰器。
 
基于类装饰器的实现，必须实现 __call__ 和 __init__两个内置函数。

• init ：接收被装饰函数
• call ：实现装饰逻辑。

还是以日志打印这个简单的例子为例

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

    def __call__(self, *args, **kwargs):
        print("[INFO]: the function {}() is running...".format(self.func.__name__))
        return self.func(*args, **kwargs)


@Logger
def say(something):
    print("say {}!".format(something))


say("hello")

>>> [INFO]: the function say() is running...
>>> say hello!

带参数的类装饰器

上面不带参数的例子，你发现没有，只能打印INFO级别的日志，正常情况下，我们还需要打印DEBUG WARNING等级别的日志。这就需要给类装饰器传入参数，给这个函数指定级别了。
 
带参数和不带参数的类装饰器有很大的不同。

• init ：不再接收被装饰函数，而是接收传入参数
• call ：接收被装饰函数，实现装饰逻辑

class Logger(object):
    def __init__(self, level='INFO'):
        self.level = level

    def __call__(self, func):  # 接受函数
        def wrapper(*args, **kwargs):
            print("[{level}]: the function {func}() is running...".format(level=self.level, func=func.__name__))
            func(*args, **kwargs)
        return wrapper  # 返回函数


@Logger(level='WARNING')
def say(something):
    print("say {}!".format(something))


say("hello")

>>> [WARNING]: the function say() is running...
>>> say hello!

参考链接：https://mp.weixin.qq.com/s/-jy7v4tt9fmMpMcfPKWNfQ