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

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

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

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

使用namedtuple通常非常方便。例如，您有一个字典，其中“name”作为关键字，“score”作为值，您希望按“score“排序：

import collections
Player = collections.namedtuple('Player', 'score name')
d = {'John':5, 'Alex':10, 'Richard': 7}

首先以最低分数排序：

worst = sorted(Player(v,k) for (k,v) in d.items())

首先以最高分数排序：

best = sorted([Player(v,k) for (k,v) in d.items()], reverse=True)

现在，你可以得到的名字和分数，让我们说第二个最好的球员（索引=1）非常像这样：

player = best[1]
player.name
    'Richard'
player.score
    7

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

这适用于3.1.x：

import operator
slovar_sorted=sorted(slovar.items(), key=operator.itemgetter(1), reverse=True)
print(slovar_sorted)

尝试以下方法。让我们用以下数据定义一个名为mydict的字典：

mydict = {'carl':40,
          'alan':2,
          'bob':1,
          'danny':3}

如果要按关键字对字典进行排序，可以执行以下操作：

for key in sorted(mydict.iterkeys()):
    print "%s: %s" % (key, mydict[key])

这将返回以下输出：

alan: 2
bob: 1
carl: 40
danny: 3

另一方面，如果想要按值对字典进行排序（如问题中所问），可以执行以下操作：

for key, value in sorted(mydict.iteritems(), key=lambda (k,v): (v,k)):
    print "%s: %s" % (key, value)

此命令的结果（按值对字典进行排序）应返回以下内容：

bob: 1
alan: 2
danny: 3
carl: 40

这是一个在d.values（）和d.keys（）上使用zip的解决方案。此链接（在Dictionary视图对象上）下面的几行是：

这允许使用zip（）创建（value，key）对：pairs＝zip（d.values（），d.keys（））。

因此，我们可以执行以下操作：

d = {'key1': 874.7, 'key2': 5, 'key3': 8.1}

d_sorted = sorted(zip(d.values(), d.keys()))

print d_sorted 
# prints: [(5, 'key2'), (8.1, 'key3'), (874.7, 'key1')]