我的建议是这样的，因为它允许你在添加项和将来可能需要添加项时对字典排序或保持字典排序:

从头开始构建词典。有第二个数据结构，一个包含键列表的列表。bisect包有一个insort函数，允许插入到一个排序的列表中，或者在完全填充字典后对列表进行排序。现在，当您迭代字典时，您将迭代列表以按顺序访问每个键，而不用担心字典结构的表示(它不是为排序而设计的)。

以下是建议解决方案的性能:

from collections import OrderedDict
from sortedcontainers import SortedDict
import json

keys = np.random.rand(100000)
vals = np.random.rand(100000)

d = dict(zip(keys, vals))

timeit SortedDict(d)
#45.8 ms ± 780 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit sorted(d.items())
#91.9 ms ± 707 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit OrderedDict(sorted(d.items(), key=lambda x: x[0]))
#93.7 ms ± 1.52 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit dict(sorted(dic.items()))
#113 ms ± 824 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit OrderedDict(sorted(dic.items()))
#122 ms ± 2.65 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit json.dumps(d, sort_keys=True)
#259 ms ± 9.42 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

如我们所见，格兰特·詹克斯的解决方案是目前为止最快的。

我的建议是这样的，因为它允许你在添加项和将来可能需要添加项时对字典排序或保持字典排序:

从头开始构建词典。有第二个数据结构，一个包含键列表的列表。bisect包有一个insort函数，允许插入到一个排序的列表中，或者在完全填充字典后对列表进行排序。现在，当您迭代字典时，您将迭代列表以按顺序访问每个键，而不用担心字典结构的表示(它不是为排序而设计的)。

l = dict.keys()
l2 = l
l2.append(0)
l3 = []
for repeater in range(0, len(l)):
    smallnum = float("inf")
    for listitem in l2:
        if listitem < smallnum:
            smallnum = listitem
    l2.remove(smallnum)
    l3.append(smallnum)
l3.remove(0)
l = l3

for listitem in l:
    print(listitem)

就问题的表述方式而言，这里的大多数答案都是正确的。

然而，考虑到事情应该如何真正完成，考虑到几十年的计算机科学，让我完全惊讶的是，这里实际上只有一个答案(来自GrantJ用户)建议使用排序关联容器(sortedcontainers)，它基于插入点的键对元素进行排序。

这将避免每次调用sort(…)时对性能的巨大影响(至少O(N*log(N))，其中N是元素的数量(逻辑上，这适用于这里建议使用sort(…)的所有此类解决方案)。考虑到对于所有这样的解决方案，sort(…)将需要在每次通过添加/删除元素修改后，当需要以排序方式访问集合时调用…

或者用熊猫，

演示:

>>> d={'B':1,'A':2,'C':3}
>>> df=pd.DataFrame(d,index=[0]).sort_index(axis=1)
   A  B  C
0  2  1  3
>>> df.to_dict('int')[0]
{'A': 2, 'B': 1, 'C': 3}
>>> 

See:

这方面的文档 整只熊猫的记录