由于似乎没有地方提到，例如C ++所知的一种模拟引用的方法是使用“更新”函数并传递该函数而不是实际变量（或“名称”）：

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

这对于“仅引用”或在具有多个线程/进程的情况下（通过使更新功能线程/多处理安全）最有用。

显然，以上内容不允许读取值，而只能对其进行更新。

您只能将一个空类用作存储参考对象的实例，因为内部对象属性存储在实例字典中。参见示例。

class RefsObj(object):
    "A class which helps to create references to variables."
    pass

...

# an example of usage
def change_ref_var(ref_obj):
    ref_obj.val = 24

ref_obj = RefsObj()
ref_obj.val = 1
print(ref_obj.val) # or print ref_obj.val for python2
change_ref_var(ref_obj)
print(ref_obj.val)

A lot of insights in answers here, but i think an additional point is not clearly mentioned here explicitly. Quoting from python documentation https://docs.python.org/2/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python

"In Python, variables that are only referenced inside a function are implicitly global. If a variable is assigned a new value anywhere within the function’s body, it’s assumed to be a local. If a variable is ever assigned a new value inside the function, the variable is implicitly local, and you need to explicitly declare it as ‘global’. Though a bit surprising at first, a moment’s consideration explains this. On one hand, requiring global for assigned variables provides a bar against unintended side-effects. On the other hand, if global was required for all global references, you’d be using global all the time. You’d have to declare as global every reference to a built-in function or to a component of an imported module. This clutter would defeat the usefulness of the global declaration for identifying side-effects."

即使将可变对象传递给函数，这仍然适用。并且向我清楚地说明了在函数中分配给对象和对对象进行操作之间行为不同的原因。

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的东西，应该很少使用，但是有些变通办法实际上可以起作用，以使当前分配给局部变量的对象甚至从被调用函数内部重新分配局部变量。

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

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

def change(wrapper):
    wrapper(7)

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

相同的想法适用于读取和del设置变量。

对于正读，甚至有一种更短的使用方法，lambda: x该方法返回可调用对象，而被调用时将返回x的当前值。这有点像遥远的过去在语言中使用的“按名称呼叫”。

传递3个包装器来访问变量有点麻烦，因此可以将它们包装到具有proxy属性的类中：

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

借助Python的“反射”支持，可以获得一个对象，该对象能够在给定范围内重新分配名称/变量，而无需在该范围内显式定义函数：

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转换为所传递字典中的项目访问。通过传递内建的结果locals和局部变量的名称，最终访问局部变量。从3.5版开始的python文档建议更改字典可能不起作用，但似乎对我有用。

Python中的按引用传递与C ++ / Java中的按引用传递概念完全不同。

• Java＆C＃：原始类型（包括字符串）通过值（副本）传递，引用类型通过引用（地址副本）传递，因此对调用者可见的所有被调用函数中的参数更改。
• C ++：允许按引用传递或按值传递。如果参数是通过引用传递的，则可以根据是否以const形式传递参数来对其进行修改。但是，无论是否为const，该参数都将保留对对象的引用，并且无法将引用分配为指向所调用函数内的另一个对象。
• Python： Python是“按对象传递引用”，通常这样说：“对象引用按值传递。” [阅读此处] 1。调用者和函数都引用相同的对象，但是函数中的参数是一个新变量，它仅在调用者中保存对象的副本。像C ++一样，可以在函数中修改或不修改参数-这取决于传递的对象的类型。例如; 不变的对象类型不能在调用的函数中修改，而可变的对象可以更新或重新初始化。更新或重新分配/重新初始化可变变量之间的关键区别在于，更新后的值会反映在被调用函数中，而重新初始化后的值则不会。将新对象分配给可变变量的范围是python中函数的局部范围。@ blair-conrad提供的示例很好地理解了这一点。

我使用以下方法快速将几个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

这是pass by objectPython中使用的概念的简单解释（我希望如此）。
每当将对象传递给函数时，都会传递对象本身（Python中的对象实际上是您在其他编程语言中称为值的对象），而不是对该对象的引用。换句话说，当您致电时：

def change_me(list):
   list = [1, 2, 3]

my_list = [0, 1]
change_me(my_list)

正在传递实际对象-[0，1]（在其他编程语言中将其称为值）。因此，实际上该函数change_me将尝试执行以下操作：

[0, 1] = [1, 2, 3]

这显然不会改变传递给函数的对象。如果函数看起来像这样：

def change_me(list):
   list.append(2)

然后，该调用将导致：

[0, 1].append(2)

这显然会改变对象。这个答案很好地解释了。

Effbot（又名Fredrik Lundh）将Python的变量传递样式描述为按对象调用：http : //effbot.org/zone/call-by-object.htm

对象在堆上分配，指向它们的指针可以在任何地方传递。

• 当您进行诸如的分配时x = 1000，将创建一个字典条目，该条目将当前名称空间中的字符串“ x”映射到指向包含一千的整数对象的指针。

• 当您使用来更新“ x”时x = 2000，将创建一个新的整数对象，并且将字典更新为指向该新对象。旧的一千个对象保持不变（取决于其他是否引用了该对象，该对象是否可以存活）。

• 当您进行新的分配（例如）时y = x，将创建一个新的字典条目“ y”，该条目指向与“ x”条目相同的对象。

• 诸如字符串和整数之类的对象是不可变的。这仅表示没有任何方法可以在创建对象后更改该对象。例如，一旦创建了整数对象1000，它就永远不会改变。数学是通过创建新的整数对象完成的。

• 像列表这样的对象是可变的。这意味着可以通过指向该对象的任何内容来更改该对象的内容。例如，x = []; y = x; x.append(10); print y将打印[10]。空列表已创建。“ x”和“ y”都指向同一列表。该追加方法变异（更新）列表中的对象（如添加一条记录到数据库），其结果是可见的两个“X”和“Y”（就像一个数据库更新将每一个连接到该数据库中可见）。

希望能为您解决问题。

Python的传递分配方案与C ++的引用参数选项并不完全相同，但实际上与C语言（及其他语言）的参数传递模型非常相似：

• 不变的参数有效地“ 按值 ” 传递。诸如整数和字符串之类的对象是通过对象引用而不是通过复制传递的，但是由于您无论如何都不能就地更改不可变对象，因此效果很像制作副本。
• 可变参数有效地“ 通过指针 ” 传递。诸如列表和字典之类的对象也通过对象引用传递，这类似于C将数组作为指针传递的方式—可变对象可以在函数中就地更改，就像C数组一样。

（编辑-布莱尔更新了他非常受欢迎的答案，现在它是准确的）

我认为重要的是要注意到，当前职位（布莱尔·康拉德（Blair Conrad））的票数最多，尽管其结果是正确的，但根据其定义，它具有误导性并且是不正确的。尽管有许多语言（例如C）允许用户通过引用传递或通过值传递，但Python并不是其中一种。

大卫·库纳波（David Cournapeau）的答案指出了真正的答案，并解释了为什么布莱尔·康拉德（Blair Conrad）的帖子中的行为似乎是正确的，而定义却不正确。

就Python按值传递的程度而言，所有语言都是按值传递的，因为必须发送一些数据（“值”或“引用”）。但是，这并不意味着Python就象C程序员会想到的那样按值传递。

如果您想要该行为，Blair Conrad的答案很好。但是，如果您想了解为什么Python既不按值传递也不按引用传递的细节，请阅读David Cournapeau的答案。

我发现其他答案相当冗长和复杂，因此我创建了这个简单的图来解释Python处理变量和参数的方式。