【python】闭包和装饰器、通用装饰器、多个装饰器、带参装饰器、类装饰器

- 日理万妓 2022-11-28 13:44 252阅读 0赞

#### 1、闭包 ####

**概念：** 把使用了外部函数变量的内部函数称为闭包

**构成闭包的三个条件：**

*  在函数嵌套的基础上(在外部函数内定义一个内部函数)
 *  内部函数使用外部函数变量
 *  外部函数返回内部函数

**作用：** 保存外部函数定义的变量，不会随函数调用结束而销毁

**引用计数** sys.getrecount()函数可以看到引用计数，当引用计数为0则会被销毁

简单的闭包举例

def foo_outer(num1):
        # 1.函数嵌套，在函数里再定义一个内部函数
        def foo_inner(num2):
            # 2.内部函数使用了外部函数的变量num1
            res = num1 + num2
            print(res)
        # 3.外部函数返回内部函数名
        return foo_inner
    
    
    if __name__ == '__main__':
        f1 = foo_outer(100)
        f1(1)
    
        f2 = foo_outer(200)
        f2(1)

#### 2.nonlocal关键字 ####

与global关键字类似，global声明变量是全局变量，而在闭包里，想要修改外部函数的变量，需要加上关键字nonlocal，否则只是在内部定义了一个新的变量

def foo_outer(num1):
        def foo_inner(num2):
            nonlocal num1  # 声明是外部变量，而不是定义新变量
            num1 = 10 # 修改外部变量
            res = num1 + num2
            print(res)
        return foo_inner
    
    
    if __name__ == '__main__':
        f1 = foo_outer(100)
        f1(1)

#### 3.装饰器 ####

**python三大器**  
装饰器、迭代器、生成器

**装饰器**：可以给已有的函数添加功能，本质上就是一个闭包

*  闭包函数有且只有一个参数，必须是函数类型
 *  写代码要遵循开放封闭原则

**作用**：不改变原有代码，也不改变原有代码的调用方式，但可以给原代码拓展功能

写法1

def fun_outer(fn):
        def fun_inner():
            print('请先登录')
            fn()
    
        return fun_inner
        
    def comment():
        print('写评论')
        
    
    if __name__ == '__main__':
        comment = fun_outer(comment)
        comment()

写法2（语法糖格式）

def fun_outer(fn):
        def fun_inner():
            print('请先登录')
            fn()
    
        return fun_inner
    
    
    @fun_outer
    def comment():
        print('写评论')
    
    
    if __name__ == '__main__':
        comment()

#### 4.通用装饰器 ####

# 通用装饰器
    def func_outer(fn):
        def func_inner(*args, **kwargs):
            print('扩展代码')
            res = fn(*args, **kwargs)
            return res
    
        return func_inner
    
    # 被装饰的函数
    @func_outer
    def foo(*args, **kwargs):
        print(args, kwargs)
        result = 0
        for i in args:
            result += i
        for i in kwargs.values():
            result += i
        return result
    
    
    if __name__ == '__main__':
        print(foo(1, 4, 7, a=5))

#### 5.多个装饰器 ####

一个函数可以同时被多个装饰器装饰，装饰顺序遵循**就近原则**，越接近函数，越先被调用  
但是，**调用顺序正好相反**

# 第一个装饰器
    def make_div(fn):
        def inner():
            return "<div>" + fn() + "</div>"
    
        return inner
    
    
    # 第二个装饰器
    def make_p(fn):
        def inner():
            return "<p>" + fn() + "</p>"
    
        return inner
    
    
    # 同时装饰一个函数
    @make_div
    @make_p
    def comment():
        return '人生苦短，我用python'
    
    
    if __name__ == '__main__':
        print(comment())

以上代码执行过程

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MTQ3Mjk5_size_16_color_FFFFFF_t_70_pic_center]

#### 6.带有参数的装饰器 ####

其实带有参数的装饰器就是在原有的装饰器之外，再在最外层加一个函数形成新的闭包，这个闭包的参数用于保存变量不被销毁

# 在原有的装饰器外增加一个函数，用于保存变量
    def decorator(flag):
        def func_outer(fn):
            def func_inner(x, y):
                # 根据判断变量去扩展不同的功能
                if flag == '+':
                    print('这是加法运算')
                elif flag == '-':
                    print('这是减法运算')
                return fn(x, y)
    
            return func_inner
    
        return func_outer
    
    
    # 修饰加法函数
    @decorator('+')
    def add(a, b):
        return a + b
    
    
    # 修饰减法函数
    @decorator('-')
    def sub(a, b):
        return a - b
    
    
    if __name__ == '__main__':
        print(add(10, 20))
        print(sub(50, 20))

#### 7.使用类实现装饰器 ####

闭包的功能是保存参数不被销毁，我们也可以把它设置成类属性，只要类不被销毁该参数就不会被销毁。我们可以在\_\_init\_\_方法保存变量，在\_\_call\_\_()方法调用

# 创建一个类
    class Check(object):
        def __init__(self, fn):
            # 初始化的时候传进函数名，并且保存
            self.__fn = fn
    
        def __call__(self, *args, **kwargs):
            # 此方法会在类被调用的时候执行
            print('请先登录')
            self.__fn()
    
    
    @Check
    def comment():
        print('发表评论')
    
    
    if __name__ == '__main__':
        comment()  # 会执行__call__方法

#### 8.计算函数执行时间 ####

import time
    from datetime import datetime
    
    
    def get_date_time_str(dt):
        return dt.strftime("%Y-%m-%d %H:%M:%S") if dt and isinstance(dt, datetime) else None
    
    
    def outer(fn):
        print("outer_before: ", get_date_time_str(datetime.now()))
    
        def inner(*args, **kwargs):
            print("inner_before: ", get_date_time_str(datetime.now()))
            time_start = time.time()
            fn_res = fn(*args, **kwargs)
            print(time.time() - time_start)
            print("inner_after: ", get_date_time_str(datetime.now()))
            return fn_res
    
        print("outer_after: ", get_date_time_str(datetime.now()))
        return inner
    
    
    @outer
    def test():
        print("test...")
        time.sleep(3.6)
    
    
    test()
    
    # 执行结果
    # outer_before: 2021-04-18 23:11:01
    # outer_after: 2021-04-18 23:11:01
    # inner_before: 2021-04-18 23:11:01
    # test...
    # 3.604762315750122
    # inner_after: 2021-04-18 23:11:05

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MTQ3Mjk5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/9936ba83a1f741348e741e12daefd7ed.png