题
我有一个从数据库中的两个字段读取的值字典:一个字符串字段和一个数字字段。字符串字段是唯一的,因此它是字典的键。
我可以按键排序,但如何根据值排序?
笔记:我在这里阅读了堆栈溢出问题 如何按字典的值对字典列表进行排序? 并且可能可以更改我的代码以拥有字典列表,但由于我实际上并不需要字典列表,所以我想知道是否有更简单的解决方案可以按升序或降序排序。
解决方案
无法对字典进行排序,只能获取已排序字典的表示形式。字典本质上是无序的,但其他类型(如列表和元组)则不是。所以你需要一个有序的数据类型来表示排序的值,这将是一个列表—可能是一个元组列表。
例如,
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])
如果您希望输出为dict,可以使用 collections.OrderedDict 代码>
:
import collections
sorted_dict = collections.OrderedDict(sorted_x)
其他提示
简单如下: 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]
我正在写这个详细的解释来说明人们通常所说的“我可以轻松按键排序字典,但我如何按值排序”? - 我认为OP正试图解决这个问题。解决方案是根据值对键进行排序,如上所示。
您可以使用:
sorted(d.items(), key=lambda x: x[1])
这将根据字典中从最小到最大的每个条目的值对字典进行排序。
要按降序对其进行排序,只需添加 reverse = True
:
sorted(d.items(), key=lambda x: x[1], reverse=True)
无法对Dicts进行排序,但您可以从中构建排序列表。
dict值的排序列表:
sorted(d.values())
(键,值)对的列表,按值排序:
from operator import itemgetter
sorted(d.items(), key=itemgetter(1))
在最近的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)])
更新:2015年12月5日使用Python 3.5
虽然我发现接受的答案很有用,但我还惊讶于它尚未更新以引用 集合模块的collections.OrderedDict“rel =”noreferrer“> 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作为sort函数:
# 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)])
与 Hank Gay的答案非常相似:
sorted([(value,key) for (key,value) in mydict.items()])
或者根据John Fouhy的建议略微优化:
sorted((value,key) for (key,value) in mydict.items())
使用 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
作为 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 dict 变得紧凑并获得私有版本;并且关键字变得有序” 由于问题 27350 的修复/实施 “紧凑有序的字典” 在 Python 3.6 中,我们现在可以使用内置字典来维护插入顺序!
希望这将导致薄层 OrderedDict 实现作为第一步。正如 @JimFasarakis-Hilliard 所指出的,有些人认为 OrderedDict 类型在未来也会有用例。我认为整个 Python 社区都会仔细检查这是否经得起时间的考验,以及下一步将是什么。
是时候重新思考我们的编码习惯了,不要错过稳定排序带来的可能性:
- 关键字参数和
- (中级)字典存储
第一个是因为它在某些情况下简化了函数和方法实现中的调度。
第二个,因为它鼓励更轻松地使用 dict
作为处理管道中的中间存储。
Raymond Hettinger 善意地提供了解释“的文件”Python 3.6 字典背后的技术“ - 摘自他 2016 年 12 月 8 日在旧金山 Python Meetup Group 上的演讲。
也许相当多的 Stack Overflow 高级装饰问答页面将收到此信息的变体,并且许多高质量的答案也将需要每个版本的更新。
买者自负(但也请参阅下面的更新 2017-12-15):
正如 @ajcr 正确指出的那样:“这个新实现的顺序保留方面被认为是一个实现细节,不应该被依赖。(从 最新消息36)不是吹毛求疵, 但 引文被削减了一点悲观;-)。它继续为“(这将来可能会改变,但希望在更改语言规范以强制所有当前和未来的 Python 实现使用顺序保留语义之前,在几个版本的语言中拥有这个新的 dict 实现;这也有助于保持与旧版本语言的向后兼容性,其中随机迭代顺序仍然有效,例如Python 3.5)。”
就像某些人类语言一样(例如德语),用法塑造了语言,现在已经宣布了遗嘱......在 最新消息36.
2017年12月15日更新:
在一个 邮寄到 python-dev 列表, ,Guido van Rossum 宣称:
就这样吧。裁决是“Dict 保持插入顺序”。谢谢!
因此,3.6 版 CPython 字典插入排序的副作用现在已成为语言规范的一部分(而不再只是实现细节)。该邮件线程还提出了一些独特的设计目标 collections.OrderedDict
正如 Raymond Hettinger 在讨论中所提醒的那样。
我遇到了同样的问题,我解决了这个问题:
WantedOutput = sorted(MyDict, key=lambda x : MyDict[x])
(回答“不可能对词典进行排序”的人没有读到这个问题!事实上,“我可以对键进行排序,但我如何根据值进行排序?”他想要一个按照值的值排序的密钥列表。)
请注意,订单定义不明确(具有相同值的键将在输出列表中以任意顺序排列)。
在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/开发/库/ collections.html#ordereddict-实例和 - 食谱
享受; - )
这是代码:
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}
<强> ROFL 强>
{'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}
尝试以下方法。让我们使用以下数据定义一个名为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
您可以创建“倒置索引”,也是
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]
您可以使用 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)])
从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
。
版本3.7中更改:保证字典顺序是插入 订购。这种行为是来自3.6的CPython的实现细节。
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
您还可以使用可以传递给密钥的自定义功能。
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)
正如Dilettant所指出的那样,Python 3.6现在保持订单!我以为我会共享一个我编写的函数,它可以简化迭代(元组,列表,字典)的排序。在后一种情况下,您可以对键或值进行排序,并且可以将数值比较考虑在内。 仅适用于&gt; = 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")
以下是在 d上使用zip的解决方案。 values()
和 d.keys()
。此链接的几行(在Dictionary视图对象上)是:
这允许使用zip()创建(值,键)对: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')]
使用 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)]
通过dict迭代并按其值按降序对其进行排序:
$ 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
如果您的值是整数,并且您使用的是Python 2.7或更高版本,则可以使用 collections.Counter
而不是 dict
。 most_common
方法将为您提供所有项目,按值排序。
当然,请记住,您需要使用 OrderedDict
,因为常规Python词典不保留原始顺序。
from collections import OrderedDict
a = OrderedDict(sorted(originalDict.items(), key=lambda x: x[1]))
如果你没有Python 2.7或更高版本,你可以做的最好的事情就是迭代生成器函数中的值。 (2.4和2.6 此处有 OrderedDict
,但
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或更高版本
,请记得在打印后删除括号这适用于3.1.x:
import operator
slovar_sorted=sorted(slovar.items(), key=operator.itemgetter(1), reverse=True)
print(slovar_sorted)
为了完整起见,我使用 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)]
刚刚从 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))
示例输出:
#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')]
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