由于似乎没有任何地方提到过模拟引用的方法，例如C++就是使用一个“update”函数并传递它而不是实际变量（或者更确切地说，“name”）：

def need_to_modify(update):
    update(42) # set new value 42
    # other code

def call_it():
    value = 21
    def update_value(new_value):
        nonlocal value
        value = new_value
    need_to_modify(update_value)
    print(value) # prints 42

这对于“仅输出引用”或具有多个线程/进程的情况（通过使更新函数线程/多处理安全）非常有用。

显然，上面不允许读取值，只允许更新它。

如果没有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中的“通过引用”与C++/Java中的“引用传递”概念截然不同。

Java&C#：基元类型（包括字符串）通过值传递（副本），引用类型通过引用传递（地址副本），因此调用方可以看到调用函数中参数的所有更改。C++：允许通过引用或通过值传递。如果参数是通过引用传递的，则可以根据参数是否作为常量传递来修改它。但是，无论是否为常量，参数都保持对对象的引用，并且不能将引用指定为指向所调用函数中的其他对象。蟒蛇：Python是“按对象引用传递”，人们常说：“对象引用是按值传递的。”。调用者和函数都引用同一个对象，但函数中的参数是一个新变量，它只是在调用者中保存对象的副本。与C++一样，参数可以在函数中修改或不修改-这取决于传递的对象类型。如；不可变对象类型不能在调用的函数中修改，而可变对象可以更新或重新初始化。更新或重新分配/重新初始化可变变量之间的一个关键区别是，更新的值会在调用的函数中反映出来，而重新初始化的值则不会。将新对象分配给可变变量的作用域是python中函数的本地作用域。@blair conrad提供的例子很好地理解了这一点。

大多数时候，要通过引用传递的变量是类成员。我建议的解决方案是使用修饰符来添加可变字段和相应的属性。该字段是变量的类包装器。

@refproperty同时添加self_myvar（可变）和self.myvar属性。

@refproperty('myvar')
class T():
    pass

def f(x):
   x.value=6

y=T()
y.myvar=3
f(y._myvar)
print(y.myvar) 

它将打印6。

将其与以下内容进行比较：

class X:
   pass

x=X()
x.myvar=4

def f(y):
    y=6

f(x.myvar)
print(x.myvar) 

在这种情况下，它不起作用。它将打印4。

代码如下：

def refproperty(var,value=None):
    def getp(self):
        return getattr(self,'_'+var).get(self)

    def setp(self,v):
        return getattr(self,'_'+var).set(self,v)

    def decorator(klass):
        orginit=klass.__init__
        setattr(klass,var,property(getp,setp))

        def newinit(self,*args,**kw):
            rv=RefVar(value)
            setattr(self,'_'+var,rv)
            orginit(self,*args,**kw)

        klass.__init__=newinit
        return klass
    return decorator

class RefVar(object):
    def __init__(self, value=None):
        self.value = value
    def get(self,*args):
        return self.value
    def set(self,main, value):
        self.value = value

虽然通过引用传递并不能很好地适应python，应该很少使用，但实际上有一些变通方法可以有效地将对象当前分配给局部变量，甚至可以从调用函数内部重新分配局部变量。

基本思想是有一个函数可以进行访问，并且可以作为对象传递给其他函数或存储在类中。

一种方法是在包装函数中使用全局（用于全局变量）或非局部（用于函数中的局部变量）。

def change(wrapper):
    wrapper(7)

x = 5
def setter(val):
    global x
    x = val
print(x)

同样的想法适用于读取和删除变量。

对于只读，还有一种更短的方法可以使用lambda:x，它返回一个可调用函数，当被调用时，该函数返回当前值x。这有点像很久以前语言中使用的“按名称调用”。

传递3个包装器来访问变量有点笨拙，因此可以将这些包装器包装到具有代理属性的类中：

class ByRef:
    def __init__(self, r, w, d):
        self._read = r
        self._write = w
        self._delete = d
    def set(self, val):
        self._write(val)
    def get(self):
        return self._read()
    def remove(self):
        self._delete()
    wrapped = property(get, set, remove)

# left as an exercise for the reader: define set, get, remove as local functions using global / nonlocal
r = ByRef(get, set, remove)
r.wrapped = 15

Pythons的“反射”支持使得可以获得能够在给定范围内重新分配名称/变量的对象，而无需在该范围内明确定义函数：

class ByRef:
    def __init__(self, locs, name):
        self._locs = locs
        self._name = name
    def set(self, val):
        self._locs[self._name] = val
    def get(self):
        return self._locs[self._name]
    def remove(self):
        del self._locs[self._name]
    wrapped = property(get, set, remove)

def change(x):
    x.wrapped = 7

def test_me():
    x = 6
    print(x)
    change(ByRef(locals(), "x"))
    print(x)

这里ByRef类包装了字典访问。因此，对wrapped的属性访问被转换为传递的字典中的项访问。通过传递内置局部变量的结果和局部变量的名称，最终访问一个局部变量。3.5版本的python文档建议，更改字典可能不起作用，但对我来说似乎很有用。

通过引用传递对象有一个小技巧，即使语言无法实现。它也适用于Java，它是一个列表，只有一项。；-）

class PassByReference:
    def __init__(self, name):
        self.name = name

def changeRef(ref):
    ref[0] = PassByReference('Michael')

obj = PassByReference('Peter')
print obj.name

p = [obj] # A pointer to obj! ;-)
changeRef(p)

print p[0].name # p->name

这是一个丑陋的黑客，但它奏效了-P