Python中的这种赋值叫什么？ a = b = 真

Question

我知道tuple unpacking，但是如果你在一行上有多个等号，这个作业叫什么？啦a = b = True

它总是让我有点不适应，尤其是当 RHS 是可变的时，但我在找到正确的关键字以在文档中搜索时遇到了真正的麻烦。

Answer 1

这是一个任务链，用来描述它的术语是......

^{- 请给我打鼓吗？}

链式赋值。

---

我只是在谷歌上运行了一下，发现关于这个主题的阅读内容并不多，可能是因为大多数人觉得它使用起来非常简单（而且只有真正的极客想了解更多关于主题）。

---

在前面的表达式中，计算顺序可以看作是从最右边的= 开始，然后向左移动，这相当于写作：

b = True
a = b

---

上面的顺序是大多数语言描述的赋值链，但是 python 做的不同。在 python 中，表达式被评估为下面的等价物，尽管它不会产生任何其他结果而不是前面描述的结果。

temporary_expr_result = True

a = temporary_expr_result
b = temporary_expr_result

---

在 stackoverflow 上可以进一步阅读：

• How do chained assignments work? python

Answer 2

使用dis（反汇编）模块，此输出进一步支持@refp 的答案：

>>> def a(x):
...   g = h = x
...
>>> import dis
>>> dis.dis(a)
  2           0 LOAD_FAST                0 (x)
              3 DUP_TOP
              4 STORE_FAST               1 (g)
              7 STORE_FAST               2 (h)
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE

RHS 被检索和复制，然后从左到右存储到目标变量中（自己尝试使用e = f = g = h = x）。

如果 RHS 是一个函数调用，其他一些发帖者会感到困惑，例如 a = b = fn() - RHS 只评估一次，然后将结果分配给每个连续的变量。如果返回的值是可变的，例如列表或字典，这可能会导致不必要的共享。

对于那些使用threading 的人，需要注意的是，在多个显式赋值语句中，链式赋值形式没有暗示“原子性”——g 和 h 的赋值与另一个线程之间可能发生线程切换查看他们两个可以看到两个变量中的不同值。

从documentation, 7.2. Assignment statements、g 和h 是两个目标列表，x 是表达式列表：

assignment_stmt ::=  (target_list "=")+ (expression_list | yield_expression)

赋值语句计算表达式列表（请记住，这可以是单个表达式或逗号分隔的列表，后者产生一个元组）并将单个结果对象分配给每个目标列表，从左到右。

Answer 3

好的，“链式分配”是我所追求的搜索词，但经过更多挖掘后，我认为它并不完全正确。但它比“赋值语句的特殊情况”更容易搜索。

The Wikipedia articlesenderle 链接到说：

在 Python 中，赋值语句不是表达式，因此不 返回一个值。相反，链式分配是一系列 具有多个目标的单个表达式的语句。这 分配从左到右执行，以便i = arr[i] = f() 计算表达式f()，然后将结果分配给最左边 目标，i，然后将相同的结果分配给下一个目标， arr[i]，使用 i 的新值。

另一个blog post 说：

在 Python 中，赋值语句不返回值。链式 赋值（或者更准确地说，看起来像链式赋值的代码 声明）被承认和支持作为一个特例 赋值语句。

这对我来说似乎是最正确的，仔细阅读 the docs - 特别是 (target_list "=")+ - 这也说

赋值语句计算表达式列表 ... 并赋值 每个目标列表的单个结果对象，从左到 对。

因此，它并不是真正“从最右到左评估”——RHS 被评估，然后从最左边的目标分配到右——不是我能想到的任何真实世界（甚至是人为的）例子会有所作为。

Answer 4

由于我的无知，今天被python的Chained Assignment咬了。在代码中

if l1.val <= l2.val:
    tail = tail.next = l1 # this line 
    l1 = l1.next

我的预期是

tail.next = l1
tail = tail.next
# or equivalently 
# tail = l1

而我在下面，这会在列表中产生一个自我循环，让我陷入无限循环，哎呀......

tail = l1
tail.next = l1 # now l1.next is changed to l1 itself

因为对于 a = b = c， 一种方式（例如python）相当于

tmp = evaluate(c)
evaluate(a) = tmp
evaluate(b) = tmp

两个赋值的右操作数相等。

另一个（例如C++）等价于

evaluate(b) = evaluate(c)
evaluate(a) = evaluate(b)

因为在这种情况下a = b = c基本上是

b = c
a = b

两个右手操作数可能不同。

这就是为什么类似的代码在 C++ 中运行良好的原因。