除了所有关于Python中这些东西的工作原理的精彩解释之外，我看不到任何关于这个问题的简单建议。就像您创建对象和实例一样，处理实例变量并更改它们的Python方式如下：

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

    def Change(self):
        self.variable = 'Changed'

在实例方法中，通常引用self来访问实例属性。在__init__中设置实例属性并在实例方法中读取或更改它们是正常的。这也是为什么将self-als作为第一个参数传递给def Change。

另一种解决方案是创建如下静态方法：

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

    @staticmethod
    def Change(var):
        var = 'Changed'
        return var

我是Python新手，从昨天开始（尽管我已经编程45年了）。

我来这里是因为我在写一个函数，希望有两个所谓的参数。如果它只是一个out参数，我现在就不会在检查reference/value在Python中的工作方式时感到困惑。我只需要使用函数的返回值。但由于我需要两个这样的参数，我觉得我需要整理一下。

在这篇文章中，我将展示我如何解决我的问题。也许其他来到这里的人会觉得它很有价值，尽管它并不是对主题问题的答案。当然，经验丰富的Python程序员已经知道我使用的解决方案，但这对我来说是新的。

从这里的答案中，我可以很快看出Python在这方面的工作方式有点像Javascript，如果您想要引用功能，则需要使用变通方法。

但后来我在Python中发现了一些我以前在其他语言中没有见过的东西，即可以用简单的逗号分隔方式从函数中返回多个值，如下所示：

def somefunction(p):
    a=p+1
    b=p+2
    c=-p
    return a, b, c

并且你可以在调用端类似地处理它，就像这样

x, y, z = somefunction(w)

这对我来说已经足够好了，我很满意。不需要使用一些变通方法。

在其他语言中，您当然也可以返回许多值，但通常是从对象中返回，您需要相应地调整调用端。

Python的方法很好，也很简单。

如果您想通过引用进行更多模拟，可以执行以下操作：

def somefunction(a, b, c):
    a = a * 2
    b = b + a
    c = a * b * c
    return a, b, c

x = 3
y = 5
z = 10
print(F"Before : {x}, {y}, {z}")

x, y, z = somefunction(x, y, z)

print(F"After  : {x}, {y}, {z}")

这给出了这个结果

Before : 3, 5, 10  
After  : 6, 11, 660  

简单答案：

在类似于python的c++中，当您创建一个对象实例并将其作为参数传递时，不会复制实例本身，因此您可以从函数的外部和内部引用相同的实例，并且可以修改相同对象实例的组件基准，因此外部可以看到更改。

对于基本类型，python和c++的行为也相同，因为现在创建了实例的副本，所以外部看到/修改的实例与函数内部不同。因此，外部看不到内部的变化。

下面是python和c++之间的真正区别：

c++具有地址指针的概念，而c++允许您传递指针，这绕过了对基本类型的复制，因此函数内部可以影响与外部相同的实例，因此外部也可以看到更改。这在python中没有等价的，因此如果没有变通方法（例如创建包装器类型）是不可能的。

这样的指针在python中很有用，但不像在c++中那样有必要，因为在c++中，您只能返回一个实体，而在python中，您可以返回用逗号分隔的多个值（即元组）。因此，在python中，如果您有变量a、b和c，并希望函数持久地修改它们（相对于外部），您可以这样做：

a=4
b=3
c=8

a,b,c=somefunc(a,b,c)
# a,b,c now have different values here

这样的语法在c++中是不容易实现的，因此在c++中您可以这样做：

int a=4
int b=3
int c=8
somefunc(&a,&b,&c)
// a,b,c now have different values here

由于您的示例恰好是面向对象的，因此可以进行以下更改以获得类似的结果：

class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.change('variable')
        print(self.variable)

    def change(self, var):
        setattr(self, var, 'Changed')

# o.variable will equal 'Changed'
o = PassByReference()
assert o.variable == 'Changed'

从技术上讲，Python始终使用引用传递值。我将重复我的另一个回答，以支持我的发言。

Python始终使用引用传递值。没有任何例外。任何变量赋值都意味着复制参考值。没有例外。任何变量都是绑定到引用值的名称。总是

您可以将参考值视为目标对象的地址。地址在使用时自动取消引用。这样，使用引用值时，似乎可以直接使用目标对象。但在两者之间总是有一个参考点，多跳一步就可以到达目标。

下面的示例证明了Python使用的是通过引用传递：

如果参数是按值传递的，则无法修改外部lst。绿色是目标对象（黑色是存储在内存中的值，红色是对象类型），黄色是内存中的参考值，如箭头所示。蓝色实心箭头是传递给函数的参考值（通过蓝色虚线箭头路径）。丑陋的深黄色是内部字典。（实际上它也可以画成一个绿色椭圆。颜色和形状只表示它是内部的。）

您可以使用id（）内置函数来了解引用值是什么（即目标对象的地址）。

在编译语言中，变量是能够捕获类型值的内存空间。在Python中，变量是绑定到引用变量的名称（内部捕获为字符串），该引用变量保存目标对象的引用值。变量的名称是内部字典中的键，该字典项的值部分存储目标的引用值。

引用值在Python中隐藏。没有任何用于存储引用值的显式用户类型。但是，您可以使用列表元素（或任何其他合适容器类型的元素）作为引用变量，因为所有容器都将元素存储为对目标对象的引用。换句话说，元素实际上不包含在容器中——只有对元素的引用。

我解决了类似的要求，如下所示：

要实现更改变量的成员函数，请不要传递变量本身，而是传递包含引用该变量的setattr的functools.partial。在change（）内调用functools.partial将执行setttr并更改实际引用的变量。

注意，setattr需要变量的名称作为字符串。

class PassByReference(object):
    def __init__(self):
        self.variable = "Original"
        print(self.variable)        
        self.change(partial(setattr,self,"variable"))
        print(self.variable)

    def change(self, setter):
        setter("Changed")