Question

为了更好地解释，我写了一个小班node，并设置了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
print(a,b)  #it returns 6 <__main__.node object at 0x1021a0400>

我们都知道，当a, b = b, a+b时，它同时给出a，b值，并且当代码变为b, a = a+b, b时结果不会改变。

那么，有人可以帮我吗？为什么会这样？

Answer 1

元组拆包只发生＆＃34;同时＆＃34; 当LHS元素独立时。由于您已经创建了不独立的情况，因此实现中的次要细节现在很重要。

在这种情况下，重要的细节是LHS元素从左到右分配。由于a在查看int时包含a.next，因此会抛出异常。

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)

...

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

Answer 2

拆包不是同时进行的。只是右手边在“解包”到左手边之前被“构造”了。但每一方都是从左到右评估的！

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

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

在第二种情况下，它有效，因为在“重新分配”a.next之后“重新分配”：

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

如果我按常规设置变量来切换顺序，为什么结果会有所不同？

2 个答案: