问题描述：

我有一个字典，其中包含从数据库中的两个字段读取的值：一个字符串字段和一个数字字段。字符串字段是唯一的，因此它是字典的键。

我可以按键排序，但是如何根据值排序呢？

注意：我已在此处阅读 Stack Overflow 问题如何按字典值对字典列表进行排序？并且可能可以更改我的代码以获得字典列表，但由于我实际上不需要字典列表，所以我想知道是否有更简单的解决方案可以按升序或降序排序。

解决方案 1：

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}

或者

>>> 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)

解决方案 2：

简单来说：sorted(dict1, key=dict1.get)

嗯，实际上可以“按字典值排序”。最近，我不得不在 Code Golf 中执行此操作（Stack Overflow 问题Code golf：词频图）。简而言之，问题是这样的：给定一个文本，计算每个单词出现的频率，并显示按频率递减排序的热门单词列表。

如果构建一个以单词为键、以每个单词出现的次数为值的字典，这里简化为：

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

然后您可以获得一个单词列表，按使用频率排序sorted(d, key=d.get)- 排序遍历字典键，使用单词出现的次数作为排序键。

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

我写这篇详细的解释是为了说明人们常说的“我可以轻松地按键对字典进行排序，但如何按值排序”的意思——我认为原始帖子试图解决这个问题。解决方案是根据值对键列表进行排序，如上所示。

解决方案 3：

您可以使用：

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)]

解决方案 4：

字典无法排序，但你可以从中建立一个排序列表。

字典值的排序列表：

sorted(d.values())

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

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

解决方案 5：

在最近的 Python 2.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 的行为类似于普通字典：

>>> 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)])

解决方案 6：

使用 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)])

解决方案 7：

与Hank Gay 的回答几乎相同：

sorted([(value,key) for (key,value) in mydict.items()])

或者按照 John Fouhy 的建议稍微优化一下：

sorted((value,key) for (key,value) in mydict.items())

解决方案 8：

从Python 3.6开始，内置字典将按顺序排列

好消息是，OP 最初的用例是将从数据库中检索到的具有唯一字符串 ID 作为键、数字值作为值的对映射到内置的 Python v3.6+ 字典中，现在应该遵守插入顺序。

如果说数据库查询产生的两列表表达式如下：

SELECT a_key, a_value FROM a_table ORDER BY a_value;

将存储在两个 Python 元组中，k_seq 和 v_seq （按数字索引对齐，并且长度当然相同），然后：

k_seq = ('foo', 'bar', 'baz')
v_seq = (0, 1, 42)
ordered_map = dict(zip(k_seq, v_seq))

允许稍后输出为：

for k, v in ordered_map.items():
    print(k, v)

在这种情况下产生（对于新的 Python 3.6+ 内置字典！）：

foo 0
bar 1
baz 42

按 v 的每个值的相同顺序。

在我的计算机上安装的 Python 3.5 中，目前的输出为：

bar 1
foo 0
baz 42

细节：

正如 Raymond Hettinger 在 2012 年所提议的（参见 python-dev 上主题为“更紧凑的字典和更快的迭代”的邮件），现在（2016 年）Victor Stinner 在发给 python-dev 的一封主题为“Python 3.6 字典变得紧凑并获得私有版本；关键字变得有序”的邮件中宣布的那样，由于在 Python 3.6 中修复/实现了问题 27350 “紧凑且有序的字典”，我们现在可以使用内置字典来维护插入顺序！！

希望这将导致第一步是实现薄层 OrderedDict。正如 @JimFasarakis-Hilliard 指出的那样，有些人认为 OrderedDict 类型在未来也会有用例。我认为整个 Python 社区将仔细检查这是否经得起时间的考验，以及下一步将是什么。

是时候重新考虑我们的编码习惯，不要错过稳定排序带来的可能性：

• 关键字参数和

• （中级）字典存储

首先，因为在某些情况下它可以简化函数和方法的实现中的调度。

第二个原因是它鼓励更容易地使用dicts 作为处理管道中的中间存储。

Raymond Hettinger 友好地提供了文档来解释“ Python 3.6 字典背后的技术” - 摘自他在 2016 年 12 月 8 日的旧金山 Python 聚会小组演示。

也许相当多的 Stack Overflow 高装饰性问答页面会收到此信息的变体，并且许多高质量的答案也需要每个版本更新。

买者自慎（另请参阅下面的 2017-12-15 更新）：

