Python 如何根据字典的值对字典列表进行排序？

我有一个字典列表，希望每个条目都按特定值排序

考虑到清单：

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

按

名称

排序时，应为：

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

---

您必须实现自己的比较函数，该函数将通过名称键的值来比较字典。请参见

您必须实现自己的比较功能，通过名称键的值来比较字典。看

我想你的意思是：

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

这将按如下方式排序：

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

我猜你的意思是：

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

这将按如下方式排序：

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

my_list

现在就是您想要的了

或者更好：

自Python 2.4以来，有一个

键

参数更高效、更整洁：

my_list = sorted(my_list, key=lambda k: k['name'])

…依我看，lambda比operator.itemgetter更容易理解，但您的里程可能会有所不同

my_list

现在就是您想要的了

或者更好：

自Python 2.4以来，有一个

键

参数更高效、更整洁：

my_list = sorted(my_list, key=lambda k: k['name'])

…依我看，lambda比operator.itemgetter更容易理解，但您的里程数可能会有所不同。

该函数采用

键=

参数

newlist=sorted（list-to-be-sorted，key=lambda k:k['name']）

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

从操作员导入itemgetter
newlist=sorted（list-to-be-sorted，key=itemgetter（'name'））

为完整起见，请添加

reverse=True

以按降序排序

newlist=sorted（l，key=itemgetter（'name'），reverse=True）

该函数采用

键=

参数

newlist=sorted（list-to-be-sorted，key=lambda k:k['name']）

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

从操作员导入itemgetter
newlist=sorted（list-to-be-sorted，key=itemgetter（'name'））

为完整起见，请添加

reverse=True

以按降序排序

newlist=sorted（l，key=itemgetter（'name'），reverse=True）

“key”用于按任意值排序，“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 itemgetter
x = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age':10}]
sorted(x, 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 itemgetter
x = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age':10}]
sorted(x, key=itemgetter('name'))

要按key='name'对词典列表排序，请执行以下操作：

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

要按key='age'对词典列表排序，请执行以下操作：

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

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

---

它相当粗糙，因为它依赖于将值转换为单个字符串表示进行比较，但对于包括负数在内的数字，它的工作原理与预期的一样（尽管如果使用数字，则需要使用零填充来适当格式化字符串）。

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

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

它相当粗糙，因为它依赖于将值转换为单个字符串表示进行比较，但对于包括负数在内的数字，它的工作原理与预期的一样（尽管如果使用数字，则需要使用零填充来适当格式化字符串）。

使用来自Perl的

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

做

给予

有关Perl-Schwartzian转换的更多信息：

在计算机科学中，Schwartzian变换是一种Perl编程 用于提高项目列表排序效率的习惯用法。这 当排序为空时，习惯用法适用于基于比较的排序 实际上是基于 元素，其中计算该属性是一项密集操作 应至少执行几次。施瓦茨学派 转换值得注意的是，它不使用命名的临时数组

使用来自Perl的

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

做

给予

有关Perl-Schwartzian转换的更多信息：

在计算机科学中，Schwartzian变换是一种Perl编程 用于提高项目列表排序效率的习惯用法。这 当排序为空时，习惯用法适用于基于比较的排序 实际上是基于 元素，其中计算该属性是一项密集操作 应至少执行几次。施瓦茨学派 转换值得注意的是，它不使用命名的临时数组

---

假设我有一本包含以下元素的字典

D

。要排序，只需使用

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

---

退房。

假设我有一本包含以下元素的字典

D

。要排序，只需使用

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

---

查看。

这里是另一种通用解决方案-它按键和值对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)

这是

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

data_one.sort(key=get_name)

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

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

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

# 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'))"

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