如何按值对字典排序？

这篇文章是 社区维基 。 编辑现有答案以改善此职位。 它当前不接受新的答案。

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

我可以对键进行排序，但是如何根据值进行排序？

注意：我在这里阅读了堆栈溢出问题， 如何按字典值对字典列表进行排序？ 可能会更改我的代码以包含字典列表，但是由于我实际上并不需要字典列表，因此我想知道是否存在一种更简单的解决方案来按升序或降序进行排序。

---

#1楼

如果值是数字，则还可以使用来自集合的 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)]    

---

#2楼

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

---

#3楼

为了完整起见，我发布了一个使用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)]

---

#4楼

在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

请享用 ;-）

---

#5楼

由于需要保持与旧版本Python的向后兼容性，因此我认为OrderedDict解决方案非常不明智。 您需要适用于Python 2.7和更早版本的工具。

但是，另一个答案中提到的集合解决方案绝对是极好的，因为您可以重新训练键和值之间的联系，这对于字典而言极为重要。

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

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

from collections import Counter

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


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

---

#6楼

您可以使用：

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

这将按照字典中每个条目的值（从最小到最大）对字典进行排序。

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

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

---

#7楼

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

---

#8楼

您可以使用skip dict ，这是一个按值永久排序的字典。

>>> 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()则将按值对排序顺序进行迭代。

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

---

#9楼

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

这允许使用zip（）创建（值，键）对：pair = 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')]

---

#10楼

当然，请记住，您需要使用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或更高版本，请记住在打印后删除括号

---

#11楼

在最近的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)])

---

#12楼

就像这样简单： sorted(dict1, key=dict1.get)

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

如果您以单词为键构建字典，每个单词的出现次数为值，则简化为：

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

那么您可以获取单词列表，并按sorted(d, key=d.get)的使用频率进行sorted(d, key=d.get) -使用单词出现的次数作为sort key，排序遍历字典键。

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

我正在写这个详细的说明，以说明人们通常所说的“我可以很容易地按键对字典进行排序，但是如何按值对字典进行排序”的意思-我认为OP试图解决这一问题。 解决方案是根据值对键列表进行排序，如上所示。

---

#13楼

更新：2015年12月5日使用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)])

---

#14楼

从Python 3.6开始，将对内置字典进行排序

好消息，因此OP从数据库中检索到的映射对的原始用例（以唯一的字符串ID作为键，而数值作为值）到内置Python v3.6 + dict中，现在应该遵守插入顺序。

如果说从数据库查询中得到的两个列表表达式如下：

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 dict紧凑并获得私有版本；由于在Python 3.6中已解决/实现了问题27350 “紧凑且有序的字典” ，因此关键字变得有序” ，我们现在可以使用内置的字典来维护插入顺序！！

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

是时候重新考虑我们的编码习惯，以免错过以下稳定订单所带来的可能性：

• 关键字参数和
• （中级）字典存储

第一个是因为它在某些情况下简化了函数和方法的实现中的调度。

第二个原因是它鼓励在处理管道中更轻松地将dict用作中间存储。

Raymond Hettinger从旧金山Python Meetup Group的演讲2016-DEC-08中提供了解释“ Python 3.6词典背后的技术 ” 的文档。

也许相当一部分Stack Overflow高修饰度的问答页面会收到此信息的变体，并且许多高质量的答案也需要按版本进行更新。

警告购买者（另请参阅下面的更新2017-12-15）：

正如@ajcr正确指出的那样：“此新实现的顺序保留方面被认为是实现细节，因此不应依赖。” （摘自whatsnew36 ）并不是很挑剔， 但引文有点悲观了；-)。 它继续显示为“（将来可能会改变，但是希望在更改语言规范以强制所有当前和将来的Python实现保留顺序语义之前，先在几个版本中使用该语言的新dict实现；有助于保持与仍旧有效的随机迭代顺序的旧版语言（例如Python 3.5）的向后兼容性。”

因此，就像在某些人类语言（例如德语）中一样，用法决定了语言的使用方式，现在遗嘱已在whatsnew36中声明。

更新2017-12-15：

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

做到这一点。 裁定“裁定保留插入顺序”。 谢谢！

因此，dict插入顺序的3.6 CPython版本的副作用现在已成为语言规范的一部分（并且不再仅仅是实现细节）。 该邮件线程还浮出了collections.OrderedDict一些区别设计目标，正如Raymond Hettinger在讨论中所提醒的那样。

---

#15楼

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

---

#16楼

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

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

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

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

---

#17楼

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

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)

---

#18楼

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

---

#19楼

刚刚从Python for Everyone中学习了相关技能。

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

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

样本输出：

#Asending 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')]

---

#20楼

这是代码：

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 "\n>> Rofl sort >>"
for foo in sorted(origin_list, key=operator.itemgetter("rofl")):
    print foo

print "\n>> 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}

---

#21楼

从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的实现细节。

---

#22楼

无法对字典进行排序，只能获得已排序字典的表示形式。 字典本质上是无序的，但其他类型（例如列表和元组）不是。 因此，您需要一个有序的数据类型来表示排序后的值，该值将是一个列表-可能是一个元组列表。

例如，

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中，由于不允许拆包[1]，我们可以使用

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)

---

#23楼

字典无法排序，但是您可以从中建立排序列表。

字典值的排序列表：

sorted(d.values())

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

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

---

#24楼

与Hank Gay的答案几乎相同：

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

或根据John Fouhy的建议进行了稍微优化：

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

---

#25楼

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

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]

---

#26楼

使用namedtuple通常很方便。 例如，您有一个“名称”作为键，而“分数”作为值的字典，并且您想对“分数”进行排序：

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)

现在您可以得到Python的第二好玩家（index = 1）的名称和得分，如下所示：

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

---

#27楼

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

---

#28楼

遍历字典并按其值降序对其进行排序：

$ 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

---

#29楼

这适用于3.1.x：

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

---

#30楼

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