正如 @ajcr 正确指出的那样：“此新实现的保序方面被视为实现细节，不应依赖。”（来自whatsnew36）不是吹毛求疵，但引用有点悲观 ;-)。它继续说“（这可能会在未来发生变化，但希望在更改语言规范以强制所有当前和未来 Python 实现的保序语义之前，在语言的几个版本中拥有这个新的字典实现；这也有助于保持与旧版本的语言的向后兼容性，其中随机迭代顺序仍然有效，例如 Python 3.5）。”

因此，就像某些人类语言（例如德语）一样，用法塑造了语言，而意志现在已经在whatsnew36中宣告。

更新2017-12-15：

在给 python-dev 列表的一封邮件中，Guido van Rossum 声明：

就这样吧。“Dict 保持插入顺序”是裁决。谢谢！

因此，3.6 版 CPython 的字典插入顺序副作用现在已成为语言规范的一部分（而不再仅仅是实现细节）。该邮件线程还揭示了一些独特的设计目标，正如collections.OrderedDictRaymond Hettinger 在讨论中提醒的那样。

解决方案 9：

使用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），就像这样非常 Pythonical：

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

解决方案 10：

从 Python 3.6 开始，dict对象按插入顺序排序。这已正式纳入 Python 3.7 的规范中。

>>> words = {"python": 2, "blah": 4, "alice": 3}
>>> dict(sorted(words.items(), key=lambda x: x[1]))
{'python': 2, 'alice': 3, 'blah': 4}

在此之前，您必须使用OrderedDict。

Python 3.7 文档说：

在 3.7 版中更改：保证字典顺序与插入顺序一致。此行为是从 3.6 版开始的 CPython 实现细节。

解决方案 11：

我遇到了同样的问题，我是这么解决的：

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

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

请注意，顺序定义不明确（具有相同值的键在输出列表中将按任意顺序排列）。

解决方案 12：

如果值是数字，您也可以使用Counter来自集合的值。

from collections import Counter

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

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

解决方案 13：

在 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-examples-and-recipes

享受 ;-）

解决方案 14：

这是代码：

import operator
origin_list = [
    {"name": "foo", "rank": 0, "rofl": 20000},
    {"name": "Silly", "rank": 15, "rofl": 1000},
    {"name": "Baa", "rank": 300, "rofl": 20},
    {"name": "Zoo", "rank": 10, "rofl": 200},
    {"name": "Penguin", "rank": -1, "rofl": 10000}
]
print ">> Original >>"
for foo in origin_list:
    print foo

print "
>> Rofl sort >>"
for foo in sorted(origin_list, key=operator.itemgetter("rofl")):
    print foo

print "
>> Rank sort >>"
for foo in sorted(origin_list, key=operator.itemgetter("rank")):
    print foo

结果如下：

原来的

{'name': 'foo', 'rank': 0, 'rofl': 20000}
{'name': 'Silly', 'rank': 15, 'rofl': 1000}
{'name': 'Baa', 'rank': 300, 'rofl': 20}
{'name': 'Zoo', 'rank': 10, 'rofl': 200}
{'name': 'Penguin', 'rank': -1, 'rofl': 10000}

哈哈哈

{'name': 'Baa', 'rank': 300, 'rofl': 20}
{'name': 'Zoo', 'rank': 10, 'rofl': 200}
{'name': 'Silly', 'rank': 15, 'rofl': 1000}
{'name': 'Penguin', 'rank': -1, 'rofl': 10000}
{'name': 'foo', 'rank': 0, 'rofl': 20000}

秩

{'name': 'Penguin', 'rank': -1, 'rofl': 10000}
{'name': 'foo', 'rank': 0, 'rofl': 20000}
{'name': 'Zoo', 'rank': 10, 'rofl': 200}
{'name': 'Silly', 'rank': 15, 'rofl': 1000}
{'name': 'Baa', 'rank': 300, 'rofl': 20}

解决方案 15：

尝试以下方法。让我们用以下数据定义一个名为 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

解决方案 16：

您还可以创建一个“倒排索引”

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]

解决方案 17：

您可以使用collections.Counter。请注意，这适用于数字和非数字值。

