难以理解 Python 中传递值和引用

Question

遇到对象何时更改以及何时不在 Python 中的问题。下面是我设计得很糟糕的示例：

class person:
    age = 21

class bar:
    def __init__(self, arg1):
        self.foo = arg1
        self.foo.age = 23

def baz(arg1):
    arg1.age = 27

def teh(arg1):
    arg1 = [3,2,1]

Person1 = person()
bar1 = bar(Person1)

print Person1.age
print bar1.foo.age

baz(Person1)

print Person1.age
print bar1.foo.age

meh = [1,2,3]
teh(meh)
print meh

输出为

23
23
27
27
[1, 2, 3]

因此，当我们声明 Person1 时，Person1.age 为 21。对此对象的引用将传递给 bar 的另一个类实例（称为 bar1）的类构造函数。对此引用所做的任何更改都会更改 Person1。

当我们将 Person1 传递给普通函数时也是这种情况，Person1.age 现在等于 27。

但是为什么这对变量“meh”不起作用？当然，如果我们赋值一个变量a = meh并改变a = [6, 6, 6]，那么meh也会改变。我很困惑。有没有关于这一切如何运作的文献？

Answer 1

我可以看到三个基本的 Python 概念可以阐明这个问题：

1）首先，从像 in 这样的可变对象进行赋值

self.foo = arg1

就像复制指针（而不是指向的值）：self.foo 和 arg1 是同一个对象。这就是接下来的行

self.foo.age = 23

修改 arg1 （即 Person1）的原因。 变量因此是可以指向唯一对象的不同“名称”或“标签”（此处为person对象）。这解释了为什么 baz(Person1) 将 Person1.age 和 bar1.foo.age 修改为 27，因为 < code>Person1 和 bar1.foo 只是相同 person 对象的两个名称（Person1 是 bar1.foo 返回True，在 Python 中）。

2）第二个重要的概念是作业。变量

def teh(arg1):
    arg1 = [3,2,1]

arg1 是本地变量，因此代码

meh = [1,2,3]
teh(meh)

首先执行 arg1 = meh，这意味着 arg1 是列表的附加（本地）名称嗯；但执行 arg1 = [3, 2, 1] 就像在说“我改变了主意：arg1 从现在开始将是一个new的名称em> 列表，[3,2,1]”。这里要记住的重要一点是，尽管用“等号”表示，但赋值是不对称的：它们为右侧的（可变）对象提供了一个附加名称，在左侧给出（这就是为什么你不能这样做 [3, 2, 1] = arg1，因为左侧必须是一个名称[或多个名称]）。所以，arg1 = meh; arg1 = [3, 2, 1] 无法更改 meh。

3）最后一点与问题标题相关：“按值传递”和“按引用传递”不是Python中相关的概念。相关概念是“可变对象”和“不可变对象”。列表是可变的，而数字则不然，这解释了您所观察到的情况。此外，您的 Person1 和 bar1 对象是可变的（这就是您可以更改此人的年龄的原因）。您可以在文本教程和视频教程。维基百科还有一些（更多技术性）信息。一个示例说明了可变和不可变之间的行为差​​异：

x = (4, 2)
y = x  # This is equivalent to copying the value (4, 2), because tuples are immutable
y += (1, 2, 3)  # This does not change x, because tuples are immutable; this does y = (4, 2) + (1, 2, 3)

x = [4, 2]
y = x  # This is equivalent to copying a pointer to the [4, 2] list
y += [1, 2, 3]  # This also changes x, because x and y are different names for the same (mutable) object

最后一行不相当于y = y + [1, 2, 3]，因为这只会放置一个变量y中的新列表对象，而不是更改y和x引用的列表。

上面的三个概念（变量作为名称[用于可变对象]、不对称赋值和可变性/不可变性）解释了 Python 的许多行为。

Answer 2

当然，如果我们赋值一个变量 a = meh 并改变 a = [6, 6, 6]，那么 meh 也会改变。

不，实际上，它不会：

>>> meh = [1,2,3]
>>> a = meh
>>> a = [6, 6, 6]
>>> print a
[6, 6, 6]
>>> print meh
[1, 2, 3]

这是覆盖变量和修改变量指向的实例之间的区别。

列表、字典、集合和对象是可变类型。如果您在其中的实例中添加、删除、设置、获取或以其他方式修改某些内容，则会更新引用该实例的所有内容。

但是，如果您将类型的全新实例分配给变量，则会更改存储在该变量中的引用，因此旧的引用实例不会更改。

---

a = [1,2,3] # New instance
a[1] = 4    # Modifying existing instance

b = {'x':1, 'y':2} # New instance
b['x'] = 3         # Modifying existing instance

self.x = [1,2,3] # Modifying existing object instance pointed to by 'self',
                 # and creating new instance of a list to store in 'self.x'

self.x[0] = 5    # Modifying existing list instance pointed to by 'self.x'

Answer 3

Python 没有按值传递，也没有按引用传递，而是使用按对象传递——换句话说，对象直接传递到函数中，并绑定到函数定义中给出的参数名称。

当您执行 spam = "green" 时，您已将名称 spam 绑定到字符串对象“green”；如果您随后执行“eggs = spam”，则您没有复制任何内容，也没有创建引用指针；您只需将另一个名称“eggs”绑定到同一个对象（在本例中为“green”）。如果您随后将垃圾邮件绑定到其他内容（垃圾邮件 = 3.14159），鸡蛋仍将绑定到“绿色”。

在您的 teh 函数中，您不会更改/修改/改变传入的对象，而是将名称 arg1 重新分配给不同的列表。要更改 arg1 你需要这样：

def teh(arg1):
    arg1[:] = [3, 2, 1]