如果两个变量指向同一个对象，为什么重新分配一个变量不会影响另一个变量？

问题描述：

我试图理解变量在 Python 中的工作方式。假设我在变量中存储了一个对象a：

>>> a = [1, 2, 3]

如果我分配a给b，两者都指向同一个对象：

>>> b = a
>>> b is a
True

但如果我重新分配a或b，情况就不再如此：

>>> a = {'x': 'y'}
>>> a is b
False

这两个变量现在具有不同的值：

>>> a
{'x': 'y'}
>>> b
[1, 2, 3]

我不明白为什么变量现在不同了。为什么a is b不再正确？有人能解释一下发生了什么吗？

解决方案 1：

Python 中的名称指的是对象。对象独立于名称而存在，名称也独立于其所引用的对象而存在。

# name a
a = 1337
    # object 1337

当将“名称赋给名称”时，右侧将计算为所引用的对象。与2 + 2计算为类似4，a计算为原始1337。

# name b
b = a
    # object referred to by a -> 1337

此时，我们有a -> 1337和b -> 1337- 请注意，两个名字都不认识对方！如果我们测试a is b，两个名称将被评估为同一个对象，这显然是相等的。

重新分配名称只会改变该名称所指的内容 - 不存在可以更改其他名称的联系。

# name a - reassign
a = 9001
  # object 9001

此时，我们有a -> 9001和b -> 1337。如果我们现在测试a is b，两个名称将被评估为不同的对象，它们是不一样的。

如果您使用过 C 等语言，那么您会习惯于包含值的变量。例如，char a = 12可以读作“a是包含 的内存区域12”。最重要的是，您可以让多个变量使用相同的内存。将另一个值赋给变量会更改共享内存的内容 - 从而更改两个变量的值。

+- char a -+
|       12 |
+--char b -+

# a = -128

+- char a -+
|     -128 |
+--char b -+

这不是 Python 的工作方式：名称不包含任何内容，但引用单独的值。例如，a = 12可以读作“a是一个引用值的名称12”。最重要的是，您可以让多个名称引用同一个值 - 但它们仍然是单独的名称，每个名称都有自己的引用。将另一个值分配给名称会更改该名称的引用 - 但另一个名称的引用保持不变。

+- name a -+ -\n               \n                --> +- <12> ---+
               /    |       12 |
+- name b -+ -/     +----------+

# a = -128
                    +- <-128> -+
+- name a -+ -----> |     -128 |
                    +----------+

                    +- <12> ---+
+- name b -+ -----> |       12 |
                    +----------+

容易让人混淆的是，可变对象似乎违反了名称和对象的分离。通常，这些是容器（例如list，，dict...），并且类默认表现出相同的行为。

# name m
m = [1337]
    # object [1337]
# name n
n = m
    # object referred to by m

与普通整数 类似1337，包含整数的列表[1337]是可以用多个独立名称引用的对象n is m。如上所述，计算结果为True并且m = [9001]不会改变n。

但是，对名称执行某些操作会改变该名称和所有别名所看到的值。

# inplace add to m
m += [9001]

经过此操作后，m == [1337, 9001] 和 n is m仍然成立。事实上，看到的值n也变为了[1337, 9001]。这似乎违反了上述行为，其中别名不会相互影响。

这是因为m += [9001]并没有改变m所引用的内容。它只改变了所引用的列表（和别名）的内容。和仍然引用原始列表对象，其值已更改。m`nmn`

+- name m -+ -\n                                 
                --> +- […] -+     +--- <@0> -+
               /    |    @0 |  -> |     1337 |
+- name n -+ -/     +-------+     +----------+

# m += [9001]

+- name m -+ -\n                                 
                --> +- […] -+     +--- <@0> -++--- <@1> -+
               /    | @0 @1 |  -> |     1337 ||     9001 |
+- name n -+ -/     +-------+     +----------++----------+

解决方案 2：

在 Python 中，所有变量都存储在字典或看起来很像字典的结构中（例如，locals()可以将当前范围/命名空间显示为字典）。

注意：PyObject*是 CPython 概念。我不确定在其他 Python 实现中情况如何。

因此，将 Python 变量视为具有精确内存位置的 C 变量是错误的。它们的值是PyObject*（指针或内存位置），而不是实际的原始值。由于变量本身只是指向PyObject*指针的字典中的条目，因此更改变量的值实际上是为其提供了一个不同的内存地址。

在 CPython 中，这些值被和PyObject*使用（与 相同）。id`isa is bid(a) == id(b)`

例如，让我们考虑一下简单的代码行：

# x: int
x += 1

实际上改变了与变量关联的内存位置。这是因为它遵循以下逻辑：

LOAD_FAST (x)
LOAD_CONST (1)
INPLACE_ADD
STORE_FAST (x)

字节码大致如下：

1. 查找 x 的值。在 CPython 中，它是PyObject*指向PyLongLong或 这样的（int来自 Python 用户空间）

2. 从常量内存地址加载值

3. 将两个值相加。这将产生一个新的PyObject*，它也是一个int

4. 将与之关联的值设置x为这个新指针

TL;DR：Python 中的所有内容（包括基元）都是对象。变量本身并不存储值，而是存储封装它们的指针。重新分配变量会更改与该名称关联的指针，而不会更新保存在该位置的内存。

解决方案 3：

“假设我在变量 a 中存储了一个对象”——这就是你错的地方。

Python 对象不存储在变量中，而是通过变量引用。

a = [1, 2, 3]
b = a

a并b引用同一个对象。该list对象的引用计数为 2，因为有两个名称引用它。

a = {'x': 'y'}

a不再引用同一个list对象，而是引用一个dict对象。这会减少该对象的引用计数list，但b仍引用该对象，因此该对象的引用计数现在为 1。

b = None

这意味着b现在引用了None对象（该对象的引用计数非常高，许多名称都引用了None）。该list对象的引用计数再次减少，并降至零。此时，该list对象可以被垃圾回收，内存被释放（何时发生这种情况无法保证）。

参见sys.getrefcount

解决方案 4：

我用外行人能理解的语言向你解释，以便你能够轻松理解。

案例1

a = [1, 2, 3]
b = a
print(b is a)

的值a是[1,2,3]。现在我们将也[1,2,3]赋给。因此两者具有相同的值，因此 = 。b`ab is aTrue`

下一步，

a = {'x': 'y'}
print(a is b) 

现在您将 的值更改a为 ，{'x':'y'} 但我们的b值仍然与 相同[1,2,3]。因此现在a is b是False。

案例 2如果您已完成以下操作：-

a = [1, 2, 3]
b = a
print(b is a)
a = {'x': 'y'}
b = a  # Reassigning the value of b.
print(a is b)

重新分配 的值后a，我还将重新分配 的值。因此，在两种情况下b您都会得到。True

我希望这对你有帮助。