python有多可靠；什么是字典订购？

我需要快速地散列一个字典（计数器），我注意到python似乎以相同的顺序排列具有相同键的字典，即使它们的构造不同。事实上，这些词典似乎能够经受住相当多的滥用：

>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> list(D)
['b', 'c', 'a']
>>> list(D)
['b', 'c', 'a']
>>> list(D)
['b', 'c', 'a']
>>> list(D)
['b', 'c', 'a']
>>> E = {'a': 1, 'b': 2, 'c': 3}
>>> list(E)
['b', 'c', 'a']
>>> list(E)
['b', 'c', 'a']
>>> list(E)
['b', 'c', 'a']
>>> F = {'a': 1, 'b': 2, 'c': 3}
>>> list(F)
['b', 'c', 'a']
>>> list(F)
['b', 'c', 'a']
>>> list(F)
['b', 'c', 'a']
>>> list(F)
['b', 'c', 'a']
>>> G = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> list(G)
['b', 'c', 'a', 'd']
>>> list(G)
['b', 'c', 'a', 'd']
>>> list(G)
['b', 'c', 'a', 'd']
>>> list(F)
['b', 'c', 'a']
>>> F.pop('a')
1
>>> list(F)
['b', 'c']
>>> F['a'] = 2
>>> list(F)
['b', 'c', 'a']
>>> list(F)
['b', 'c', 'a']
>>> H = {'b': 2, 'a': 1, 'c': 3}
>>> list(H)
['b', 'c', 'a']
>>> H = {'b': 2, 'c': 1, 'a': 3}
>>> list(H)
['b', 'c', 'a']
>>> K = {'b': 2, 'c': 1, 'a': 3, 'd': 4}
>>> list(K)
['b', 'c', 'a', 'd']
>>> K = {'b': 2, 'c': 1, 'd': 3, 'a': 4}
>>> list(K)
['b', 'c', 'a', 'd']

那么，我的问题是，如果我的字典具有相同的键和值，那么至少在python运行实例的生命周期内，我能指望键的顺序相同吗？ 注意，我知道python决定对字典排序的方式有点不可理解，但我想知道，如果给定相同的输入，同一个python实例每次都会返回相同的键排序

如果我的字典有相同的键和值，我能指望键的顺序相同吗

没有

如果我的字典有相同的键和值，我能指望键的顺序相同吗

没有

---

Python>3.7

字典顺序保证为插入顺序

---

PythonPython>3.7

字典顺序保证为插入顺序

---

Python常规Python命令没有排序。当您得到密钥列表时，它们将是您期望的顺序，这是无法保证的

如果你想保持秩序，使用一个有序的命令

---

常规python命令未排序。当您得到密钥列表时，它们将是您期望的顺序，这是无法保证的

如果你想保持秩序，使用一个有序的命令

---

鉴于目前还没有人提到这一点，我会告诉你散列随机化是一种新方法

使用散列随机化，在每次Python运行中，

hash（'abc'）

的结果是不同的。由于哈希是字典的基础（它们用于确定项目在

dict

使用的内部数组中的位置），因此关于排序的保证就更少了

$ python3.5
>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> list(d)
['a', 'c', 'b']
>>> list(d)
['a', 'c', 'b']

$ python3.5
# new process, new random seed, new ordering
>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> list(d)
['c', 'a', 'b']
>>> list(d)
['c', 'a', 'b']

---

考虑到还没有人提到这一点，我会告诉你散列随机化是一种新方法

使用散列随机化，在每次Python运行中，

hash（'abc'）

的结果是不同的。由于哈希是字典的基础（它们用于确定项目在

dict

使用的内部数组中的位置），因此关于排序的保证就更少了

$ python3.5
>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> list(d)
['a', 'c', 'b']
>>> list(d)
['a', 'c', 'b']

$ python3.5
# new process, new random seed, new ordering
>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> list(d)
['c', 'a', 'b']
>>> list(d)
['c', 'a', 'b']

---

非python特定注意事项：当哈希表增长或收缩时，它可能会重新平衡存储桶，从而改变项目的顺序——您可能需要尝试添加/删除项目，以查看顺序是否突然改变……不可靠。对于新来者，请不要依赖Python 3.7中可能出现的重复。非Python特定注意：当哈希表增长或收缩时，它可能会重新平衡存储桶，从而改变项目的顺序-您可能需要尝试添加/删除项目，以查看顺序是否突然改变…不可靠。对于新来者，请不要依赖于可能的副本，从Python 3.7开始，它崩溃是什么意思？

list（{'a'：0，'e'：0}）

→ <代码>['a'，'e']<代码>列表（{'e'：0，'a'：0}）→ <代码>['a'，'e']对我来说。“Python2.7.11（默认值，2016年1月11日，21:04:40）”我想我们甚至不能依赖不可靠性：-P.新字母呢？这次我检查了Python2和Python3。有趣的是，对于我来说，这是唯一一对在两个版本中都“有效”的组合。[d，l][l，d]是的，这个例子对我来说很有效，证明了当你以不同的方式构造时，顺序会受到影响；原创海报的希望破灭了。你说它破裂是什么意思？

list（{'a'：0，'e'：0}）

→ <代码>['a'，'e']<代码>列表（{'e'：0，'a'：0}）→ <代码>['a'，'e']对我来说。“Python2.7.11（默认值，2016年1月11日，21:04:40）”我想我们甚至不能依赖不可靠性：-P.新字母呢？这次我检查了Python2和Python3。有趣的是，对于我来说，这是唯一一对在两个版本中都“有效”的组合。[d，l][l，d]是的，这个例子对我来说很有效，证明了当你以不同的方式构造时，顺序会受到影响；原创海报的希望破灭了。“随时改变那个选择”，没错。这里需要注意的重要一点是，语言之所以这样做，并不是因为它讨厌你，而是因为不稳定的顺序更快，更难攻击。我之所以考虑这样做，是因为如果关键顺序发生变化，这并不是世界末日，该程序只是受到性能的影响，因为一个昂贵的计算必须进行两次（因为它不会意识到已经完成了）。但是跳过

''中的sorted（）步骤。join（k+str（v）表示k，v表示sorted（D.items（），key=lambda k:k[0]）

在获取缓存值的代码部分可以大大节省性能，这听起来很合理，甚至很有趣，但是有什么理由不考虑使用OrderedICT来确保一致性吗？“随时改变这种选择“，对。这里需要注意的重要一点是，语言之所以这样做，并不是因为它讨厌你，而是因为不稳定的顺序更快，更难攻击。我之所以考虑这样做，是因为如果关键顺序发生变化，这并不是世界末日，该程序只是受到性能的影响，因为一个昂贵的计算必须进行两次（因为它不会意识到已经完成了）。但是跳过

''中的sorted（）步骤。join（k+str（v）表示k，v表示sorted（D.items（），key=lambda k:k[0]）

在获取缓存值的代码部分可以大大节省性能，这听起来很合理，甚至很有趣，但是有什么理由不考虑使用OrderedICT来确保一致性吗？