我有一个字典列表，并希望每个项目都按特定值排序。
考虑清单：
[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
按 排序时name，应变为：
[{'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}]
问问题
1004632 次
18 回答
3133
该sorted()函数接受一个key=参数
newlist = sorted(list_to_be_sorted, key=lambda d: d['name'])
或者，您可以使用operator.itemgetter而不是自己定义函数
from operator import itemgetter
newlist = sorted(list_to_be_sorted, key=itemgetter('name'))
为了完整起见，添加reverse=True以降序排序
newlist = sorted(list_to_be_sorted, key=itemgetter('name'), reverse=True)
于 2008-09-16T14:39:44.273 回答
203
import operator
按 key='name' 对字典列表进行排序：
list_of_dicts.sort(key=operator.itemgetter('name'))
按 key='age' 对字典列表进行排序：
list_of_dicts.sort(key=operator.itemgetter('age'))
于 2008-09-16T15:18:14.417 回答
92
my_list = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
my_list.sort(lambda x,y : cmp(x['name'], y['name']))
my_list现在将是你想要的。
或更好：
从 Python 2.4 开始，有一个key参数更高效、更整洁：
my_list = sorted(my_list, key=lambda k: k['name'])
... lambda 是，IMO，比 更容易理解operator.itemgetter，但你的里程可能会有所不同。
于 2008-09-16T14:39:11.030 回答
63
如果要按多个键对列表进行排序，可以执行以下操作：
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']))
这是相当骇人听闻的，因为它依赖于将值转换为单个字符串表示形式进行比较，但它对包括负数在内的数字按预期工作（尽管如果您使用数字，则需要使用零填充适当地格式化您的字符串）。
于 2010-05-18T15:28:11.290 回答
40
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'])
于 2017-03-17T10:29:50.080 回答
34
import operator
a_list_of_dicts.sort(key=operator.itemgetter('name'))
'key' 用于按任意值排序，'itemgetter' 将该值设置为每个项目的 'name' 属性。
于 2008-09-16T14:43:51.550 回答
25
我猜你的意思是：
[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
这将像这样排序：
sorted(l,cmp=lambda x,y: cmp(x['name'],y['name']))
于 2008-09-16T14:36:54.953 回答
24
使用 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 变换：
在计算机科学中，Schwartzian 变换是一种 Perl 编程习惯，用于提高对项目列表进行排序的效率。当排序实际上是基于元素的某个属性（键）的排序时，此习惯用法适用于基于比较的排序，其中计算该属性是一项应执行最少次数的密集操作。Schwartzian 变换值得注意的是它不使用命名的临时数组。
于 2013-05-27T11:21:03.357 回答
23
您可以使用自定义比较函数，也可以传入一个计算自定义排序键的函数。这通常更有效，因为每个项目只计算一次键，而比较函数会被调用更多次。
你可以这样做：
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'))
于 2008-09-16T14:52:14.697 回答
21
您必须实现自己的比较函数，该函数将按名称键的值比较字典。请参阅PythonInfo Wiki 中的 Sorting Mini-HOW TO
于 2008-09-16T14:31:52.577 回答
16
有时我们需要使用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}]
于 2017-07-14T03:21:08.117 回答
13
这是另一种通用解决方案 - 它通过键和值对 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)
于 2015-01-22T17:21:17.473 回答
13
使用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
于 2016-09-01T21:21:11.583 回答
9
假设我有一本D包含以下元素的字典。要排序，只需使用 key 参数sorted传入自定义函数，如下所示：
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
看看这个。
于 2014-04-16T07:18:21.040 回答
9
如果您不需要 的原件list，您可以使用自定义键功能使用方法dictionaries就地修改它。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和 key 函数，然后将返回的 sorted 分配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}]
于 2017-12-19T17:31:30.943 回答
9
我一直是 lambda 过滤器的忠实粉丝。但是，如果考虑时间复杂度，这不是最佳选择。
第一个选项
sorted_list = sorted(list_to_sort, key= lambda x: x['name'])
# Returns list of values
第二种选择
list_to_sort.sort(key=operator.itemgetter('name'))
# Edits the list, and does not return a new list
执行时间的快速比较
# First option
python3.6 -m timeit -s "list_to_sort = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}, {'name':'Faaa', 'age':57}, {'name':'Errr', 'age':20}]" -s "sorted_l=[]" "sorted_l = sorted(list_to_sort, key=lambda e: e['name'])"
1000000 次循环，3 次中的最佳：每个循环 0.736 微秒
# Second option
python3.6 -m timeit -s "list_to_sort = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}, {'name':'Faaa', 'age':57}, {'name':'Errr', 'age':20}]" -s "sorted_l=[]" -s "import operator" "list_to_sort.sort(key=operator.itemgetter('name'))"
1000000 次循环，3 次中的最佳：每个循环 0.438 微秒
于 2019-10-01T07:24:42.577 回答
6
如果性能是一个问题，我会使用operator.itemgetter而不是lambda内置函数比手工制作的函数执行得更快。根据我的测试，该itemgetter功能的执行速度似乎快了大约 20% 。lambda
来自https://wiki.python.org/moin/PythonSpeed：
同样，内置函数比手动构建的等效函数运行得更快。例如，map(operator.add, v1, v2) 比 map(lambda x,y: x+y, v1, v2) 快。
这是使用lambdavs的排序速度的比较itemgetter。
import random
import operator
# Create a list of 100 dicts with random 8-letter names and random ages from 0 to 100.
l = [{'name': ''.join(random.choices(string.ascii_lowercase, k=8)), 'age': random.randint(0, 100)} for i in range(100)]
# Test the performance with a lambda function sorting on name
%timeit sorted(l, key=lambda x: x['name'])
13 µs ± 388 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
# Test the performance with itemgetter sorting on name
%timeit sorted(l, key=operator.itemgetter('name'))
10.7 µs ± 38.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
# Check that each technique produces the same sort order
sorted(l, key=lambda x: x['name']) == sorted(l, key=operator.itemgetter('name'))
True
两种技术都以相同的顺序对列表进行排序（通过执行代码块中的最后一条语句来验证），但第一种技术要快一些。
于 2020-01-18T16:32:05.457 回答
0
正如@Claudiu 在此答案的评论部分中向@monojohnny 指出的那样，
给出：
list_to_be_sorted = [
{'name':'Homer', 'age':39},
{'name':'Milhouse', 'age':10},
{'name':'Bart', 'age':10}
]
要按键排序字典列表'age'，'name'
（如 SQL 语句中ORDER BY age, name），您可以使用：
newlist = sorted( list_to_be_sorted, key=lambda k: (k['age'], k['name']) )
或者，同样
import operator
newlist = sorted( list_to_be_sorted, key=operator.itemgetter('age','name') )
print(newlist)
[{'name': 'Bart', 'age': 10},
{'name': 'Milhouse', 'age': 10},
{'name': 'Homer', 'age': 39}]
于 2021-09-06T09:55:16.017 回答