这里的答案有很多见解，但我认为这里没有明确提到另外一点。引用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中使用的pass by对象概念的简单解释（我希望）。每当您将对象传递给函数时，对象本身就会被传递（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)

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

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

想想通过赋值而不是通过引用/值传递的东西。这样，只要你明白在正常任务中发生了什么，就会很清楚发生了什么。

因此，当将列表传递给函数/方法时，该列表被分配给参数名称。附加到列表将导致列表被修改。重新分配函数内的列表不会更改原始列表，因为：

a = [1, 2, 3]
b = a
b.append(4)
b = ['a', 'b']
print a, b      # prints [1, 2, 3, 4] ['a', 'b']

由于不可变类型不能被修改，它们看起来像是通过值传递的——将int传递给函数意味着将int分配给函数的参数。您只能重新分配它，但它不会更改原始变量值。

给定python处理值和对它们的引用的方式，唯一可以引用任意实例属性的方法是通过名称：

class PassByReferenceIsh:
    def __init__(self):
        self.variable = 'Original'
        self.change('variable')
        print self.variable

    def change(self, var):
        self.__dict__[var] = 'Changed'

当然，在实际代码中，您可以在dict查找中添加错误检查。

可以用[]传递

dta=“15252”正文=[dta]