python中给多个变量一起赋值和分开赋值的区别

最近在刷LeetCode的编程题时，发现了一个很有意思的小细节，关于“python中给多个变量一起赋值和分开赋值”产生的不同效果。
刚好刷到“反转链表这道题目”，题意很简单，即输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL，在讨论区看到了最简单的python代码的解答：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        cur, pre = head, None
                while cur:
            cur.next, pre, cur = pre, cur, cur.next
        return pre

然后，我尝试把代码改成java来实现，分开赋值

  public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while (cur!=null){
            cur.next = pre;
            pre = cur;
            cur = cur.next;
        }
        return pre;
    }

然后接这样了，呜~~~

从测试结果可以看出来是出现了链表的节点的游离，然后我就开始思考问题出现的原因，python的代码实现相同的功能，理论上是java代码的1/5，代码很简便，其实也蕴含了很多变量的赋值差异，掌握不好，bug就一堆了。
重新思考这个问题，在双指针节点更新的过程中，出现了节点游离，导致的出错，参看了一下其他代码，大多数都用一个临时变量tmp来先保存当前结点的下一个节点，再开始移动指针，先看代码再解释：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        pre = None
        cur = head
        while cur:
            temp = cur.next   # 先用临时变量把原来cur.next位置存起来
            cur.next = pre
            pre = cur
            cur = temp
        return pre

测试就没问题了，问题出在哪呢？
回看原来的代码：
cur.next, pre, cur = pre, cur, cur.next
这一行代码实现了，三个变量的赋值，而且有个特点，变量之间是有重叠的，问题也就出现在这里了，再进一步解释，当执行赋值中的第二个赋值（pre = cur）时，其实第一个赋值并没有生效，还是保持这行语句之前的状态，同样的执行赋值语句（cur = cur.next）时，同一行的两个赋值也并未生效，在这个代码背景中，就出现了节点游离的状态。
（结合题目背景解释：因为本题中是一个单向链表，只能从一个节点找它后面的节点，不能从一个节点找它前面的节点。比如： 1 -> 2 -> 3 -> 4 -> 5 ，假设现在 cur 指向2，cur.next 就代表了后面的一串： 3 -> 4 -> 5 ，如果不先把 cur.next 存起来，就将 cur 指向前面的 1 这个节点的话，就找不到 3 -> 4 -> 5 这一串了，就出现了游离的状态。）
再举一个简单的例子说明这个问题吧：

def test01():
    a = 1
    b = 2
    a, b = a + 2, a + b
    print('a={0} b ={1}'.format(a, b))


def test02():
    a = 1
    b = 2
    a = a + 2
    b = a + b
    print('a={0} b ={1}'.format(a, b))


if __name__ == '__main__':
    test01()
    test02()

看输出结果：
解释一个为啥Test01（）的输出结果是a = 3, b = 3
赋值代码：a, b = a + 2, a + b
在执行第二赋值b = a + b，时，a在内存中，还是处于初始赋值a= 1的状态，而前面的赋值语句a = a+ 2 = 1+2 =3,在内存中还没生效。这样就很容易理解了，再回头看反转链表背景的赋值差异就清晰多了。