python - 不明白这段代码显示元组拆包

Question

问题：有人可以解释一下输出吗？为什么z等于2在第二print()？

代码：

x=1
y=2
x,y,z=x,x,y
print(y,x,y,z)
z,y,z=x,y,z
print(x,y,z)

输出：

1 1 1 2
1 1 2

Answer 1

这是因为在 Python 中，您可以在同一行中从左到右声明和分配多个变量值。

x=1
y=2
x,y, ->z<- =x,x, ->y<-  then again, assignments are read from left to right, y is 2 and is passed to z, therefore z is now 2.
print(y,x,y,z)
z,y,z=x,y,z
print(x,y,z)

相同的示例但更短：

a = 10
b = 99
a, b, c = a, b, b

我们正在分配：

10 to a
99 to b

然后分别a, b, c = 10, 99, 99

在同一个注释中， print 需要动态地使用尽可能多的参数。

因此，翻译正在发生的事情是这样的：

x, y, z = 1, 1, 2
print(1, 1, 1, 2)

在你的情况下：

print(y,x,y,z)

保存值：1、1、1、2。

那是因为 x 和 y 持有 1 而值 z 持有值 2，但 y 被打印了两次，因此这也可能发生

print(z, z, z, x, y, y, z)

这将输出： (2, 2, 2, 1, 1, 1, 2)

之后，在您的代码中

z, x, y = 1, 1, 2

  print(1, 1, 2)

Answer 2

您可以在教程部分元组和序列中阅读有关元组的信息。在您的代码中，正在创建和解包元组。

例如，在第二次分配之前，zis 2。

z,y,z=x,y,z

在这里，python(1,1,2)从右侧创建了一个元组，然后在左侧解包。因此，z被重新分配给 1，y被重新分配给 1...但随后再次z被重新分配给 2，覆盖了第一个分配。

当您编写时，x,y,z您从这些变量引用的对象创建一个元组。这些对象现在有来自变量和元组的附加引用。一旦创建了该元组，它就不关心这些变量会发生什么。它没有他们的记忆，只有引用的内容。

脚本，带有运行评论

x=1
y=2
x,y,z=x,x,y        # create tuple (1,1,2) from the right hand side x,x,y
                   # then unpack left hand side: x=1; y=1; z=2.
print(y,x,y,z)
z,y,z=x,y,z        # create a tuple (1,1,2) from the right hand side x,y,z
                   # then unpack left hand side: z=1; y=1; z=1 (overwriting z)
print(x,y,z)

Answer 3

Python 元组赋值使用堆栈，因此假设 x=1 和 y=2：

x,y,z=x,x,y

抽象地翻译为：

push x (value 1) on stack:    top_of_stack(TOS) -> 1
push x (value 1) on stack:    TOS -> 1, 1
push y (value 2) on stack:    TOS -> 2, 1, 1
reverse top 3 stack entries:  TOS -> 1, 1, 2
pop stack and store in x (x=1)  TOS -> 1, 2
pop stack and store in y (y=1)  TOS -> 2
pop stack and store in z (z=2)  TOS -> empty

最终结果是 x=1, y=1, z=2，下一行：

z,y,z=x,y,z

推 x,y,z (1,1,2)，然后加载 z=1，然后 y=1，然后 z=2（覆盖 z=1）。

这是带有注释的实际反汇编：

>>> dis.dis('x=1;y=2;x,y,z=x,x,y;z,y,z=x,y,z')
  1           0 LOAD_CONST               0 (1)     # load constant 1
              2 STORE_NAME               0 (x)     # assign to x
              4 LOAD_CONST               1 (2)     # load constant 2
              6 STORE_NAME               1 (y)     # assign to y
              8 LOAD_NAME                0 (x)     # push x on stack (1)
             10 LOAD_NAME                0 (x)     # push x again on stack (1)
             12 LOAD_NAME                1 (y)     # push y on stack (2)
             14 ROT_THREE                          # two instructions reverse stack
             16 ROT_TWO                            # .. 2,1,1 becomes 1,1,2
             18 STORE_NAME               0 (x)     # pop x=1
             20 STORE_NAME               1 (y)     # pop y=1
             22 STORE_NAME               2 (z)     # pop z=2
             24 LOAD_NAME                0 (x)     # push x (1)
             26 LOAD_NAME                1 (y)     # push y (1)
             28 LOAD_NAME                2 (z)     # push z (2)
             30 ROT_THREE                          # reverse stack
             32 ROT_TWO                            #  2,1,1 becomes 1,1,2
             34 STORE_NAME               2 (z)     # pop z=1  <---
             36 STORE_NAME               1 (y)     # pop y=1      \
             38 STORE_NAME               2 (z)     # pop z=2 (overwriting previous)

你也可以更抽象地把它想象成：

1. 首先计算右侧的值。
2. 从左到右分配右边的变量。

所以：

x=1
y=2
x,y,z=x,x,y

方法：

# x,y,z=1,1,2
x=1
y=1
z=2

然后：

z,y,z=x,y,z

方法：

# z,y,z = 1,1,2
z=1
y=1
z=2   # overwriting previous z=1

Answer 4

在第 3 行，您将 z 设置为 y "x,y,z=x,x,y"