这里已经有很多答案展示了对Python字典进行排序的流行方法。我想我应该为那些从谷歌来到这里寻找非标准想法的人添加一些不太明显的方法。

样本字典:d = {2: ' c ', 1: ' b ', 0: ' a ', 3: ' d '}

字典理解

# Converts to list, sorts, re-converts to dict
{k: v for k, v in sorted(list(d.items()))}

使用λ

排序并不总是按照严格的升序或降序进行。对于更多的条件排序，使用上述方法结合lamdas:

{k: v for k, v in sorted(d.items(), key=lambda v: ord(v[1]))}

更多的例子

这个帖子已经有足够多的好例子了。有关更多示例，以及边缘情况和奇怪情况，请参阅这篇关于Python中字典排序的文章。

伙计们，你们把事情搞复杂了……非常简单

from pprint import pprint
Dict={'B':1,'A':2,'C':3}
pprint(Dict)

输出结果为:

{'A':2,'B':1,'C':3}

正如其他人所提到的，字典本质上是无序的。然而，如果问题只是以有序的方式显示字典，你可以在字典子类中重写__str__方法，并使用这个字典类而不是内置的字典。如。

class SortedDisplayDict(dict):
   def __str__(self):
       return "{" + ", ".join("%r: %r" % (key, self[key]) for key in sorted(self)) + "}"


>>> d = SortedDisplayDict({2:3, 1:89, 4:5, 3:0})
>>> d
{1: 89, 2: 3, 3: 0, 4: 5}

注意，这不会改变键的存储方式，当你遍历它们时它们返回的顺序等，只是它们在打印时或在python控制台中显示的方式。

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

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)

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

dictionary = {1:[2],2:[],5:[4,5],4:[5],3:[1]}

temp=sorted(dictionary)
sorted_dict = dict([(k,dictionary[k]) for i,k in enumerate(temp)])

sorted_dict:
         {1: [2], 2: [], 3: [1], 4: [5], 5: [4, 5]}

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

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

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