>>> x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
>>> from collections import Counter
>>> #To sort in reverse order
>>> Counter(x).most_common()
[(3, 4), (4, 3), (1, 2), (2, 1), (0, 0)]
>>> #To sort in ascending order
>>> Counter(x).most_common()[::-1]
[(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]
>>> #To get a dictionary sorted by values
>>> from collections import OrderedDict
>>> OrderedDict(Counter(x).most_common()[::-1])
OrderedDict([(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)])

解决方案 18：

另一个答案中提到的集合解决方案绝对非常棒，因为您保留了键和值之间的联系，这在字典的情况下极为重要。

我不同意另一个答案中提出的第一选择，因为它丢掉了钥匙。

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

from collections import Counter

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


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

解决方案 19：

您还可以使用可传递给参数键的自定义函数。

def dict_val(x):
    return x[1]

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

解决方案 20：

您可以使用跳过字典，它是一个按值永久排序的字典。

>>> data = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
>>> SkipDict(data)
{0: 0.0, 2: 1.0, 1: 2.0, 4: 3.0, 3: 4.0}

如果您使用keys()，values()或者items()，那么您将按值的排序顺序进行迭代。

它是使用跳过列表数据结构实现的。

解决方案 21：

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

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

如果你没有 Python 2.7 或更高版本，那么最好的办法就是使用生成器函数迭代这些值。（这里有一个适用OrderedDict于 2.4 和 2.6 的 版本，但是

a) 我不知道效果如何

和

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 或更高版本，请记得删除打印后的括号

解决方案 22：

我刚刚从《Python for Everybody》中学习了相关技能。

您可以使用临时列表来帮助您对字典进行排序：

# Assume dictionary to be:
d = {'apple': 500.1, 'banana': 1500.2, 'orange': 1.0, 'pineapple': 789.0}

# Create a temporary list
tmp = []

# Iterate through the dictionary and append each tuple into the temporary list
for key, value in d.items():
    tmptuple = (value, key)
    tmp.append(tmptuple)

# Sort the list in ascending order
tmp = sorted(tmp)

print (tmp)

如果要按降序对列表进行排序，只需将原始排序行更改为：

tmp = sorted(tmp, reverse=True)

使用列表推导，一行代码如下：

# Assuming the dictionary looks like
d = {'apple': 500.1, 'banana': 1500.2, 'orange': 1.0, 'pineapple': 789.0}
# One-liner for sorting in ascending order
print (sorted([(v, k) for k, v in d.items()]))
# One-liner for sorting in descending order
print (sorted([(v, k) for k, v in d.items()], reverse=True))

示例输出：

# Ascending order
[(1.0, 'orange'), (500.1, 'apple'), (789.0, 'pineapple'), (1500.2, 'banana')]
# Descending order
[(1500.2, 'banana'), (789.0, 'pineapple'), (500.1, 'apple'), (1.0, 'orange')]

解决方案 23：

from django.utils.datastructures import SortedDict

def sortedDictByKey(self,data):
    """Sorted dictionary order by key"""
    sortedDict = SortedDict()
    if data:
        if isinstance(data, dict):
            sortedKey = sorted(data.keys())
            for k in sortedKey:
                sortedDict[k] = data[k]
    return sortedDict

解决方案 24：

d.values()以下是使用 zip和 的d.keys()解决方案。此链接下方几行（在 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')]

解决方案 25：

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

当您尝试对包含字符串和整数的迭代器使用 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")

解决方案 26：

使用dicts中的ValueSortedDict：

from dicts.sorteddict import ValueSortedDict
d = {1: 2, 3: 4, 4:3, 2:1, 0:0}
sorted_dict = ValueSortedDict(d)
print sorted_dict.items() 

[(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]

解决方案 27：

遍历一个字典并按其值的降序排序：

$ python --version
Python 3.2.2

$ cat sort_dict_by_val_desc.py 
dictionary = dict(siis = 1, sana = 2, joka = 3, tuli = 4, aina = 5)
for word in sorted(dictionary, key=dictionary.get, reverse=True):
  print(word, dictionary[word])

$ python sort_dict_by_val_desc.py 
aina 5
tuli 4
joka 3
sana 2
siis 1

解决方案 28：

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

解决方案 29：

这在 3.1.x 中有效：

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

解决方案 30：

为了完整起见，我发布了一个使用heapq的解决方案。请注意，此方法适用于数字和非数字值

>>> x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
>>> x_items = x.items()
>>> heapq.heapify(x_items)
>>> #To sort in reverse order
>>> heapq.nlargest(len(x_items),x_items, operator.itemgetter(1))
[(3, 4), (4, 3), (1, 2), (2, 1), (0, 0)]
>>> #To sort in ascending order
>>> heapq.nsmallest(len(x_items),x_items, operator.itemgetter(1))
[(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]