在Python 2.7中，只需执行以下操作：

from collections import OrderedDict
# regular unsorted dictionary
d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}

# dictionary sorted by key
OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

# dictionary sorted by value
OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

复制粘贴自：http://docs.python.org/dev/library/collections.html#ordereddict-示例和食谱

享受；-）

简单如：sorted（dict1，key=dict1.get）

嗯，实际上可以进行“按字典值排序”。最近，我不得不在代码高尔夫（堆栈溢出问题代码高尔夫：单词频率表）中这样做。简言之，问题是这样的：给定一个文本，计算每个单词遇到的频率，并显示一个按频率递减排序的顶级单词列表。

如果您构建一个字典，将单词作为关键字，将每个单词的出现次数作为值，则此处简化为：

from collections import defaultdict
d = defaultdict(int)
for w in text.split():
    d[w] += 1

然后，您可以得到一个单词列表，按使用频率排序，排序（d，key=d.get）-排序将使用单词出现的次数作为排序关键字，在字典关键字上迭代。

for w in sorted(d, key=d.get, reverse=True):
    print(w, d[w])

我写这篇详细的解释是为了说明人们通常所说的“我可以很容易地按关键字对字典进行排序，但我如何按值排序”——我认为最初的文章正试图解决这一问题。解决方案是根据这些值列出一些键，如上所示。

Python 3.7+或CPython 3.6

Python 3.7+中的字典保持插入顺序。CPython 3.6中也一样，但这是一个实现细节。

>>> x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
>>> {k: v for k, v in sorted(x.items(), key=lambda item: item[1])}
{0: 0, 2: 1, 1: 2, 4: 3, 3: 4}

or

>>> dict(sorted(x.items(), key=lambda item: item[1]))
{0: 0, 2: 1, 1: 2, 4: 3, 3: 4}

较旧的Python

不可能对字典进行排序，只能获得已排序字典的表示。字典本质上是无序的，但其他类型，如列表和元组，则不是。因此，您需要一个有序的数据类型来表示排序的值，这将是一个列表，可能是一个元组列表。

例如，

import operator
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=operator.itemgetter(1))

sorted_x将是由每个元组中的第二个元素排序的元组列表。dict（sorted_x）==x。

对于那些希望按关键字而不是值排序的用户：

import operator
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=operator.itemgetter(0))

在Python3中，由于不允许开箱，我们可以使用

x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=lambda kv: kv[1])

如果要将输出作为字典，可以使用collections.OrderedDict:

import collections

sorted_dict = collections.OrderedDict(sorted_x)

除了使用内置模块等，我尝试手动解决它。。。

首先，我制作了一个函数，其任务是返回dict的每个项的最小值：

def returnminDict(_dct):
    dict_items = _dct.items()
    list_items = list(dict_items)
    init_items = list_items[0]
    for i in range(len(list_items)):
        if list_items[i][1] > init_items[1]:
           continue
        else:
           init_items = list_items[i]
    return init_items

第二，现在我们有一个函数，它返回一个具有最小值的项。然后我做了一个新的格言，并在格言上循环：

def SelectDictSort(_dct):
    new_dict = {}
    while _dct:
        mindict = returnminDict(_dct)
        new_dict.update(dict((mindict,)))
        _dct.pop(mindict[0])
    return new_dict

我尝试使用SelectDictSort（｛2:5，5:1，4:3，1:1，0:1，9:2，8:2｝）。它将返回：

{0: 1, 1: 1, 5: 1, 8: 2, 9: 2, 4: 3, 2: 5}

嗯……我不知道哪一个是正确的，但这是我尝试过的。。。

当然，请记住，您需要使用OrderedDict，因为常规Python字典不能保持原始顺序。

from collections import OrderedDict
a = OrderedDict(sorted(originalDict.items(), key=lambda x: x[1]))

如果您没有Python 2.7或更高版本，最好的方法就是迭代生成器函数中的值。（这里有2.4和2.6的OrderedDict，但是

a） 我不知道它有多好

and

b） 当然，你必须下载并安装它。如果您没有管理权限，那么恐怕该选项无效。）

def gen(originalDict):
    for x, y in sorted(zip(originalDict.keys(), originalDict.values()), key=lambda z: z[1]):
        yield (x, y)
    #Yields as a tuple with (key, value). You can iterate with conditional clauses to get what you want. 

for bleh, meh in gen(myDict):
    if bleh == "foo":
        print(myDict[bleh])

您还可以打印出每个值

for bleh, meh in gen(myDict):
    print(bleh, meh)

如果不使用Python 3.0或更高版本，请记住在打印后删除括号

在Python 2.7中，只需执行以下操作：

from collections import OrderedDict
# regular unsorted dictionary
d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}

# dictionary sorted by key
OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

# dictionary sorted by value
OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

复制粘贴自：http://docs.python.org/dev/library/collections.html#ordereddict-示例和食谱

享受；-）