问题来自对Python中变量的误解。如果你习惯了大多数传统语言，你会有一个心理模型来描述以下顺序：

a = 1
a = 2

您认为a是存储值1的内存位置，然后更新为存储值2。这不是Python中的工作方式。相反，a开始作为对值为1的对象的引用，然后重新分配为对值为2的对象的参考。这两个对象可能会继续共存，即使a不再指代第一个对象；事实上，它们可以由程序内的任何数量的其他引用共享。

使用参数调用函数时，将创建一个引用传入对象的新引用。这与函数调用中使用的引用不同，因此无法更新该引用并使其引用新对象。在您的示例中：

def __init__(self):
    self.variable = 'Original'
    self.Change(self.variable)

def Change(self, var):
    var = 'Changed'

self.variable是对字符串对象“Original”的引用。当调用Change时，将创建对象的第二个引用变量。在函数内部，您将引用变量重新分配给不同的字符串对象“Changed”，但引用self.variable是独立的，不会更改。

解决此问题的唯一方法是传递一个可变对象。因为两个引用都引用同一个对象，所以对对象的任何更改都会反映在两个位置。

def __init__(self):         
    self.variable = ['Original']
    self.Change(self.variable)

def Change(self, var):
    var[0] = 'Changed'

问题来自对Python中变量的误解。如果你习惯了大多数传统语言，你会有一个心理模型来描述以下顺序：

a = 1
a = 2

您认为a是存储值1的内存位置，然后更新为存储值2。这不是Python中的工作方式。相反，a开始作为对值为1的对象的引用，然后重新分配为对值为2的对象的参考。这两个对象可能会继续共存，即使a不再指代第一个对象；事实上，它们可以由程序内的任何数量的其他引用共享。

使用参数调用函数时，将创建一个引用传入对象的新引用。这与函数调用中使用的引用不同，因此无法更新该引用并使其引用新对象。在您的示例中：

def __init__(self):
    self.variable = 'Original'
    self.Change(self.variable)

def Change(self, var):
    var = 'Changed'

self.variable是对字符串对象“Original”的引用。当调用Change时，将创建对象的第二个引用变量。在函数内部，您将引用变量重新分配给不同的字符串对象“Changed”，但引用self.variable是独立的，不会更改。

解决此问题的唯一方法是传递一个可变对象。因为两个引用都引用同一个对象，所以对对象的任何更改都会反映在两个位置。

def __init__(self):         
    self.variable = ['Original']
    self.Change(self.variable)

def Change(self, var):
    var[0] = 'Changed'

很可能不是最可靠的方法，但这是有效的，请记住，您正在重载内置str函数，这通常是您不想做的事情：

import builtins

class sstr(str):
    def __str__(self):
        if hasattr(self, 'changed'):
            return self.changed

        return self

    def change(self, value):
        self.changed = value

builtins.str = sstr

def change_the_value(val):
    val.change('After')

val = str('Before')
print (val)
change_the_value(val)
print (val)

您只能使用空类作为实例来存储引用对象，因为内部对象属性存储在实例字典中。请参见示例。

class RefsObj(object):
    "A class which helps to create references to variables."
    pass

...

# an example of usage
def change_ref_var(ref_obj):
    ref_obj.val = 24

ref_obj = RefsObj()
ref_obj.val = 1
print(ref_obj.val) # or print ref_obj.val for python2
change_ref_var(ref_obj)
print(ref_obj.val)

如果没有Python中的此功能，这可能是一个优雅的面向对象解决方案。一个更优雅的解决方案是让您从中创建子类。或者你可以把它命名为“大师班”。但是不要有一个变量和一个布尔值，让它们成为某种类型的集合。我修改了实例变量的命名，以符合PEP8。

class PassByReference:
    def __init__(self, variable, pass_by_reference=True):
        self._variable_original = 'Original'
        self._variable = variable
        self._pass_by_reference = pass_by_reference # False => pass_by_value
        self.change(self.variable)
        print(self)

    def __str__(self):
        print(self.get_variable())

    def get_variable(self):
        if pass_by_reference == True:
            return self._variable
        else:
            return self._variable_original

    def set_variable(self, something):
        self._variable = something

    def change(self, var):
        self.set_variable(var)

def caller_method():

    pbr = PassByReference(variable='Changed') # this will print 'Changed'
    variable = pbr.get_variable() # this will assign value 'Changed'

    pbr2 = PassByReference(variable='Changed', pass_by_reference=False) # this will print 'Original'
    variable2 = pbr2.get_variable() # this will assign value 'Original'
    

在这种情况下，方法Change中名为var的变量被分配了对self.variable的引用，并且您立即将字符串分配给var。它不再指向self.variable.下面的代码片段显示了如果您修改了var和self.variaable指向的数据结构（在本例中是一个列表）会发生什么：

>>> class PassByReference:
...     def __init__(self):
...         self.variable = ['Original']
...         self.change(self.variable)
...         print self.variable
...         
...     def change(self, var):
...         var.append('Changed')
... 
>>> q = PassByReference()
['Original', 'Changed']
>>> 

我相信其他人可以进一步澄清这一点。