如何避免定义大量命名函数？上下文管理器context作用域问题求解

你遇到的核心问题是：闭包捕获的是变量的引用而非值，导致多个handler共享同一个外部变量，最终调用时都使用变量的最后赋值结果。以下是几种可行的替代方案，无需定义大量唯一命名的函数：

方案一：使用函数工厂生成handler #

通过一个工厂函数封装handler的创建逻辑，将目标值作为参数传入工厂，每个生成的handler会独立捕获自己的参数值，避免变量共享：

subscribers = []
def subscribe(handler):
    subscribers.append(handler)

def create_handler(target):
    def handler():
        print(f'target = {target}')
        return target
    return handler

# 生成并订阅handler
subscribe(create_handler('target 1'))
subscribe(create_handler('target 2'))

for subscriber in subscribers:
    subscriber()

执行结果：

target = target 1
target = target 2

方案二：利用默认参数绑定当前值 #

在定义handler时，将外部变量的值绑定到函数的默认参数上——默认参数会在函数定义时计算并固定值，而非调用时：

subscribers = []
def subscribe(handler):
    subscribers.append(handler)

# 第一个handler
context = 'target 1'
def handler(ctx=context):
    print(f'target = {ctx}')
    return ctx
subscribe(handler)

# 第二个handler
context = 'target 2'
def handler(ctx=context):
    print(f'target = {ctx}')
    return ctx
subscribe(handler)

for subscriber in subscribers:
    subscriber()

执行结果与方案一一致，每个handler的ctx参数会保留定义时的context值。

方案三：用装饰器简化订阅流程 #

将订阅逻辑封装为装饰器，直接在定义handler时完成订阅，无需手动调用subscribe，同时可以复用函数名：

subscribers = []
def subscribe(handler):
    subscribers.append(handler)
    return handler

# 直接用装饰器订阅
@subscribe
def handler():
    print(f'handler 1')

@subscribe
def handler():
    print(f'handler 2')

for subscriber in subscribers:
    subscriber()

如果需要传递参数，可以让装饰器接受目标值，再包装handler：

subscribers = []
def subscribe(target):
    def decorator(handler):
        def wrapped():
            return handler(target)
        subscribers.append(wrapped)
        return wrapped
    return decorator

@subscribe('target 1')
def handler(target):
    print(f'target = {target}')
    return target

@subscribe('target 2')
def handler(target):
    print(f'target = {target}')
    return target

for subscriber in subscribers:
    subscriber()

修复上下文管理器的方案 #

如果一定要使用上下文管理器，可以在with块内定义一个局部变量绑定当前的context值，让闭包捕获这个独立的局部变量：

from contextlib import contextmanager
@contextmanager
def foo(target):
    yield target

subscribers = []
def subscribe(handler):
    subscribers.append(handler)

with foo('target 1') as context:
    current_ctx = context  # 绑定当前值到局部变量
    def handler():
        print(f'target = {current_ctx}')
        return current_ctx
    subscribe(handler)

with foo('target 2') as context:
    current_ctx = context
    def handler():
        print(f'target = {current_ctx}')
        return current_ctx
    subscribe(handler)

for subscriber in subscribers:
    subscriber()

这样每个current_ctx是各自with块的局部变量，闭包不会共享引用，就能得到正确结果。

内容的提问来源于stack exchange，提问作者nPn