如何在类方法内定义可访问self的函数？两种方案孰优孰劣？

问题 #

如何在类方法中定义一个需要访问self的函数（例如作为threading.Thread的目标函数）？方案1是否正确，还是应当使用方案2？

方案1：嵌套闭包函数 #

import threading, time
class Foo:
    def __init__(self):
        def f():
            while True:
                print(self.a)                
                self.a += 1
                time.sleep(1)
        self.a = 1
        threading.Thread(target=f).start()
        self.a = 2
Foo()

该方案中f未将self作为参数，但似乎能正常运行，这种写法是否可靠？

方案2：类实例方法 #

import threading, time
class Foo:
    def __init__(self):
        self.a = 1
        threading.Thread(target=self.f).start()
        self.a = 2
    def f(self):
        while True:
            print(self.a)                
            self.a += 1
            time.sleep(1)
Foo()

方案分析 #

方案1的可靠性与局限性 #

这种写法语法合法且运行正常，核心原因是Python的闭包特性：嵌套函数f可以访问外层__init__作用域中的self变量引用。但它存在明显局限：

• 闭包捕获的是变量引用而非固定值：比如代码启动线程后修改self.a = 2，线程内的f会直接使用修改后的值，复杂逻辑下易引发意料之外的行为。
• 复用性差：f仅在__init__内部可见，无法被类的其他方法调用或重写。
• 可读性低：若f逻辑复杂，嵌套在__init__会让初始化代码臃肿，不利于拆分和维护。

方案2的优势 #

将f定义为类的实例方法是更符合Python面向对象规范的推荐写法：

• 逻辑清晰：实例方法天然绑定self，无需依赖闭包，代码意图一目了然。
• 复用性强：f作为类的公共方法，可被其他实例方法调用，也能在子类中重写扩展。
• 维护性好：线程执行逻辑与初始化代码分离，类结构更清晰，便于后续修改调试。

补充：线程安全问题 #

两种方案都需注意线程安全：print(self.a)和self.a += 1并非原子操作，多线程环境下可能出现数据竞争。若要保证数据一致性，建议使用threading.Lock等同步机制。

结论 #

方案1的写法可靠（语法和运行均无问题），但方案2在可读性、维护性和复用性上更优，是实际开发中的首选方案。

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