简单答案：

在类似于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

我使用以下方法将一些Fortran代码快速转换为Python。的确，它不像最初提出的问题那样通过引用传递，但在某些情况下是一个简单的解决方案。

a=0
b=0
c=0
def myfunc(a,b,c):
    a=1
    b=2
    c=3
    return a,b,c

a,b,c = myfunc(a,b,c)
print a,b,c

如果没有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'
    

Python中没有变量

理解参数传递的关键是停止思考“变量”。Python中有名称和对象看起来像变量，但始终区分这三个变量是有用的。

Python有名称和对象。赋值将名称绑定到对象。向函数传递参数还将名称（函数的参数名称）绑定到对象。

这就是它的全部。变异性与这个问题无关。

例子：

a = 1

这将名称a绑定到保存值1的integer类型的对象。

b = x

这将名称b绑定到名称x当前绑定到的同一对象。之后，名称b与名称x不再相关。

请参见Python 3语言参考中的3.1和4.2节。

如何阅读问题中的示例

在问题中显示的代码中，self.Change（self.variable）语句将名称var（在函数Change的作用域中）绑定到保存值“Original”的对象，赋值var='Changed'（在函数Change的主体中）再次将相同的名称分配给某个其他对象（恰好也包含字符串，但可能完全是其他对象）。

如何通过引用传递

因此，如果要更改的对象是可变对象，则没有问题，因为所有内容都是通过引用有效传递的。

如果它是一个不可变对象（例如布尔值、数字、字符串），那么方法是将它包装在一个可变对象中。对于这一点，快速而肮脏的解决方案是一个单元素列表（而不是self.variable，传递[self.variable]并在函数中修改var[0]）。更像蟒蛇的方法是引入一个简单的单属性类。该函数接收类的实例并操作属性。

这里的答案有很多见解，但我认为这里没有明确提到另外一点。引用python文档https://docs.python.org/2/faq/programming.html#what-是python中局部和全局变量的规则

“在Python中，仅在函数内部引用的变量是隐式全局的。如果在函数体中的任何位置为变量分配了新值，则假定该变量是局部的。如果变量在函数内部被分配了新的值，则该变量隐式是局部的，您需要将其显式声明为“全局”。虽然一开始有点令人惊讶，但片刻的考虑可以解释这一点。一方面，要求全局分配变量可以防止意外的副作用。另一方面，如果所有全局引用都需要全局引用，那么您将一直使用全局引用。您必须将对内置函数或导入模块组件的每个引用声明为全局引用。这种混乱将破坏全球宣言在确定副作用方面的作用。"

即使在将可变对象传递给函数时，这仍然适用。对我来说，这清楚地解释了分配给对象和在函数中操作对象之间行为差异的原因。

def test(l):
    print "Received", l , id(l)
    l = [0, 0, 0]
    print "Changed to", l, id(l)  # New local object created, breaking link to global l

l= [1,2,3]
print "Original", l, id(l)
test(l)
print "After", l, id(l)

给予：

Original [1, 2, 3] 4454645632
Received [1, 2, 3] 4454645632
Changed to [0, 0, 0] 4474591928
After [1, 2, 3] 4454645632

因此，对未声明为全局的全局变量的赋值将创建一个新的局部对象，并断开与原始对象的链接。

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

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