请考虑以下列表：
[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
按
name排序时，它应该变成：[{'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}]
#1 楼
使用键而不是cmp看起来更干净： newlist = sorted(list_to_be_sorted, key=lambda k: k['name'])
或作为JFSebastian和其他建议，
from operator import itemgetter
newlist = sorted(list_to_be_sorted, key=itemgetter('name'))
为了完整性（如fitzgeraldsteele的评论所指出），请添加
reverse=True排序降序 newlist = sorted(l, key=itemgetter('name'), reverse=True)
评论
使用密钥不仅更清洁，而且效率更高。
– jfs
08/09/16在15:03
最快的方法是添加一个newlist.reverse（）语句。否则，您可以定义类似cmp = lambda x，y的比较：-cmp（x ['name']，y ['name']）。
–马里奥F
09-10-13在7:14
如果排序值是一个数字，您可以说：lambda k：（k ['age'] * -1）以获得反向排序
– Philluminati
2009年11月20日15:16
如果您使用itemgetter（i），其中i是要排序的元组元素的索引，则这也适用于元组列表。
–radicand
2012年7月11日在23:14
itemgetter接受多个参数：itemgetter（1,2,3）是一个返回obj [1]，obj [2]，obj [3]之类的元组的函数，因此您可以使用它进行复杂的排序。
–巴库留
2012年9月7日于17:59
#2 楼
import operator
按键='name'对字典列表进行排序：
list_of_dicts.sort(key=operator.itemgetter('name'))
按key ='age对字典列表进行排序'：
list_of_dicts.sort(key=operator.itemgetter('age'))
评论
反正名称和年龄相结合？ （例如在SQL ORDER BY名称中，age？）
– monojohnny
2010-2-17在13:10
@monojohnny：是的，只是让键返回一个元组，key = lambda k：（k ['name']，k ['age']）。 （或key = itemgetter（'name'，'age'））。元组的cmp将依次比较每个元素。血腥的辉煌。
– Claudiu
2013年9月4日在22:21
在文档（docs.python.org/2/tutorial/datastructures.html）中，未描述list.sort（）的可选key参数。知道在哪里找到它吗？
– TTT
2014年2月21日15:21
@TTT：有关列表和朋友，请参见图书馆文档。
–凯文
15年2月19日在14:56
#3 楼
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更容易理解，但您的行驶里程可能会有所不同。评论
如果密钥未知并且不断变化怎么办？我的意思是仅包含一个密钥和值的字典列表，但是随着密钥不断变化，无法定义密钥和值。
–山姆
12月1日14:51
#4 楼
如果要按多个键对列表进行排序，则可以执行以下操作：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']))
有点黑，因为它依赖于将值转换为单个字符串表示形式进行比较，但是它的工作原理是期望用于包括负数在内的数字（尽管如果使用数字，您将需要使用零填充来适当格式化字符串）。
评论
使用稳定的timsort进行排序，您可以多次调用sorted以对多个条件进行排序
– njzk2
13年5月29日在13:41
njzk2的评论对我尚不明确，因此我发现了以下内容。您可以按照njzk2的建议进行两次排序，也可以在顶部答案中将多个参数传递给operator.itemgetter。链接：stackoverflow.com/questions/5212870/…
–永久性断裂
13年8月23日在21:05
无需转换为字符串。只需返回一个元组作为键。
–温斯顿·埃韦特（Winston Ewert）
2013年12月15日下午4:55
进行多次排序是没有黑客的最简单的通用解决方案：stackoverflow.com/a/29849371/1805397
– wouter bolsterlee
15年4月24日在13:59
这对我的用例比itemgetter更好。
– Binoy S Kumar
6月19日21:25
#5 楼
import operator
a_list_of_dicts.sort(key=operator.itemgetter('name'))
'key'用于按任意值排序，'itemgetter'将该值设置为每个项目的'name'属性。
#6 楼
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'])
#7 楼
我想你是说：[{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
这样的排序方式是：
sorted(l,cmp=lambda x,y: cmp(x['name'],y['name']))
#8 楼
您可以使用自定义比较函数，也可以传入一个计算自定义排序键的函数。通常这样做效率更高，因为每个项仅计算一次密钥，而比较函数将被调用多次。您可以这样操作：
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'))
#9 楼
使用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
转换值得注意，因为它不使用命名的临时数组。
评论
Python自2.4（即2004年）开始支持.sort的key =。它在C排序代码内进行Schwartzian转换；因此，此方法仅在Pythons 2.0-2.3上有用。所有这些都超过12岁。
–安蒂·哈帕拉（Antti Haapala）
15年2月15日在20:11
#10 楼
您必须实现自己的比较功能，该功能将通过名称键的值比较字典。请参阅从PythonInfo Wiki对Mini-HOW TO进行排序评论
这过于依赖链接。您能否提供更完整的答案？
– Peter Mortensen
8月14日20:51
其他贡献者也已经提供了适当的答案。随时保留链接或删除答案。
–马泰
8月17日4:25
#11 楼
有时我们需要使用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}]
评论
为什么在这种情况下我们需要使用lower（）？
– Peter Mortensen
8月14日20:52
#12 楼
这是另一种通用解决方案-通过键和值对字典中的元素进行排序。它的优点-无需指定键，并且如果某些词典中缺少某些键，该方法仍然可以使用。
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)
评论
“将字典的元素按键和值排序”是什么意思？用什么方式排序？价值从何而来？
– Peter Mortensen
8月14日20:54
#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）字典列表：
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
评论
我运行了您的代码，并在timeit.Timer参数中发现了大方法熊猫的错误：您在应为“ setup_large”的地方指定“ setup_small”。更改该arg导致程序无法完成运行，而我在5分钟后将其停止。当我使用“ timeit（1）”运行它时，大方法熊猫在7.3秒内完成，比LC或LC2差得多。
–clp2
16-11-7在4:05
您说得对，这对我来说是个疏忽。我不再推荐用于大型情况！我已经对答案进行了编辑，以仅允许它成为可能，用例仍在辩论中。
–艾比·索布（Abby Sobh）
16年11月8日在22:58
#14 楼
假设我有一个包含以下元素的字典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
检查一下。
#15 楼
如果不需要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和键函数，然后将返回的已排序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}]
#16 楼
我一直是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微秒
1000000个循环，每个循环最好3个：0.438微秒
#17 楼
如果需要考虑性能，我将使用operator.itemgetter而不是lambda，因为内置函数的执行速度比手工制作的函数快。根据我的测试，itemgetter函数的执行速度似乎比lambda快20％。从https://wiki.python.org/moin/PythonSpeed：
类似，内置函数运行比手工制作的同类产品更快。例如，map（operator.add，v1，v2）比map（lambda x，y：x + y，v1，v2）更快。
这里是使用
lambda与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
两种技术都以相同的顺序对列表进行排序（通过执行代码块中的final语句进行验证），但是第一个要快一些。
评论
阅读答案并查看operator.itemgetter。我可以在同一过程中对多个值进行排序吗（例如，我们有[{'name'：'Bart'，'age'：10，'note'：3}，{'name'：'Homer'，'age' ：10，'note'：2}，{'name'：'Vasile'，'age'：20，'note'：3}]并使用：来自运营商import itemgetter newlist = sorted（old_list，key = itemgetter（ -'note'，'name'）编辑：已测试，并且可以正常工作，但我不知道如何制作注释DESC和名称ASC。