使用setattr循环动态绑定类方法时变量引用异常求助

这是Python闭包的延迟绑定特性导致的：循环中定义的函数some_func并没有直接捕获当前循环迭代的pass_this值，而是持有对变量pass_this的引用。当你后续调用f.bar()或f.bar2()时，循环已经结束，pass_this变量指向的是最后一次迭代的值"passed-for-bar2"，所以所有动态绑定的方法都会使用这个值。而__doc__是直接赋值的字符串字面量，每次循环都会生成独立的字符串对象，不受变量引用影响。

以下几种方法可以解决这个闭包绑定问题：

1. 利用函数默认参数捕获当前值 #

在定义内部函数时，将pass_this作为默认参数传入，这样每次循环迭代时，当前的pass_this值会被绑定到函数的默认参数中，而非引用循环变量：

class Foo2:
    def do_this(self, pass_this: str):
        print(pass_this)

class Foo:
    def __init__(self):
        self.reference = "ti-hihi"
        self.foo2 = Foo2()
        for (method_name, pass_this) in [("bar", "passed-for-bar"), ("bar2", "passed-for-bar2")]:
            my_doc = f"""my_custom_docstring: {pass_this}"""
            
            def some_func(pass_this=pass_this):
                self.foo2.do_this(pass_this=pass_this)
            some_func.__doc__ = my_doc
            setattr(self, method_name, some_func)

if __name__ == '__main__':
    f = Foo()
    f.bar()  # 输出 "passed-for-bar"
    f.bar2() # 输出 "passed-for-bar2"

2. 使用functools.partial绑定参数 #

functools.partial可以帮我们预先固定函数的参数值，避免闭包的延迟绑定问题：

from functools import partial

class Foo2:
    def do_this(self, pass_this: str):
        print(pass_this)

class Foo:
    def __init__(self):
        self.reference = "ti-hihi"
        self.foo2 = Foo2()
        for (method_name, pass_this) in [("bar", "passed-for-bar"), ("bar2", "passed-for-bar2")]:
            my_doc = f"""my_custom_docstring: {pass_this}"""
            
            def some_func(pass_this_val):
                self.foo2.do_this(pass_this=pass_this_val)
            some_func.__doc__ = my_doc
            # 预先绑定当前的pass_this值
            bound_func = partial(some_func, pass_this)
            setattr(self, method_name, bound_func)

if __name__ == '__main__':
    f = Foo()
    f.bar()  # 输出 "passed-for-bar"
    f.bar2() # 输出 "passed-for-bar2"

3. 用工厂函数创建独立作用域 #

通过外层工厂函数创建独立的作用域，保存当前迭代的pass_this值，确保内部函数捕获的是当前值而非变量引用：

class Foo2:
    def do_this(self, pass_this: str):
        print(pass_this)

class Foo:
    def __init__(self):
        self.reference = "ti-hihi"
        self.foo2 = Foo2()
        
        # 定义工厂函数
        def create_method(pass_this_val):
            def inner_func():
                self.foo2.do_this(pass_this=pass_this_val)
            return inner_func
            
        for (method_name, pass_this) in [("bar", "passed-for-bar"), ("bar2", "passed-for-bar2")]:
            my_doc = f"""my_custom_docstring: {pass_this}"""
            some_func = create_method(pass_this)
            some_func.__doc__ = my_doc
            setattr(self, method_name, some_func)

if __name__ == '__main__':
    f = Foo()
    f.bar()  # 输出 "passed-for-bar"
    f.bar2() # 输出 "passed-for-bar2"

• lambda方案：你的lambda仍然引用了循环变量pass_this，并没有捕获当前迭代的值，本质还是延迟绑定，所以问题依旧。
• deepcopy方案：问题的核心不是变量值被修改，而是闭包引用的是变量本身而非值，深拷贝变量无法改变闭包的绑定逻辑，因此无效。

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