浅析Python闭包如何捕获自由变量

def make_counter():
    count = 0
    def counter():
        count += 1   # 这里会报错
        return count
    return counter

c = make_counter()
print(c())  # UnboundLocalError: local variable 'count' referenced before assignment

x = "global"  # G 层

def outer():
    x = "enclosing"  # E 层

    def inner():
        x = "local"  # L 层
        print(x)  # -> local（找到了就停）

    inner()

outer()

count = count + 1

count = 0

def make_counter():
    global count  # 声明接下来访问全局的 count
    count += 1
    return count

print(make_counter())  # 1
print(make_counter())  # 2

def make_counter():
    count = 0

    def counter():
        nonlocal count  # 声明：接下来对 count 的赋值操作，作用于外层的 count
        count += 1
        return count

    return counter

c = make_counter()
print(c())  # 1
print(c())  # 2
print(c())  # 3

def make_counter():
    count = 0  # <- E 层变量

    def counter():
        print("count 当前值:", count)  # 读 E 层变量 - 没问题
        return count  # 读 E 层变量 - 没问题

    return counter

import dis

def make_counter():
    count = 0

    def counter():
        nonlocal count
        count += 1
        return count

    return counter

# counter 函数的字节码
dis.dis(counter := make_counter())

def make_multiplier(factor):
    # factor 绑定在 make_multiplier 的局部作用域里
    def multiply(value):
        return value * factor
    return multiply

doubler = make_multiplier(2)

# make_multiplier() 已经执行完毕退出了
# 但 doubler 仍然持有 factor=2
print(doubler(5))   # 10
print(doubler(100)) # 200

>>> doubler.__closure__
(<cell at 0x...: int object at 0x...>,)
>>> doubler.__closure__[0].cell_contents
2

def processor(initial=0):
    total = initial

    def add(x):
        nonlocal total
        total += x
        return total

    def subtract(x):
        nonlocal total
        total -= x
        return total

    return add, subtract

add, subtract = processor(100)

print(add(30))     # 130，total = 100 + 30
print(subtract(20)) # 110，total = 130 - 20
print(add(10))     # 120，total = 110 + 10

def power_factory(exp):
    def power(base):
        return base ** exp
    return power

square = power_factory(2)
cube = power_factory(3)

print(square(5))  # 25
print(cube(5))    # 125

def memoized_fibonacci():
    cache = {}  # E 层变量

    def fib(n):
        if n in cache:
            return cache[n]
        if n <= 1:
            result = n
        else:
            result = fib(n-1) + fib(n-2)
        cache[n] = result
        return result

    return fib

fib = memoized_fibonacci()
print(fib(100))  # 354224848179261915075
print(fib(200))  # 280571172992510140037611908417314019

import functools
import time

def timing_decorator(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        # fn 和 elapsed_time 都是闭包变量
        start = time.perf_counter()
        result = fn(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{fn.__name__} 耗时 {elapsed:.4f}s")
        return result
    return wrapper

def create_multipliers():
    multipliers = []
    for i in range(5):
        multipliers.append(lambda x: x * i)  # i 是自由变量
    return multipliers

fns = create_multipliers()

# 全部返回 4*4=16，而不是 0*4, 1*4, 2*4, 3*4, 4*4
print([fn(4) for fn in fns])  # [16, 16, 16, 16, 16]

def create_multipliers_fixed():
    multipliers = []
    for i in range(5):
        multipliers.append(lambda x, i=i: x * i)  # i=i 把当前值绑定为默认值
    return multipliers

fns = create_multipliers_fixed()
print([fn(4) for fn in fns])  # [0, 4, 8, 12, 16]

import functools

def create_multipliers_partial():
    multipliers = []
    for i in range(5):
        multipliers.append(functools.partial(lambda x, i: x * i, i=i))
    return multipliers

def outer(x):
    def inner(y):
        # z 从更外层捕获
        def deeper(z):
            return x + y + z
        return deeper
    return inner

# 查看各层函数的自由变量
outer_fn = outer(10)
inner_fn = outer_fn(20)
deeper_fn = inner_fn(30)

>>> outer_fn.__code__.co_freevars
('x',)
>>> inner_fn.__code__.co_freevars
('x', 'y')
>>> deeper_fn.__code__.co_freevars
('x', 'y', 'z')

# __closure__ 的顺序和 co_freevars 一一对应
>>> deeper_fn.__closure__
(<cell at ...: int object at ...>, <cell at ...: int object at ...>, <cell at ...: int object at ...>)
>>> deeper_fn.__closure__[0].cell_contents, \
     deeper_fn.__closure__[1].cell_contents, \
     deeper_fn.__closure__[2].cell_contents
(10, 20, 30)