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

问题描述：

如何根据特定键的值对字典列表进行排序？鉴于：

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

按 排序的话name应该变成：

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

解决方案 1：

该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)

解决方案 2：

import operator

按键‘name’对字典列表进行排序：

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

按键‘age’对字典列表进行排序：

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

解决方案 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 比 更容易理解operator.itemgetter，但您的理解可能会有所不同。

解决方案 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']))

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

解决方案 5：

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

解决方案 6：

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

“key” 用于按任意值排序，“itemgetter” 将该值设置为每个项目的“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：

有时我们需要使用lower()不区分大小写的排序。例如，

simpsons = [
    {"name": "Homer", "age": 39},
    {"name": "Bart", "age": 10},
    {"name": "abby", "age": 9},
]

sorted_simpsons = sorted(simpsons, key=lambda k: k["name"])
print(sorted_simpsons)
# Order is: -> Bart, Homer, abby
# [{'name': 'Bart', 'age': 10}, {'name': 'Homer', 'age': 39}, {'name': 'abby', 'age': 9}]

sorted_simpsons = sorted(simpsons, key=lambda k: k["name"].lower())
print(sorted_simpsons)
# Order is: -> abby, Bart, Homer
# [{'name': 'abby', 'age': 9}, {'name': 'Bart', 'age': 10}, {'name': 'Homer', 'age': 39}]

解决方案 10：

使用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 变换的更多信息：

在计算机科学中，施瓦茨变换是一种 Perl 编程习语，用于提高对项目列表进行排序的效率。当排序实际上基于元素的某个属性（键）的排序时，此习语适用于基于比较的排序，其中计算该属性是一项密集操作，应尽量减少执行次数。施瓦茨变换的显著特点是它不使用命名的临时数组。

解决方案 11：

您必须实现自己的比较函数，该函数将按名称键的值比较字典。请参阅PythonInfo Wiki 中的“Sorting Mini-HOW TO”

解决方案 12：

使用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 = [];\n[listOfDicts.extend(({'name':'Homer', 'age':39}, {'name':'Bart', 'age':10})) for _ in range(50000)];\nfrom operator import itemgetter;import pandas as pd;\ndf = pd.DataFrame(listOfDicts);"

setup_small = "listOfDicts = [];\nlistOfDicts.extend(({'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}));\nfrom operator import itemgetter;import pandas as pd;\ndf = 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');\nsorted_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

解决方案 13：

这是替代的通用解决方案——它按键和值对字典的元素进行排序。

它的优点是 - 不需要指定键，并且如果某些字典中缺少某些键，它仍然有效。

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)

解决方案 14：

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

解决方案 15：

假设我有一个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

看看这个。

解决方案 16：

如果您不需要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}]

解决方案 17：

如果性能是一个问题，我会使用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) 快。

lambda以下是使用vs进行排序速度的比较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

两种技术都按相同的顺序对列表进行排序（通过执行代码块中的最后一条语句进行验证），但第一种方法速度稍快一些。

解决方案 18：

最好使用dict.get()来获取排序键中要排序的值。一种更好的方法是，dict[]如果列表中的某个字典中缺少某个键，则可以使用默认值。

例如，如果一个字典列表已按排序'age'但某个字典缺失，则可以通过简单地将该字典作为默认值'age'传递给 ，将该字典推到排序列表的后面（或前面）。inf`dict.get()`

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

sorted(lst, key=lambda d: d['age'])                     # KeyError: 'age'
sorted(lst, key=itemgetter('age'))                      # KeyError: 'age'

# push dicts with missing keys to the back
sorted(lst, key=lambda d: d.get('age', float('inf')))   # OK
# push dicts with missing keys to the front
sorted(lst, key=lambda d: d.get('age', -float('inf')))  # OK

# if the value to be sorted by is a string
# '~' because it has the highest printable ASCII value
sorted(lst, key=lambda d: d.get('name', '~'))           # OK  

解决方案 19：

您可以使用键对字典列表进行排序，如下所示：

person_list = [
  {'name':'Bob','age':18}, {'name':'Kai','age':36}, {'name':'Ada','age':24} 
]
                                       # Key ↓
print(sorted(person_list, key=lambda x: x['name']))

输出：

[
  {'name':'Ada','age':24}, {'name':'Bob','age':18}, {'name':'Kai','age':36}
]

此外，您可以使用键和值列表对字典列表进行排序，如下所示：

person_list = [
  {'name':'Bob','age':18}, {'name':'Kai','age':36}, {'name':'Ada','age':24} 
]

name_list = ['Kai', 'Ada', 'Bob'] # Here
                                      # ↓ Here ↓       # Key ↓
print(sorted(person_list, key=lambda x: name_list.index(x['name'])))

输出：

[
  {'name':'Kai', 'age':36}, {'name':'Ada', 'age':24}, {'name':'Bob','age':18}
]

解决方案 20：

正如@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}]

解决方案 21：

按多列排序，其中某些列按降序排列：cmps 数组是 cmp 函数的全局数组，包含字段名称和 inv == -1（表示 desc）1（表示 asc）

def cmpfun(a, b):
    for (name, inv) in cmps:
        res = cmp(a[name], b[name])
        if res != 0:
            return res * inv
    return 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:', data
for cmps in all_cmps: print 'sort:', cmps; print sorted(data, cmpfun)

解决方案 22：

您可以使用以下内容：

lst = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age': 10}]
sorted_lst = sorted(lst, key=lambda x: x['age']) # change this to sort by a different field
print(sorted_lst)