问题来自对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'

由于字典是通过引用传递的，所以可以使用dict变量在其中存储任何引用的值。

# returns the result of adding numbers `a` and `b`
def AddNumbers(a, b, ref): # using a dict for reference
    result = a + b
    ref['multi'] = a * b # reference the multi. ref['multi'] is number
    ref['msg'] = "The result: " + str(result) + " was nice!"
    return result

number1 = 5
number2 = 10
ref = {} # init a dict like that so it can save all the referenced values. this is because all dictionaries are passed by reference, while strings and numbers do not.

sum = AddNumbers(number1, number2, ref)
print("sum: ", sum)             # the returned value
print("multi: ", ref['multi'])  # a referenced value
print("msg: ", ref['msg'])      # a referenced value

在这种情况下，方法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']
>>> 

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

关于这一点，已经有很多很好的答案（或者说是观点），我已经读过了，但我想提到一个缺失的答案。常见问题解答部分Python文档中的一个。我不知道发布此页面的日期，但这应该是我们的真实参考：

记住，在Python中，参数是通过赋值传递的。自从赋值只创建对对象的引用，没有别名在调用者和被调用者中的参数名之间，因此没有引用调用本身。

如果您有：

a = SOMETHING

def fn(arg):
    pass

你把它叫做fn（a），你做的和你在作业中做的完全一样。所以会发生这种情况：

arg = a

创建了对SOMETHING的其他引用。变量只是符号/名称/引用。他们不“持有”任何东西。

它既不是通过值传递，也不是通过引用传递，而是通过对象调用。参见Fredrik Lundh：

http://effbot.org/zone/call-by-object.htm

这里有一句重要的话：

“…变量[名称]不是对象；它们不能由其他变量表示或由对象引用。”

在您的示例中，当调用Change方法时，将为其创建名称空间；var成为该名称空间中字符串对象“Original”的名称。然后，该对象在两个名称空间中都有一个名称。接下来，var='Changed'将var绑定到一个新的字符串对象，因此该方法的命名空间忘记了'Original'。最后，该名称空间被遗忘，字符串“Changed”也随之消失。

数据类呢？此外，它允许您应用类型限制（也称为“类型提示”）。

from dataclasses import dataclass

@dataclass
class Holder:
    obj: your_type # Need any type? Use "obj: object" then.

def foo(ref: Holder):
    ref.obj = do_something()

我同意人们的看法，在大多数情况下，你最好考虑不要使用它。

然而，当我们谈论上下文时，我们有必要知道这一点。

不过，您可以设计显式上下文类。在进行原型设计时，我更喜欢数据类，因为来回序列化它们很容易。

干杯