python - 从 Python2 到 Python3 的这种解包行为的变化是什么？

Question

昨天我发现了 Python 2 和 Python 3 之间的这种奇怪的拆包差异，在快速谷歌搜索后似乎没有找到任何解释。

Python 2.7.8

a = 257
b = 257
a is b # False

a, b = 257, 257
a is b # False

Python 3.4.2

a = 257
b = 257
a is b # False

a, b = 257, 257
a is b # True

我知道它可能不会影响程序的正确性，但它确实让我有些烦恼。谁能提供一些关于拆包差异的见解？

Answer 1

这种行为至少部分与解释器如何进行常量折叠有关 以及 REPL 如何执行代码。

首先，请记住 CPython 先编译代码(编译为 AST，然后编译为字节码)。然后它评估 字节码。在编译期间，脚本会查找不可变的对象并缓存它们。它 还会对它们进行重复数据删除。所以如果它看到了

a = 257
b = 257

它将针对同一个对象存储 a 和 b:

import dis

def f():
    a = 257
    b = 257

dis.dis(f)
#>>>   4           0 LOAD_CONST               1 (257)
#>>>               3 STORE_FAST               0 (a)
#>>>
#>>>   5           6 LOAD_CONST               1 (257)
#>>>               9 STORE_FAST               1 (b)
#>>>              12 LOAD_CONST               0 (None)
#>>>              15 RETURN_VALUE

注意 LOAD_CONST 1。 1 是 co_consts 的索引:

f.__code__.co_consts
#>>> (None, 257)

所以它们都加载相同的 257。为什么不会发生这种情况:

$ python2
Python 2.7.8 (default, Sep 24 2014, 18:26:21) 
>>> a = 257
>>> b = 257
>>> a is b
False

$ python3
Python 3.4.2 (default, Oct  8 2014, 13:44:52) 
>>> a = 257
>>> b = 257
>>> a is b
False

?

在这种情况下，每一行都是一个单独的编译单元，并且 重复数据删除不会发生在它们之间。它的工作原理类似于

compile a = 257
run     a = 257
compile b = 257
run     b = 257
compile a is b
run     a is b

因此，这些代码对象都将具有唯一的常量缓存。 这意味着如果我们删除换行符，is 将返回 True:

>>> a = 257; b = 257
>>> a is b
True

事实上，这两个 Python 版本都是如此。事实上，这正是原因

>>> a, b = 257, 257
>>> a is b
True

也返回 True；这不是因为解包的任何属性；他们 只需放在同一个编译单元中即可。

对于不能正确折叠的版本，这将返回 False； filmor links to Ideone这表明这在 2.7.3 和 3.2.3 上失败了。在这些版本中，创建的元组不与其他常量共享它们的项:

import dis

def f():
    a, b = 257, 257
    print(a is b)

print(f.__code__.co_consts)
#>>> (None, 257, (257, 257))

n = f.__code__.co_consts[1]
n1 = f.__code__.co_consts[2][0]
n2 = f.__code__.co_consts[2][1]

print(id(n), id(n1), id(n2))
#>>> (148384292, 148384304, 148384496)

不过，这与对象解包方式的变化无关；这只是对象在 co_consts 中存储方式的变化。