Python 如何按值对词典排序?
我有一个从数据库中的两个字段读取的值字典:字符串字段和数字字段。字符串字段是唯一的,因此它是字典的键 我可以按键排序,但如何根据值排序 注意:我已经阅读了这里的堆栈溢出问题,可能可以将我的代码更改为字典列表,但由于我并不真正需要字典列表,我想知道是否有更简单的解决方案可以按升序或降序排序。Python 3.7+或CPython 3.6 Dicts在Python 3.7+中保留插入顺序。在CPython 3.6中相同,但是 或 老蟒蛇 不可能对字典进行排序,只能获得已排序字典的表示形式。字典本质上是无序的,但其他类型(如列表和元组)则不是。因此,您需要一个有序的数据类型来表示排序后的值,这将是一个列表,可能是一个元组列表 比如说,Python 如何按值对词典排序?,python,sorting,dictionary,Python,Sorting,Dictionary,我有一个从数据库中的两个字段读取的值字典:字符串字段和数字字段。字符串字段是唯一的,因此它是字典的键 我可以按键排序,但如何根据值排序 注意:我已经阅读了这里的堆栈溢出问题,可能可以将我的代码更改为字典列表,但由于我并不真正需要字典列表,我想知道是否有更简单的解决方案可以按升序或降序排序。Python 3.7+或CPython 3.6 Dicts在Python 3.7+中保留插入顺序。在CPython 3.6中相同,但是 或 老蟒蛇 不可能对字典进行排序,只能获得已排序字典的表示形式。字典本质上
import operator
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=operator.itemgetter(1))
sorted_x
将是按每个元组中的第二个元素排序的元组列表<代码>目录(排序的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])
如果希望输出为dict,可以使用:
无法对dict进行排序,但可以从中构建排序列表 dict值的排序列表:
sorted(d.values())
按值排序的(键、值)对列表:
from operator import itemgetter
sorted(d.items(), key=itemgetter(1))
与以下内容大致相同:
或者按照John Fouhy的建议稍微优化:
sorted((value,key) for (key,value) in mydict.items())
您还可以创建“反向索引”
现在你的倒数有了值;每个值都有一个适用键的列表
for k in sorted(inverse):
print k, inverse[k]
您可以使用:
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)]
输出:
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)]
在最近的Python2.7中,我们有了新的类型,它记住了添加项的顺序
>>> 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的行为与普通dict类似:
>>> 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)])
简单到:sorted(dict1,key=dict1.get)
实际上,可以“按字典值排序”。最近,我不得不在一个代码高尔夫(堆栈溢出问题)中这样做。简而言之,问题是这样的:给定一个文本,计算每个单词遇到的频率,并显示一个按频率递减排序的最热门单词列表
如果以单词作为关键字,以每个单词的出现次数作为值来构建词典,则此处简化为:
from collections import defaultdict
d = defaultdict(int)
for w in text.split():
d[w] += 1
然后,您可以获得一个单词列表,按使用频率排序,排序将使用单词出现的次数作为排序键,在字典键上迭代
for w in sorted(d, key=d.get, reverse=True):
print(w, d[w])
我写这篇详细的解释是为了说明人们常说的“我可以很容易地按键对字典排序,但我如何按值排序”的意思,我想这篇文章的原意就是要解决这样一个问题。解决方案是根据上述值对键列表进行排序。我也遇到了同样的问题,我这样解决了这个问题:
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
WantedOutput = sorted(MyDict, key=lambda x : MyDict[x])
player = best[1]
player.name
'Richard'
player.score
7
(回答“不可能对dict排序”的人没有读过这个问题!事实上,“我可以按键排序,但如何根据值排序?”显然意味着他想要一个按键值排序的键列表。)
请注意,顺序没有很好地定义(具有相同值的键将在输出列表中以任意顺序排列)。这是代码:
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}
Rofl
{'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}
它通常使用起来非常方便。例如,您有一个字典,其中“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)
首先以最高分数排序:
worst = sorted(Player(v,k) for (k,v) in d.items())
best = sorted([Player(v,k) for (k,v) in d.items()], reverse=True)
现在,您可以获得第二名最佳球员(index=1)的名字和分数,非常像这样:
WantedOutput = sorted(MyDict, key=lambda x : MyDict[x])
player = best[1]
player.name
'Richard'
player.score
7
使用valuesortedct来自:
迭代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
这在3.1.x中起作用:
import operator
slovar_sorted=sorted(slovar.items(), key=operator.itemgetter(1), reverse=True)
print(slovar_sorted)
如果您的值是整数,并且您使用的是Python 2.7或更新版本,那么您可以使用而不是
dict
。最常用的方法将为您提供按值排序的所有项目。如果值是数字,您也可以从中使用
您可以使用。注意,这将适用于数值和非数值
>>> 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)])
为了完整起见,我发布了一个使用的解决方案。注意,此方法适用于数值和非数值
>>> 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 2.7中,只需执行以下操作:
从集合导入订单数据
#常规未分类词典
d={‘香蕉’:3,‘苹果’:4,‘梨’:1,‘橘子’:2}
#按键排序的词典
OrderedDict(已排序(d.items(),key=lambda t:t[0]))
订购信息([('apple',4),('banana',3),('orange',2),('pear',1)])
#按值排序的字典
OrderedDict(已排序(d.items(),key=lambda t:t[1]))
订单信息([('pear',1),('orange',2),('banana',3),('apple',4)])
复制粘贴自:
享受;-) 试试下面的方法。让我们用以下数据定义一个名为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 = {'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')]
此命令的结果(按值对字典排序)应返回以下内容:
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 = {'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')]
您可以使用一个永久按值排序的字典
>>> 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()
,则将按值的顺序进行迭代
>>> 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}
它是使用数据结构实现的。下面是一个so
# 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)])
SELECT a_key, a_value FROM a_table ORDER BY a_value;
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)
foo 0
bar 1
baz 42
bar 1
foo 0
baz 42
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)
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")
#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')]
>>> words = {"python": 2, "blah": 4, "alice": 3}
>>> dict(sorted(words.items(), key=lambda x: x[1]))
{'python': 2, 'alice': 3, 'blah': 4}