在最近的Python2.7中，我们有了新的OrderedDict类型，它可以记住添加项目的顺序。

>>> d = {"third": 3, "first": 1, "fourth": 4, "second": 2}

>>> for k, v in d.items():
...     print "%s: %s" % (k, v)
...
second: 2
fourth: 4
third: 3
first: 1

>>> d
{'second': 2, 'fourth': 4, 'third': 3, 'first': 1}

要从原始字典创建新的有序字典，请按值排序：

>>> from collections import OrderedDict
>>> d_sorted_by_value = OrderedDict(sorted(d.items(), key=lambda x: x[1]))

OrderedDict的行为类似于普通dict：

>>> for k, v in d_sorted_by_value.items():
...     print "%s: %s" % (k, v)
...
first: 1
second: 2
third: 3
fourth: 4

>>> d_sorted_by_value
OrderedDict([('first': 1), ('second': 2), ('third': 3), ('fourth': 4)])

字典无法排序，但您可以根据它们构建排序列表。

字典值的排序列表：

sorted(d.values())

按值排序的（键、值）对列表：

from operator import itemgetter
sorted(d.items(), key=itemgetter(1))

正如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")

您还可以创建“反向索引”

from collections import defaultdict
inverse= defaultdict( list )
for k, v in originalDict.items():
    inverse[v].append( k )

现在你的逆函数有了值；每个值都有一个适用的键列表。

for k in sorted(inverse):
    print k, inverse[k]

我有同样的问题，我这样解决了：

WantedOutput = sorted(MyDict, key=lambda x : MyDict[x]) 

（回答“不可能对字典进行排序”的人没有读到这个问题！事实上，“我可以对键进行排序，但如何根据值进行排序？”显然意味着他想要一个根据其值排序的键列表。）

请注意，顺序没有很好地定义（具有相同值的键在输出列表中的顺序是任意的）。

如果值是数字，则还可以使用集合中的计数器。

from collections import Counter

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

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