虽然通过引用传递并不能很好地适应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文档建议，更改字典可能不起作用，但对我来说似乎很有用。

这里的答案有很多见解，但我认为这里没有明确提到另外一点。引用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

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

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

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

要实现更改变量的成员函数，请不要传递变量本身，而是传递包含引用该变量的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")

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