Python 如果我在设置变量的过程中按公共值切换顺序，结果为什么会不同？

为了更好地解释，我编写了一个小类

节点

，并设置

a

和

b

：

class node(object):
    def __init__(self,x,y):
        self.val = x 
        self.next = y

a = node(5,6)
b = None

然后我发现结果不同于：

a, a.next, b = a.next, b, a
print(a,b)  #it returns AttributeError: 'int' object has no attribute 'next'

以及：

a.next，a，b=b，a.next，a
打印（a，b）#返回6

我们都知道，当

a，b=b，a+b

时，它同时给出a，b值，当代码变成

b，a=a+b，b

时，结果不会改变

---

有人能帮我吗？为什么会发生这种情况？

当LHS元素是独立的时，元组解包只会“同时”发生。因为您已经创建了一个它们不独立的情况，所以实现中的小细节现在很重要

在这种情况下，重要的细节是LHS元素是从左到右分配的。由于

a

在查看

a.next

时包含

int

，因此会引发异常

import dis

def f1():
    a, a.next, b = a.next, b, a

def f2():
    a.next, a, b = b, a.next, a

print('f1:')
dis.dis(f1)
print()
print('f2:')
dis.dis(f2)

---

拆包不是同时进行的。只是右手边在“拆包”到左手边之前是“构造”好的。但每边都是从左到右计算的

因此，所发生的事情大致如下（它实际上并不构建元组，但这只是一个实现细节）：

在第二种情况下，它起作用是因为在“重新分配”之后是“重新分配”的

tmp = (b, a.next, a)
a.next = tmp[0]  # a still has the next attribute
a = tmp[1]
b = tmp[2]

---

我们可以看看您的列表的实施情况吗（特别是

next

）？理论上，

next

应该是内部的，不应该在课外玩。它来自这个网站。下一个函数列在代码区中，但我不确定您是否能看到它。我会更新它的图片。因为如果

a=tmp[0]

和

b=tmp[1]

（当你使用

a，b=b，a+b

）或

b=tmp[0]

和

a=tmp[1]

（在

b的情况下，a=a+b，b

）。重要的是，在将右手侧解包到左手侧之前，要对右手侧进行完全评估（但每侧都是从左到右进行评估）。我的意思是，你甚至可以使用

a，a=a+b，a

->然后得到的

a

将只是原始

a

，因为这是

a

的“最后一次”解包赋值（与

a相反，a=a，a+b

，得到的

a

等于

a+b

，因为这是“最后一次解包”）1.我明白你的意思。首先计算右侧元素，然后从左到右逐个拆包到左侧元素。

f1:
  4           0 LOAD_FAST                0 (a)
              3 LOAD_ATTR                0 (next)
              6 LOAD_FAST                1 (b)
              9 LOAD_FAST                0 (a)
             12 ROT_THREE
             13 ROT_TWO
             14 STORE_FAST               0 (a)
             17 LOAD_FAST                0 (a)
             20 STORE_ATTR               0 (next)
             23 STORE_FAST               1 (b)
             26 LOAD_CONST               0 (None)
             29 RETURN_VALUE

f2:
  7           0 LOAD_FAST                0 (b)
              3 LOAD_FAST                1 (a)
              6 LOAD_ATTR                0 (next)
              9 LOAD_FAST                1 (a)
             12 ROT_THREE
             13 ROT_TWO
             14 LOAD_FAST                1 (a)
             17 STORE_ATTR               0 (next)
             20 STORE_FAST               1 (a)
             23 STORE_FAST               0 (b)
             26 LOAD_CONST               0 (None)
             29 RETURN_VALUE

tmp = (a.next, b, a)
a = tmp[0]
a.next = tmp[1]  # fails because "a" is now an integer
b = tmp[2]

tmp = (b, a.next, a)
a.next = tmp[0]  # a still has the next attribute
a = tmp[1]
b = tmp[2]