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)

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

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

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

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

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

months = {"January": 31, "February": 28, "March": 31, "April": 30, "May": 31,
          "June": 30, "July": 31, "August": 31, "September": 30, "October": 31,
          "November": 30, "December": 31}

def mykey(t):
    """ Customize your sorting logic using this function.  The parameter to
    this function is a tuple.  Comment/uncomment the return statements to test
    different logics.
    """
    return t[1]              # sort by number of days in the month
    #return t[1], t[0]       # sort by number of days, then by month name
    #return len(t[0])        # sort by length of month name
    #return t[0][-1]         # sort by last character of month name


# Since a dictionary can't be sorted by value, what you can do is to convert
# it into a list of tuples with tuple length 2.
# You can then do custom sorts by passing your own function to sorted().
months_as_list = sorted(months.items(), key=mykey, reverse=False)

for month in months_as_list:
    print month

您可以使用：

sorted(d.items(), key=lambda x: x[1])

这将根据字典中每个条目的值从最小到最大对字典进行排序。

要按降序排序，只需添加reverse=True：

sorted(d.items(), key=lambda x: x[1], reverse=True)

输入：

d = {'one':1,'three':3,'five':5,'two':2,'four':4}
a = sorted(d.items(), key=lambda x: x[1])    
print(a)

输出：

[('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]

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

from collections import Counter

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

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