Question

在许多参考文献中，我们读到多个分配使用元组并在内部拆包元组。

如果我们反汇编带有四个变量的示例，那么我们可以看到它的作用：

import dis

code = """
a = 1
b = 2
c = 3
d = 4

d, c, b, a = a, b, c, d
"""

print(dis.dis(code))

输出：

  2           0 LOAD_CONST               0 (1)
              2 STORE_NAME               0 (a)

  3           4 LOAD_CONST               1 (2)
              6 STORE_NAME               1 (b)

  4           8 LOAD_CONST               2 (3)
             10 STORE_NAME               2 (c)

  5          12 LOAD_CONST               3 (4)
             14 STORE_NAME               3 (d)

  7          16 LOAD_NAME                0 (a)
             18 LOAD_NAME                1 (b)
             20 LOAD_NAME                2 (c)
             22 LOAD_NAME                3 (d)
             24 BUILD_TUPLE              4
             26 UNPACK_SEQUENCE          4
             28 STORE_NAME               3 (d)
             30 STORE_NAME               2 (c)
             32 STORE_NAME               1 (b)
             34 STORE_NAME               0 (a)
             36 LOAD_CONST               4 (None)
             38 RETURN_VALUE
None

^{查看在Repl.it上运行| Ideone}

通过BUILD_TUPLE和UNPACK_SEQUENCE指令，行为是明确的，但是当我们对两个或三个变量执行相同操作时，行为似乎有所改变，而不是使用相同的指令：

  2           0 LOAD_CONST               0 (1)
              2 STORE_NAME               0 (a)

  3           4 LOAD_CONST               1 (2)
              6 STORE_NAME               1 (b)

  5           8 LOAD_NAME                0 (a)
             10 LOAD_NAME                1 (b)
             12 ROT_TWO
             14 STORE_NAME               1 (b)
             16 STORE_NAME               0 (a)
             18 LOAD_CONST               2 (None)
             20 RETURN_VALUE
None

^{查看在Repl.it上运行| Ideone}

那么，针对两个或三个变量的多项分配优化了吗？

是否针对两个或三个变量优化了多项分配？

0 个答案: