采用可散列对象的容器(例如 dict 键或 set 项)。因此，字典只能有一个值为 1、1.0 或 True 等的键。(注意:有些简化 - 哈希冲突是允许，但这些值被认为是相等的)

我的问题是:解析顺序是否明确定义，生成的对象是否可跨实现预测？例如，OSX Python 2.7.11 和 3.5.1 对 dict 的解释如下:

>>> { True: 'a', 1: 'b', 1.0: 'c', (1+0j): 'd' }
{True: 'd'}

在这种情况下，似乎保留了第一个键和最后一个值。

类似，在set的情况下:

>>> { True, 1, 1.0, (1+0j) }
set([(1+0j)])

这里似乎保留了最后一个项。

但是(如评论中所述):

>>> set([True, 1, 1.0])
set([True])

现在迭代中的第一个被保留。

文档指出项目的顺序(例如在 dict.items 中)是未定义的，但是我的问题是指 constructing dict 或 set 对象。

最佳答案

• 如 @jsf's answer 中所述，错误 现在已在最新版本的 python 中得到修复。

dictionary-displays

If a comma-separated sequence of key/datum pairs is given, they are evaluated from left to right to define the entries of the dictionary: each key object is used as a key into the dictionary to store the corresponding datum. This means that you can specify the same key multiple times in the key/datum list, and the final dictionary’s value for that key will be the last one given.

A dict comprehension, in contrast to list and set comprehensions, needs two expressions separated with a colon followed by the usual “for” and “if” clauses. When the comprehension is run, the resulting key and value elements are inserted in the new dictionary in the order they are produced.

set displays

A set display yields a new mutable set object, the contents being specified by either a sequence of expressions or a comprehension. When a comma-separated list of expressions is supplied, its elements are evaluated from left to right and added to the set object. When a comprehension is supplied, the set is constructed from the elements resulting from the comprehension.

调用集合构造函数或使用推导式和普通文字是有区别的。

def f1():
    return {x for x in [True, 1]}

def f2():
    return set([True, 1])
def f3():
    return {True, 1}
print(f1())
print(f2())
print(f3())
import dis

print("f1")
dis.dis(f1)

print("f2")

dis.dis(f2)

print("f3")
dis.dis(f3)

输出:

{True}
{True}
{1}

它们的创建方式会影响结果:

    605           0 LOAD_CONST               1 (<code object <setcomp> at 0x7fd17dc9a270, file "/home/padraic/Dropbox/python/test.py", line 605>)
              3 LOAD_CONST               2 ('f1.<locals>.<setcomp>')
              6 MAKE_FUNCTION            0
              9 LOAD_CONST               3 (True)
             12 LOAD_CONST               4 (1)
             15 BUILD_LIST               2
             18 GET_ITER
             19 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             22 RETURN_VALUE
f2
608           0 LOAD_GLOBAL              0 (set)
              3 LOAD_CONST               1 (True)
              6 LOAD_CONST               2 (1)
              9 BUILD_LIST               2
             12 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             15 RETURN_VALUE
f3
611           0 LOAD_CONST               1 (True)
              3 LOAD_CONST               2 (1)
              6 BUILD_SET                2
              9 RETURN_VALUE

当你传递一个用逗号分隔的纯文字时，Python 只运行 BUILD_SET 字节码:

当提供一个逗号分隔的表达式列表时，它的元素从左到右被计算并添加到集合对象中。

理解的行:

当提供推导时，集合由推导产生的元素构成。

感谢 Hamish 提交了 bug report根据 Raymond Hettinger 在链接中的评论，它确实归结为 BUILD_SET 操作码罪魁祸首是 Python/ceval.c 中的 BUILD_SET 操作码它不必要地向后循环，其实现如下:

 TARGET(BUILD_SET) {
            PyObject *set = PySet_New(NULL);
            int err = 0;
            if (set == NULL)
                goto error;
            while (--oparg >= 0) {
                PyObject *item = POP();
                if (err == 0)
                    err = PySet_Add(set, item);
                Py_DECREF(item);
            }
            if (err != 0) {
                Py_DECREF(set);
                goto error;
            }
            PUSH(set);
            DISPATCH();
        }

关于python - Dict/Set 解析顺序一致性，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34623846/