黑马程序员---闭包和装饰器

柔光的暖阳◎ 2022-11-28 13:57 125阅读 0赞

一：闭包的定义:  
目的：保证变量不会因为外部函数调用而销毁。  
1：在函数嵌套的前提下，内部函数使用了外部函数的变量，外部函数返回了内部函数，我们把这个使用外部函数变量的**内部函数**称为闭包。  
2：闭包的形成条件:  
函数嵌套 //内部函数使用了外部函数的变量 // 外部函数返回了内部函数对象。  
3：简单闭包：

def func_out(num1):
        def func_inner(num2):
            result = num1 + num2;
            print("结果是：",result)
        return func_inner
    
    f = func_out(1)
    
    f(2)
    f(3)

4:闭包的作用：闭包可以保存外部函数内的变量，不会随着外部函数调用完而销毁。  
5：为什么不会随着外部函数的调用而销毁？  
答：**变量当自己的引用计数等于0的时候就会被销毁。当将1赋值给num1的时候num1的引用计数是1，然后定义fun\_inner，由于fun\_inner里面用到了num1(result = num1 + num2;)，所以num1的引用计数变成了2，最后函数调用完成时，销毁所有变量（本质是引用变量减一），所以num1引用计数又变成了1。所以外层函数调用完，变量是不会销毁的。**  
6：修改闭包内使用的外部变量。nonlocal关键字：  
**nonlocal是使用外层函数内的变量，如果不写，实际上是内层定义的自己新的变量与外层的变量是无关的。**

# 定义一个外部函数
    def func_out(num1):
    
        # 定义一个内部函数
        def func_inner(num2):
            # 这里本意想要修改外部num1的值，实际上是在内部函数定义了一个局部变量num1
            nonlocal num1  # 告诉解释器，此处使用的是 外部变量a
            # 修改外部变量num1
            num1 = 10
            # 内部函数使用了外部函数的变量(num1)
            result = num1 + num2
            print("结果是:", result)
    
        print(num1)
        func_inner(1)
        print(num1)
    
        # 外部函数返回了内部函数，这里返回的内部函数就是闭包
        return func_inner
    
    # 创建闭包实例
    f = func_out(1)
    # 执行闭包
    f(2)

二：装饰器：特殊的闭包。：区别是只有一个变量，并且变量是函数类型。  
1：定义：给已有函数增加额外功能的函数。  
2：功能特点：  
**不修改已有函数的源代码  
不修改已有函数的调用方式  
给已有函数增加额外的功能**  
3：简单代码：

def check(fn):
        def inner():
            print("请先登录")
            fn()
        return inner
    
    
    def comment():
        print("发表评论")
    
    comment = check(comment)
    comment()

分析：开始comment 指向本函数，check(comment)让fn和comment 同时指向本函数，当check返回inner的时候，comment重新指向修饰函数的内层函数。此时（comment指向修饰函数内层函数，fn指向了本函数）。当我们调用comment（）函数的时候是执行修饰函数的内层函数，而内层函数又可以调用本函数，所以上实现了在本函数上扩展功能，但是不修改本函数。  
4：语法糖写法：@修饰函数

# 添加一个登录验证的功能
    def check(fn):
        print("装饰器函数执行了")
        def inner():
            print("请先登录....")
            fn()
        return inner
    
    # 使用语法糖方式来装饰函数
    @check
    def comment():
        print("发表评论")
    
    
    comment()

5：利用修饰器计算函数的执行时间：

import time
    
    def out_hello(fn):
        def inner_hello():
            before = time.time()
            fn()
            after = time.time()
            print("函数所用时间是：", after-before)
        return inner_hello
    
    @out_hello
    def print_hello():
        for i in range(100000):
            print("hello:%d" % i)
    
    ph = print_hello()

6：装饰器能不能携带参数？可以返回值吗？

def out_count(fn):
        def inner_count(num1,num2):
            print("正在做加法其他的功能。。。")
            sum = fn(num1,num2)
            print("做完加法做其他的。。。。。")
            return sum
    
        return inner_count
    
    @out_count
    def count_num(num1,num2):
        sum = num1 + num2
        print("num1 + num2=",sum)
        return sum
    
    sum = count_num(1,2)
    print("最后结果: %d" % sum)

分析装饰过程：@out\_count 本质是：count\_num = out\_count(count\_num), 首先开始的时候，count\_num指向本函数，传参过去后，fn和count\_num同时指向本函数，当装饰函数返回inner\_count的时候，count\_num重新指向装饰内层函数。  
调用过程：count\_num(1,2)，先调用装饰内层函数，将1，2传递给inner\_count(num1,num2) ，当执行到 sum = fn(num1,num2)的时候，inner\_count(num1,num2) 中的num1 和num2赋值给fn(num1,num2)中的num1和num2，而fn此时指向本函数，所以又将fn中的num1，num2传递给count\_num(num1,num2)。当count\_num执行完后将sum返回给装饰器函数内层函数中的sum,最后这个内层函数又把自己的sum，返回给主程序数中的sum。

