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

您必须实现自己的比较函数，该函数将通过名称键的值比较字典。请参阅从PythonInfo Wiki排序Mini-How TO

我猜你的意思是：

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

这将像这样排序：

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

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比operator.itemgetter更容易理解，但因人而异。

#0函数接受key=参数

newlist = sorted(list_to_be_sorted, key=lambda d: d['name'])

或者，您可以使用#0而不是自己定义函数

from operator import itemgetternewlist = sorted(list_to_be_sorted, key=itemgetter('name'))

为完整起见，添加reverse=True以降序排序

newlist = sorted(list_to_be_sorted, key=itemgetter('name'), reverse=True)

import operatora_list_of_dicts.sort(key=operator.itemgetter('name'))

“key”用于按任意值排序，“itemgetter”将该值设置为每个项目的“name”属性。

您可以使用自定义比较函数，也可以传入计算自定义排序键的函数。这通常更有效，因为每个项目只计算一次键，而比较函数会被调用更多次。

你可以这样做：

def mykey(adict): return adict['name']x = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age':10}]sorted(x, key=mykey)

但是标准库包含一个用于获取任意对象项的通用例程：itemgetter。所以试试这个：

from operator import itemgetterx = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age':10}]sorted(x, key=itemgetter('name'))

import operator

按key='name'对字典列表进行排序：

list_of_dicts.sort(key=operator.itemgetter('name'))

按key='age'对字典列表进行排序：

list_of_dicts.sort(key=operator.itemgetter('age'))

如果您想按多个键对列表进行排序，您可以执行以下操作：

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']))

这是相当粗俗的，因为它依赖于将值转换为单个字符串表示形式进行比较，但它可以按预期工作，包括负数（尽管如果您使用数字，则需要使用零paddings适当格式化字符串）。

使用Perl中的施瓦茨变换，

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编程用于提高对项目列表进行排序的效率的习语。这当排序为实际上基于某个属性（键）的顺序元素，其中计算该属性是一个密集的操作应该执行最少的次数。施瓦茨Transform值得注意的是它不使用命名的临时数组。

假设我有一个字典D，其中包含以下元素。要进行排序，只需使用sorted中的键参数来传递一个自定义函数，如下所示：

D = {'eggs': 3, 'ham': 1, 'spam': 2}def get_count(tuple):return tuple[1]
sorted(D.items(), key = get_count, reverse=True)# Orsorted(D.items(), key = lambda x: x[1], reverse=True)  # Avoiding get_count function call

检查这个。

这是另一种通用解决方案-它按键和值对字典的元素进行排序。

它的优点-不需要指定键，如果某些字典中缺少某些键，它仍然可以工作。

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)

使用熊猫包是另一种方法，尽管它的大规模运行时间比其他人提出的更传统的方法慢得多：

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 timeitt = 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

a = [{'name':'Homer', 'age':39}, ...]
# This changes the list aa.sort(key=lambda k : k['name'])
# This returns a new list (a is not modified)sorted(a, key=lambda k : k['name'])

有时我们需要使用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}]

如果您不需要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和key函数传递给它，然后将返回的排序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}]

我一直非常喜欢使用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 optionpython3.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 optionpython3.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微秒

如果性能是一个问题，我会使用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 randomimport 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 ordersorted(l, key=lambda x: x['name']) == sorted(l, key=operator.itemgetter('name'))True

这两种技术都以相同的顺序对列表进行排序（通过在代码块中执行最终语句来验证），但第一种更快。

正如@Claudiu在这个答案的评论部分中对@Monidjohnny所指出的，给出了
：

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 operatornewlist = sorted( list_to_be_sorted, key=operator.itemgetter('age','name') )

print(newlist)

[{'name'：'Bart'，'age'： 10}，
{'name'：'Milhouse'，'age'： 10}，
{'name'：'Homer'，'age'： 39}]

按多列排序，其中一些按降序排列：cmp数组对于cmp函数是全局的，包含字段名和inv==-1 for desc 1 for asc

def cmpfun(a, b):for (name, inv) in cmps:res = cmp(a[name], b[name])if res != 0:return res * invreturn 0
data = [dict(name='alice', age=10),dict(name='baruch', age=9),dict(name='alice', age=11),]
all_cmps = [[('name', 1), ('age', -1)],[('name', 1), ('age', 1)],[('name', -1), ('age', 1)],]
print 'data:', datafor cmps in all_cmps: print 'sort:', cmps; print sorted(data, cmpfun)