Python中如何向其他函数传递变量并修改其值？

问题分析 #

你第一个示例里，self.g_a属于不可变类型（int），传递给do_something的the_variable时，实际传的是值的副本。在函数内执行the_variable = 1只是修改了这个局部变量，完全不会影响原对象self._g_a，所以最终输出还是0,0。

而第二个示例使用了可变类型（list），传递的是对象的引用，修改列表的元素（the_variable[0] = 1）会直接改变原列表的内容，因此能得到预期的1,0。

实现需求的几种方法 #

方法1：直接操作类实例属性（最直观） #

既然要修改的是类实例的属性，直接在函数里通过self访问并修改即可，不需要额外传递变量：

class TestClass:
    _g_a: int
    _g_b: int

    def __init__(self):
        self._g_a = 0
        self._g_b = 0

    @property
    def g_a(self):
        return self._g_a

    @g_a.setter
    def g_a(self, value):
        self._g_a = value

    @property
    def g_b(self):
        return self._g_b

    @g_b.setter
    def g_b(self, value):
        self._g_b = value

    def run(self):
        self.do_something("g_a", True)
        self.do_something("g_b", False)
        self.print_it()

    def do_something(self, attr_name: str, change: bool):
        if change:
            setattr(self, attr_name, 1)

    def print_it(self):
        print(self.g_a)
        print(self.g_b)


if __name__ == '__main__':
    t = TestClass()
    t.run()

通过传递属性名字符串，用setattr直接修改实例属性，运行后会输出1,0。

方法2：用可变类型包装不可变值 #

像你第二个示例那样，用列表、字典等可变类型把不可变值包裹起来，修改内部元素就能同步影响原对象：

class TestClass:
    _g_a: list[int]
    _g_b: list[int]

    def __init__(self):
        self._g_a = [0]
        self._g_b = [0]

    @property
    def g_a(self):
        return self._g_a[0]

    @g_a.setter
    def g_a(self, value):
        self._g_a[0] = value

    @property
    def g_b(self):
        return self._g_b[0]

    @g_b.setter
    def g_b(self, value):
        self._g_b[0] = value

    def run(self):
        self.do_something(self._g_a, True)
        self.do_something(self._g_b, False)
        self.print_it()

    def do_something(self, the_variable: list[int], change: bool):
        if change:
            the_variable[0] = 1

    def print_it(self):
        print(self.g_a)
        print(self.g_b)


if __name__ == '__main__':
    t = TestClass()
    t.run()

这种方式利用可变类型的引用特性，修改内部元素会同步到实例的原属性。

方法3：返回修改后的值并重新赋值 #

如果不想直接操作实例属性，也可以让函数返回修改后的值，在调用处重新赋值：

class TestClass:
    _g_a: int
    _g_b: int

    def __init__(self):
        self._g_a = 0
        self._g_b = 0

    @property
    def g_a(self):
        return self._g_a

    @g_a.setter
    def g_a(self, value):
        self._g_a = value

    @property
    def g_b(self):
        return self._g_b

    @g_b.setter
    def g_b(self, value):
        self._g_b = value

    def run(self):
        self.g_a = self.do_something(self.g_a, True)
        self.g_b = self.do_something(self.g_b, False)
        self.print_it()

    def do_something(self, the_variable: int, change: bool) -> int:
        if change:
            return 1
        return the_variable

    def print_it(self):
        print(self.g_a)
        print(self.g_b)


if __name__ == '__main__':
    t = TestClass()
    t.run()

这种方式符合Python“显式优于隐式”的设计原则，清晰展示了值的更新过程。

关键知识点 #

Python没有PHP那样的“引用传递”，而是传对象引用：

• 对于不可变类型（int、str、tuple等），传递的是值的副本，函数内修改不会影响原对象；
• 对于可变类型（list、dict、自定义对象等），传递的是对象的引用，修改对象内部内容会影响原对象，但重新赋值形参不会改变原对象。

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