可以用[]传递

dta=“15252”正文=[dta]

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

由于字典是通过引用传递的，所以可以使用dict变量在其中存储任何引用的值。

# returns the result of adding numbers `a` and `b`
def AddNumbers(a, b, ref): # using a dict for reference
    result = a + b
    ref['multi'] = a * b # reference the multi. ref['multi'] is number
    ref['msg'] = "The result: " + str(result) + " was nice!"
    return result

number1 = 5
number2 = 10
ref = {} # init a dict like that so it can save all the referenced values. this is because all dictionaries are passed by reference, while strings and numbers do not.

sum = AddNumbers(number1, number2, ref)
print("sum: ", sum)             # the returned value
print("multi: ", ref['multi'])  # a referenced value
print("msg: ", ref['msg'])      # a referenced value

由于似乎没有任何地方提到过模拟引用的方法，例如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为每个对象分配一个唯一的标识符，可以使用Python的内置id（）函数找到该标识符。可以验证函数调用中的实际参数和正式参数是否具有相同的id值，这表明伪参数和实际参数引用了相同的对象。注意，实际参数和对应的伪参数是引用同一对象的两个名称。如果将伪参数重新绑定到函数范围中的新值/对象，这不会影响实际参数仍然指向原始对象的事实，因为实际参数和伪参数是两个名称。以上两个事实可以概括为“参数通过赋值传递”。即。，

dummy_argument = actual_argument

如果将dummy_argument重新绑定到函数体中的新对象，则actual_argument仍然引用原始对象。如果使用dummy_argument[0]=some_thing，那么这也将修改actual_argument[0]。因此，“通过引用传递”的效果可以通过修改传入的对象引用的组件/属性来实现。当然，这需要传递的对象是可变对象。

为了与其他语言进行比较，您可以说Python以与C相同的方式按值传递参数，其中当您“按引用”传递时，实际上是按值传递引用（即指针）

（编辑-布莱尔更新了他广受欢迎的答案，使其准确无误）

我认为重要的是要注意到，目前获得最多选票的帖子（布莱尔•康拉德），虽然其结果正确，但却具有误导性，并且根据其定义，几乎不正确。虽然有许多语言（如C）允许用户通过引用传递或通过值传递，但Python不是其中之一。

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

在Python是按值传递的情况下，所有语言都按值传递，因为必须发送一些数据（无论是“值”还是“引用”）。然而，这并不意味着Python是按C程序员会想到的值传递的。

如果你想要这种行为，Blair Conrad的回答很好。但如果你想知道Python既不是通过值传递，也不是通过引用传递的根本原因，请阅读大卫·库尔纳波的答案。