如何按字典值对字典列表进行排序？-Java 学习之路

1461

我有一个字典列表，希望每个项目按特定的属性值排序 .

考虑下面的数组，

[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

按 name 排序时，应该成为

[{'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}]

18 回答

2

这是my answer to a related question on sorting by multiple columns . 它也适用于列数仅为1的退化情况 .

回复于 2024-04-26T19:17:18+08:00
0
```
import operator
```
要按key ='name'对字典列表进行排序：
```
list_of_dicts.sort(key=operator.itemgetter('name'))
```
按键='年龄'对字典列表进行排序：
```
list_of_dicts.sort(key=operator.itemgetter('age'))
```
回复于 2024-04-26T19:17:18+08:00

这是另一种通用解决方案 - 它按键和值对dict元素进行排序 . 它的优点 - 不需要指定键，如果某些词典中缺少某些键，它仍然可以工作 .

def sort_key_func(item):
    """ helper function used to sort list of dicts

    :param item: dict
    :return: sorted list of tuples (k, v)
    """
    pairs = []
    for k, v in item.items():
        pairs.append((k, v))
    return sorted(pairs)
sorted(A, key=sort_key_func)

回复于 2024-04-26T19:17:18+08:00

14
如果要按多个键对列表进行排序，可以执行以下操作：
```
my_list = [{'name':'Homer', 'age':39}, {'name':'Milhouse', 'age':10}, {'name':'Bart', 'age':10} ]
sortedlist = sorted(my_list , key=lambda elem: "%02d %s" % (elem['age'], elem['name']))
```
它相当hackish，因为它依赖于将值转换为单个字符串表示以进行比较，但它对于包含负数的数字的预期工作（尽管如果使用数字，则需要使用零填充来适当地格式化字符串）
回复于 2024-04-26T19:17:18+08:00
8

您必须实现自己的比较函数，该函数将按名称键的值比较字典 . 见Sorting Mini-HOW TO from PythonInfo Wiki

回复于 2024-04-26T19:17:18+08:00

您可以使用以下代码

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

回复于 2024-04-26T19:17:18+08:00

使用pandas包是另一种方法，虽然它的大规模运行时比其他人提出的更传统的方法要慢得多：

import pandas as pd

listOfDicts = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
df = pd.DataFrame(listOfDicts)
df = df.sort_values('name')
sorted_listOfDicts = df.T.to_dict().values()

以下是一个小列表和一个大的（100k）dicts列表的一些基准值：

setup_large = "listOfDicts = [];\
[listOfDicts.extend(({'name':'Homer', 'age':39}, {'name':'Bart', 'age':10})) for _ in range(50000)];\
from operator import itemgetter;import pandas as pd;\
df = pd.DataFrame(listOfDicts);"

setup_small = "listOfDicts = [];\
listOfDicts.extend(({'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}));\
from operator import itemgetter;import pandas as pd;\
df = pd.DataFrame(listOfDicts);"

method1 = "newlist = sorted(listOfDicts, key=lambda k: k['name'])"
method2 = "newlist = sorted(listOfDicts, key=itemgetter('name')) "
method3 = "df = df.sort_values('name');\
sorted_listOfDicts = df.T.to_dict().values()"

import timeit
t = timeit.Timer(method1, setup_small)
print('Small Method LC: ' + str(t.timeit(100)))
t = timeit.Timer(method2, setup_small)
print('Small Method LC2: ' + str(t.timeit(100)))
t = timeit.Timer(method3, setup_small)
print('Small Method Pandas: ' + str(t.timeit(100)))

t = timeit.Timer(method1, setup_large)
print('Large Method LC: ' + str(t.timeit(100)))
t = timeit.Timer(method2, setup_large)
print('Large Method LC2: ' + str(t.timeit(100)))
t = timeit.Timer(method3, setup_large)
print('Large Method Pandas: ' + str(t.timeit(1)))

#Small Method LC: 0.000163078308105
#Small Method LC2: 0.000134944915771
#Small Method Pandas: 0.0712950229645
#Large Method LC: 0.0321750640869
#Large Method LC2: 0.0206089019775
#Large Method Pandas: 5.81405615807

回复于 2024-04-26T19:17:18+08:00

有时我们需要使用 lower()

lists = [{'name':'Homer', 'age':39},
  {'name':'Bart', 'age':10},
  {'name':'abby', 'age':9}]

lists = sorted(lists, key=lambda k: k['name'])
print(lists)
# [{'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}, {'name':'abby', 'age':9}]

lists = sorted(lists, key=lambda k: k['name'].lower())
print(lists)
# [ {'name':'abby', 'age':9}, {'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}]

回复于 2024-04-26T19:17:18+08:00

5
```
import operator
a_list_of_dicts.sort(key=operator.itemgetter('name'))
```
'key'用于按任意值排序，'itemgetter'将该值设置为每个项的'name'属性 .
回复于 2024-04-26T19:17:18+08:00
9
使用密钥而不是cmp可能看起来更干净：
```
newlist = sorted(list_to_be_sorted, key=lambda k: k['name'])
```
或者作为J.F.Sebastian和其他人的建议，
```
from operator import itemgetter
newlist = sorted(list_to_be_sorted, key=itemgetter('name'))
```
为了完整性（如fitzgeraldsteele的评论中所指出），添加 reverse=True 以降序排序
```
newlist = sorted(l, key=itemgetter('name'), reverse=True)
```
回复于 2024-04-26T19:17:18+08:00
44
```
my_list = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

my_list.sort(lambda x,y : cmp(x['name'], y['name']))
```
my_list 现在就是你想要的 .

(3 years later) Edited to add:

新的 key 参数更有效，更整洁 . 现在更好的答案如下：
```
my_list = sorted(my_list, key=lambda k: k['name'])
```
......作为IMO，lambda比 operator.itemgetter 更容易理解，但YMMV .
回复于 2024-04-26T19:17:18+08:00
14
您可以使用自定义比较功能，也可以传入计算自定义排序键的函数 . 这通常更有效，因为每个项目只计算一次密钥，而比较函数将被调用多次 .

你可以这样做：
```
def mykey(adict): return adict['name']
x = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age':10}]
sorted(x, key=mykey)
```
但标准库包含获取任意对象项的通用例程： itemgetter . 所以试试这个：
```
from operator import itemgetter
x = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age':10}]
sorted(x, key=itemgetter('name'))
```
回复于 2024-04-26T19:17:18+08:00

让我说我是一个字典D与下面的元素 . 要排序只使用sorted中的key参数来传递自定义函数，如下所示

D = {'eggs': 3, 'ham': 1, 'spam': 2}

def get_count(tuple):
    return tuple[1]

sorted(D.items(), key = get_count, reverse=True)
or
sorted(D.items(), key = lambda x: x[1], reverse=True)  avoiding get_count function call

https://wiki.python.org/moin/HowTo/Sorting/#Key_Functions

回复于 2024-04-26T19:17:18+08:00

a = [{'name':'Homer', 'age':39}, ...]

# This changes the list a
a.sort(key=lambda k : k['name'])

# This returns a new list (a is not modified)
sorted(a, key=lambda k : k['name'])

回复于 2024-04-26T19:17:18+08:00

119

我想你的意思是：

[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]

这将按如下方式排序：

sorted(l,cmp=lambda x,y: cmp(x['name'],y['name']))

回复于 2024-04-26T19:17:18+08:00

如果您不需要 dictionaries 的原始 list ，则可以使用自定义键功能使用 sort() 方法对其进行原位修改 .

主要功能：

def get_name(d):
    """ Return the value of a key in a dictionary. """

    return d["name"]

list 要排序：

data_one = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age': 10}]

就地排序：

data_one.sort(key=get_name)

如果你需要原始 list ，调用 sorted() 函数传递 list 和键函数，然后将返回的有序 list 分配给一个新变量：

data_two = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age': 10}]
new_data = sorted(data_two, key=get_name)

打印 data_one 和 new_data .

>>> print(data_one)
[{'name': 'Bart', 'age': 10}, {'name': 'Homer', 'age': 39}]
>>> print(new_data)
[{'name': 'Bart', 'age': 10}, {'name': 'Homer', 'age': 39}]

回复于 2024-04-26T19:17:18+08:00

1953
我试过这样的事情：
```
my_list.sort(key=lambda x: x['name'])
```
它也适用于整数 .
回复于 2024-04-26T19:17:18+08:00
18
使用Perl的Schwartzian变换，
```
py = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
```
做
```
sort_on = "name"
decorated = [(dict_[sort_on], dict_) for dict_ in py]
decorated.sort()
result = [dict_ for (key, dict_) in decorated]
```
给
```
>>> result
[{'age': 10, 'name': 'Bart'}, {'age': 39, 'name': 'Homer'}]
```
更多关于Perl Schwartzian transform

在计算机科学中，Schwartzian变换是一种Perl编程习惯用法，用于提高对项目列表进行排序的效率 . 当排序实际上基于元素的某个属性（键）的排序时，这个习惯用法适用于基于比较的排序，其中计算该属性是应该执行最少次数的密集操作 . Schwartzian变换值得注意的是它不使用命名的临时数组 .
回复于 2024-04-26T19:17:18+08:00

如何按字典值对字典列表进行排序？

18 回答

相关问题