另一个答案中提到的集合解决方案绝对是极好的，因为您在键和值之间保留了一种联系，这在字典中是极其重要的。

我不同意另一个答案中的第一选择，因为它会扔掉钥匙。

我使用了上面提到的解决方案（代码如下所示），并保留了对键和值的访问权，在我的情况下，排序是对值进行的，但重要的是对值排序后的键排序。

from collections import Counter

x = {'hello':1, 'python':5, 'world':3}
c=Counter(x)
print( c.most_common() )


>> [('python', 5), ('world', 3), ('hello', 1)]

当然，请记住，您需要使用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 3.5

虽然我发现公认的答案很有用，但我也感到惊讶的是，它还没有更新，以引用标准库集合模块中的OrderedDict作为一种可行的现代替代方案-旨在解决这类问题。

from operator import itemgetter
from collections import OrderedDict

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

官方OrderedDict文档也提供了一个非常类似的示例，但使用lambda作为排序函数：

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

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

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)

如果您的值是整数，并且使用Python 2.7或更高版本，则可以使用collections.Counter而不是dict。most_common方法将为您提供按值排序的所有项。

正如Dilettant所指出的，Python 3.6现在将保持秩序！我想我应该分享我编写的一个函数，它简化了可迭代（元组、列表、dict）的排序。在后一种情况下，可以对键或值进行排序，并且可以考虑数值比较。仅适用于>=3.6！

当您尝试在包含字符串和int的可迭代对象上使用sorted时，sorted（）将失败。当然，您可以使用str（）强制字符串比较。然而，在某些情况下，您希望进行实际的数值比较，其中12小于20（字符串比较中不是这种情况）。所以我提出了以下建议。当您需要显式数字比较时，可以使用标志num_as_num，它将尝试通过将所有值转换为浮点数来执行显式数字排序。如果成功，它将进行数字排序，否则将诉诸字符串比较。

欢迎提出改进意见。

def sort_iterable(iterable, sort_on=None, reverse=False, num_as_num=False):
    def _sort(i):
      # sort by 0 = keys, 1 values, None for lists and tuples
      try:
        if num_as_num:
          if i is None:
            _sorted = sorted(iterable, key=lambda v: float(v), reverse=reverse)
          else:
            _sorted = dict(sorted(iterable.items(), key=lambda v: float(v[i]), reverse=reverse))
        else:
          raise TypeError
      except (TypeError, ValueError):
        if i is None:
          _sorted = sorted(iterable, key=lambda v: str(v), reverse=reverse)
        else:
          _sorted = dict(sorted(iterable.items(), key=lambda v: str(v[i]), reverse=reverse))
      
      return _sorted
      
    if isinstance(iterable, list):
      sorted_list = _sort(None)
      return sorted_list
    elif isinstance(iterable, tuple):
      sorted_list = tuple(_sort(None))
      return sorted_list
    elif isinstance(iterable, dict):
      if sort_on == 'keys':
        sorted_dict = _sort(0)
        return sorted_dict
      elif sort_on == 'values':
        sorted_dict = _sort(1)
        return sorted_dict
      elif sort_on is not None:
        raise ValueError(f"Unexpected value {sort_on} for sort_on. When sorting a dict, use key or values")
    else:
      raise TypeError(f"Unexpected type {type(iterable)} for iterable. Expected a list, tuple, or dict")