注意：由于传参先传给装饰器内层函数，然后内存函数调用外层传进来的函数，最后调用本函数。所以参数个数，内层函数，内层中的外层传入的函数，都要和本函数保持一致。

7：装饰器可以携带不定长参数吗？

def loging(fn):
        def inner(*args,**kwargs):
            print("----输出执行函数前的日志信息")
            # 注意这里是用到拆包技术，这里是把inner(参数中的)变成1,2,3,x=100,y=200这种格式
            sum = fn(*args,**kwargs)
            print("-----输出函数执行后的日志信息")
            return sum
    
        return inner
    
    @loging
    def sum_num(*args ,**kwargs):
    
        sum = 0
        for i in args:
            sum = sum + i
        for i in kwargs.values():
            sum = sum + i
        return sum
    
    sum = sum_num(1,2,3,x=100,y=200)
    print("求和之后的结果是：", sum)

8：多个装饰器如何执行流程???

def add_div(fn2):
        def inner_div():
            return "<div>" + fn2() + "</div>"
        return inner_div
    
    
    def add_p(fn1):
        def inner_p():
            return "<p>"+fn1()+ "</p>"
        return inner_p
    
    
    @add_div
    @add_p
    def content():
        return "人生苦短，我用python!"
    
    main_content = content()
    print(main_content)

输出结果：

<div><p>人生苦短，我用python!</p></div>

分析：装饰过程：

`**@add_p 相当于：content = add_p(content),开始时，content指向本函数，当调用add_p(content) 后，fn1也指向本函数，然后add_p返回给content自己的内层函数，所以此时content指向第一个修饰器的内层函数。@add_div 相当于 content = add_div(content)，此时开始content 指向第一个修饰器的内层函数，通过传参将第一个修饰器的内层函数传递给fn2,然后add_div把自己的内层函数返回给content，所以content指向第二个修饰器的内层函数。**`

总结：**最终content指向第二个修饰器的内层函数，fn2指向第一个修饰器的内层函数，fn1指向本函数 content()。**

调用过程：**`调用过程：content()实际上等于inner_div()，所以先调用inner_div，然后执行 fn2()，实际上是inner_p()，然后执行fn1实际上是content()函数。然后从content函数开始向上返回，content向上返回给inner_p："人生苦短，我用python!"，inner_p组合后向上返回给inner_div:<p>人生苦短，我用python!</p>,然后inner_div向上返回给主程序<div><p>人生苦短，我用python!</p></div>`**

9：带有参数的装饰器：

def logging(flag):
    
        def out_num(fn):
    
            def inner_num(x,y):
                if flag == "+":
                    print("这是加法操作的准备工作")
                    sum2 = fn(x,y)
                    return sum2
    
                elif flag == "-":
                    print("这是减法操作的准备工作")
                    mul2 = fn(x,y)
                    return mul2
    
            return inner_num
        return out_num
    
    
    
    @logging("+")
    def add_num(a,b):
        sum = a+b
        return sum
    
    
    @logging("-")
    def mul_num(a,b):
        mul = a-b
        return mul
    
    sum = add_num(1,2)
    print(sum)
    
    mul = mul_num(2,1)
    print(mul)

分析：@logging("+"):可以拆分成两部分：logging("+")传递给装饰器外层的函数，返回一个装饰器类型的对象out\_num 然后@和out\_num 又拼接成语法糖。  
问题：为什么在修饰器外面增加一个函数，内部就能访问传入参数呢？  
由于这个外层函数传入变量，返回内层函数，内层函数使用外层函数变量，所以修饰器实际上是一个闭包了，而披上的是外层函数，闭包内可以访问外层函数变量。  
10：类装饰器：

class Check(object):
        def __init__(self ,fn):
            self.__fn = fn;
        def __call__(self, *args, **kwargs):
            print("发表评论前的准备工作。。。")
            self.__fn()
        
    @Check
    def comment():
        print("发表评论")
    
    comment()

@Check 等价于 comment = Check(comment), 所以需要提供一个init方法，并多增加一个fn参数。  
要想类的实例对象能够像函数一样调用，需要在类里面使用call方法，把类的实例变成可调用对象(callable)，也就是说可以像调用函数一样进行调用。  
在call方法里进行对fn函数的装饰，可以添加额外的功能。