python - 元组赋值什么时候表现得像所涉及的变量的 "swap"，什么时候表现得像 "individual sequential assignments"？

Question

下面，我用三个例子来说明“交换”和“赋值语句的顺序执行”的含义。

示例 1(交换)

元组赋值可以非常方便地交换变量的内容。

下面的例子展示了我们如何在不需要临时变量的情况下以清晰简洁的方式交换数组中两个元素的内容:

a = [1,2]

# prints [1, 2]
print(a)

a[0], a[1] = a[1], a[0]

# prints: [2,1] and not: [2, 2] as with a sequential assignment!
print(a)

该示例向我们展示了元组分配的行为如何像交换一样，而不是按顺序执行第一次分配，然后进行第三次分配。

示例 2(交换)

这是交换三个整数的另一个示例:

x, y, z = 1, 2, 3

# prints: 1 2 3
print(x, y, z)

# swap contents in variables:
x, y, z = z, y, x

# prints: 3 2 1 and not: 3 2 3 as with a sequential assignment!
print(x, y, z)

示例 3(顺序赋值语句)

然而，一旦事情变得比简单的数据类型更复杂，元组赋值也可能表现得像一个顺序赋值。

让我们考虑以下链表实现:

class ListNode:

    def __init__(self, data=None, next=None):
        self.data = data
        self.next = next

    def __repr__(self):
        is_first = True
        current = self
        l = []
        safety_count = 0
        while current and safety_count < 10:
            if not is_first:
                l.append(' -> ')
            is_first = False
            l.append(str(current.data))
            current = current.next
            safety_count += 1
        return ''.join(l)

    def __str__(self):
        return self.__repr__()

这个函数颠倒了链表的顺序(并且工作得很好):

def reverse_list_working(L):
    if not L:
        return L
    pre_current = None
    current = L
    while True:
        tmp_next = current.next
        current.next = pre_current
        pre_current = current
        current = tmp_next
        if not current:
            break
    return pre_current

现在，我们可能会想通过元组赋值去掉 tmp_ 变量，以交换变量的内容:

def reverse_list_not_working(L):
    pre_current = None
    current = L
    while True:
        pre_current, current, current.next = current, current.next, pre_current
        if not current:
            break
    return pre_current

然而，一旦我们到达最后一个元素，这个实现就会出错。这里的问题是元组分配的行为类似于顺序分配。

分配:pre_current -> current

分配:current -> current.next(列表末尾为 None)

分配:current.next -> pre_current :产生错误，因为当前是无!

Answer 1

如果你拿简单的例子(三个整数)看字节码，你会看到:

...
LOAD_NAME                2 (z)
LOAD_NAME                1 (y)
LOAD_NAME                0 (x)
ROT_THREE
ROT_TWO
STORE_NAME               0 (x)
STORE_NAME               1 (y)
STORE_NAME               2 (z)
...

IE。答案是您首先获取右侧的值 onto stack (简单的情况只是获取变量引用的值，但在复杂的情况下，这可能会产生更广泛的影响)，那么您 reorder ，然后你 assign从堆栈到左侧相应变量的值。