程序猿大战Python——类属性、类方法、闭包、装饰器——装饰器

二、装饰器

1、什么是装饰器

在不改变现有函数源代码以及函数调用方式的前提下，实现给函数增加额外的功能。

装饰器的本质就是一个闭包函数（三步：① 有嵌套 ② 有引用 ③ 有返回）

有返回代表外部函数返回内部函数的内存地址（内部函数的名称），不带

2、装饰器的雏形

# 要求：把登录功能封装起来（比如封装成一个函数，添加这个登录不能影响现有功能函数）
'''
装饰器：本质是一个闭包，有嵌套、有引用、有返回（返回的是函数的内存地址）
参数fn在check中也是一个局部变量
参数fn：就是要装饰的函数的函数名，如comment，如download
'''
def check(fn):
    def inner():
        # 开发登录功能
        print('登录功能')
        # 调用原函数
        fn()
    return inner
​
​
# 评论功能（前提：登录）
def comment():
    print('评论功能')
​
comment = check(comment)
comment()
​
# 下载功能（前提：登录）
def download():
    print('下载功能')
​
download = check(download)
download()

3、装饰器定义

'''
装饰器：本质就是一个闭包 ① 有嵌套 ② 有引用 ③ 有返回
'''
def check(fn):
    
    def inner():
        # 开发登录验证功能
        print('验证登录')
        # 执行原有函数
        fn()
    return inner
​
@check
def comment():
    print('发表评论')
​
comment()

4、装饰器的作用：获取程序的执行时间

'''
定义获取程序的执行时间装饰器 => 闭包（① 有嵌套 ② 有引用 ③ 有返回）
'''
import time
​
def get_time(fn):
    def inner():
        # ① 添加装饰器修饰功能（获取程序的执行时间）
        begin = time.time()
        # ② 调用fn函数，执行原函数代码
        fn()
        end = time.time()
        print(f'这个函数的执行时间：{end - begin}')
    return inner
​
​
@get_time
def demo():
    for i in range(1000000):
        print(i)
​
demo()

5、带有参数装饰器

'''
带有参数的装饰器：① 有嵌套 ② 有引用 ③ 有返回
'''
def logging(fn):
    def inner(*args, **kwargs):
        # 添加装饰器代码（输出日志信息）
        print('-- 日志信息：正在努力计算机 --')
        # 执行要修饰的函数
        fn(*args, **kwargs)  # sum_num(a, b)
    return inner
​
@logging
def sum_num(*args, **kwargs):
    result = 0
    # *args代表不定长元组参数，args = (10, 20)
    for i in args:
        result += i
    # **kwargs代表不定长字典参数， kwargs = {a:30, b:40}
    for i in kwargs.values():
        result += i
    print(result)
​
# sum_num带4个参数，而且类型不同，10和20以元组形式传递，a=30，b=40以字典形式传递
sum_num(10, 20, a=30, b=40)

6、带有返回装饰器

'''
带有返回值的装饰器：① 有嵌套 ② 有引用 ③ 有返回
如果一个函数执行完毕后，没有return返回值，则默认返回None
'''
def logging(fn):
    def inner(*args, **kwargs):
        print('-- 日志信息：正在努力计算 --')
        return fn(*args, **kwargs)  # fn() = sub_num(20, 10) = result
    return inner
​
@logging
def sub_num(a, b):
    result = a - b
    return result
​
print(sub_num(20, 10))

7、通用版本的装饰器

'''
通用装饰器：① 有嵌套 ② 有引用 ③ 有返回 ④ 有不定长参数 ⑤ 有return返回值
'''
def logging(fn):
    def inner(*args, **kwargs):
        # 输出装饰器功能
        print('-- 正在努力计算 --')
        # 调用fn函数
        return fn(*args, **kwargs)
    return inner
​
​
@logging
def sum_num1(a, b):
    result = a + b
    return result
​
print(sum_num1(20, 10))
​
@logging
def sum_num2(a, b, c):
    result = a + b + c
    return result
​
print(sum_num2(10, 20, 30))

8、装饰器高级：使用装饰器传递参数

基本语法：

def 装饰器(fn):
    ...
​
@装饰器('参数')
def 函数():
    # 函数代码

实例代码：根据传递参数不同，打印不同的日志信息

'''
通用装饰器：① 有嵌套 ② 有引用 ③ 有返回 ④ 有不定长参数 ⑤ 有return返回值
真正问题：通过装饰器传递参数，我们应该如何接收这个参数呢？
答：在logging方法的外侧在添加一个函数，专门用于接收传递过来的参数
'''
​
def logging(flag):
    # flag = + 或 flag = -
    def decorator(fn):
        def inner(*args, **kwargs):
            if flag == '+':
                print('-- 日志信息：正在努力进行加法运算 --')
            elif flag == '-':
                print('-- 日志信息：正在努力进行减法运算 --')
            return fn(*args, **kwargs)
        return inner
    return decorator
​
@logging('+')
def sum_num(a, b):
    result = a + b
    return result
​
@logging('-')
def sub_num(a, b):
    result = a - b
    return result
​
​
print(sum_num(10, 20))
print(sub_num(100, 80))

9、扩展：类装饰器

装饰器还有一种特殊的用法就是类装饰器，就是通过定义一个类来装饰函数。

class 类装饰器():
    # 装饰器代码
​
@类装饰器名称
def 函数():
    # 函数代码

举个栗子：编写一个Check类装饰器，用于实现用户的权限验证

'''
类装饰器编写规则：
① 必须有一个__init__初始化方法，用于接收要装饰函数的函数 
② 必须把这个类转换为可以调用的函数
问题：如何把一个类当做一个装饰器函数进行调用（把类当做函数）
'''
​
class Check():
    def __init__(self, fn):
        # fn就是要修饰函数的名称，当Check装饰器类被调用时，系统会自动把comment函数名称传递给fn变量
        self.__fn = fn
    # __call__方法：把一个类转换为函数的形式进行调用
    def __call__(self, *args, **kwargs):
        # 编写装饰器代码
        print('请先登录')
        # 调用comment函数本身
        self.__fn(*args, **kwargs)
​
# 编写一个函数，用于实现评论功能，底层comment = Check(comment)
@Check
def comment():
    print('评论功能')
​
# 调用comment函数，实现评论功能
comment()

@Check 等价于 comment = Check(comment), 所以需要提供一个init方法，并多增加一个fn参数。

要想类的实例对象能够像函数一样调用，需要在类里面使用call方法，把类的实例变成可调用对象(callable)，也就是说可以像调用函数一样进行调用。

在call方法里进行对fn函数的装饰，可以添加额外的功能。

目标：① 了解闭包的作用以及闭包的基本语法（三步走）

② 能独立完成通用装饰器的编写

③ 能使用装饰器传递参数