闭包

闭包:　　

1. 内层函数使用了外层函数的局部变量
2. 外层函数吧内层函数返回出来
3. 这个内层函数加做闭包函数

闭包的特点:

1. 内层函数使用了外层函数的变量,
2. 这个变量与内层函数发生了绑定关系,
3. 延长了他的生命周期

 

魔法方法__ closure __, 查看闭包函数使用过的变量

def outer():
    a = 110
    def inner():
        def small():
            nonlocal a
            a = 1
        return small
    return inner

res = outer()
func = res()
func()
# __closure__获取闭包函数使用过的变量
# 返回一个元祖, 里面每一个元素是使用过的变量,

print(func.__closure__)         # (<cell at 0x0000028C3ED19E28: int object at 0x0000000055AE6C10>,)


# cell_contents 是单元cell的一个属性, 获取保存的外部函数的变量
# 存放离得最近的外层函数的变量,或者最后一次nonlocal声明修改的变量,
# 若是外层函数的变量内层没有使用过, 将不存在这里

print(func.__closure__[0].cell_contents)        # 1

保存离得最近的那个外层函数的变量

def outer():
    a = 1
    def inner():
        a = 2
        def small():
            a = 3
            def func():
                print(a)
            return func
        return small
    return inner

res = outer()()()

# 保存离得最近的那个外层函数的变量
print(res.__closure__[0].cell_contents)     # 3

保存最后一次nonlocal声明修改的变量

def outer():
    a = 1
    def inner1():
        nonlocal a
        a = 1000

        def small():
            b = a
        return small

    def inner2():
        print(a)
    return inner1, inner2


func1, func2 = outer()
func3 = func1()

# 三个内层函数都使用了a变量
# 由于inner1使用nonlocal声明修改, 并且执行func1()了
# 这三个内层函数保存的都是inner1声明修改的a变量

print(func1.__closure__[0].cell_contents)       # 1000
print(func2.__closure__[0].cell_contents)       # 1000
print(func3.__closure__[0].cell_contents)       # 1000

测试是不是闭包:

def outer():
    a = 1
    def inner():
        print(a)
    return inner


res = outer()

# 判断是不是闭包函数
print(res.__closure__[0].cell_contents)
测试是不是闭包
    内层函数.__closure__
    返回是一个元祖, 是闭包
    如果是None , 就不是闭包