4

我有一些这样的代码：

def foo():
    bar = initial_bar = Bar()
    while True:
        next_bar = Bar()
        bar.next_bar = next_bar
        bar = next_bar
    return initial_bar

意图Bar是形成一个可以遵循的链表，链表样式。

这一切都很好；但是由于一些误导性的想法，我想将其减少一行，将循环末尾的分配复合成一行。

def foo():
    bar = initial_bar = Bar()
    while True:
        next_bar = Bar()
        bar = bar.next_bar = next_bar
    return initial_bar

因为bar = bar.next_bar = next_bar会有效地扩大到bar.next_bar = next_bar跟随着bar = bar.next_bar。（除非它没有。）

问题是，这不起作用；返回的“初始栏”没有next_bar定义。通过回到更明确的两行解决方案，我可以轻松地解决它，但是发生了什么？

4

1 回答 1

5

是时候拔出来了dis。

>>> import dis
>>> dis.dis(foo)
  2           0 LOAD_GLOBAL              0 (Bar)
              3 CALL_FUNCTION            0
              6 DUP_TOP             
              7 STORE_FAST               0 (bar)
             10 STORE_FAST               1 (initial_bar)

  3          13 SETUP_LOOP              32 (to 48)
        >>   16 LOAD_GLOBAL              1 (True)
             19 POP_JUMP_IF_FALSE       47

  4          22 LOAD_GLOBAL              0 (Bar)
             25 CALL_FUNCTION            0
             28 STORE_FAST               2 (next_bar)

  5          31 LOAD_FAST                2 (next_bar)
             34 DUP_TOP             
             35 STORE_FAST               0 (bar)
             38 LOAD_FAST                0 (bar)
             41 STORE_ATTR               2 (next_bar)
             44 JUMP_ABSOLUTE           16
        >>   47 POP_BLOCK           

  6     >>   48 LOAD_FAST                1 (initial_bar)
             51 RETURN_VALUE

如果你仔细观察，你会看到在关键行（第 5 行，见左边的数字，位置 31-47），它是这样的：

  • 加载next_bar(31) 两次 (34)；
  • 将它（堆栈上的第一个副本）写入bar（35）；
  • 将它（堆栈上的第二个副本）写入bar.next_bar(38, 41)。

这在最小测试用例中更为明显。

>>> def a():
...     b = c = d
... 
>>> dis.dis(a)
  2           0 LOAD_GLOBAL              0 (d)
              3 DUP_TOP             
              4 STORE_FAST               0 (b)
              7 STORE_FAST               1 (c)
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE

看看它在做什么。这意味着b = c = d实际上等同于b = d; c = d。通常这无关紧要，但在最初提到的情况下，它确实很重要。这意味着在临界线上，

bar = bar.next_bar = next_bar

不等于

bar.next_bar = next_bar
bar = next_bar

而是为了

bar = next_bar
bar.next_bar = next_bar

事实上，这已记录在 Python 文档的第 6.2 节Simple statements，Assignment statements 中：

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

该部分还有一个适用于这种情况的相关警告：

警告：虽然赋值的定义暗示左侧和右侧之间的重叠是“安全的”（例如a, b = b, a交换两个变量），但赋值变量集合中的重叠并不安全！例如，以下程序打印[0, 2]：

x = [0, 1]
i = 0
i, x[i] = 1, 2
print x

这是可能的bar.next_bar = bar = next_bar，这确实产生了最初想要的结果，但请怜悯任何人（包括一段时间后的原作者！），他们将不得不稍后阅读代码并为这样一个事实而高兴，用我的话来说如果蒂姆想到它们，肯定会使用，

显式比可能令人困惑的极端情况要好。

于 2012-12-19T03:23:39.553 回答