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

masi 1722 python sorting dictionary list data-structures

我有一个字典列表,并希望每个项目按特定的属性值排序.

考虑下面的数组,

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

排序时name,应该成为

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

Mario F.. 2267

使用密钥而不是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)

  • `itemgetter`接受多个参数:`itemgetter(1,2,3)`是一个返回像`obj [1],obj [2],obj [3]`这样的元组的函数,所以你可以用它来做复杂的事情. (38认同)
  • 使用键不仅更干净,而且更有效. (25认同)
  • 最快的方法是添加newlist.reverse()语句.否则,您可以定义比较,如cmp = lambda x,y: - cmp(x ['name'],y ['name']). (4认同)
  • 如果排序值是一个数字,您可以说:lambda k:(k ['age'] * -1)以获得反向排序 (2认同)

小智.. 143

import operator

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

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

按键='年龄'对字典列表进行排序:

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

  • @monojohnny:是的,只需让键返回一个元组,`key = lambda k:(k ['name'],k ['age'])`.(或`key = itemgetter('name','age')`).元组的`cmp`将依次比较每个元素.它真是太棒了. (26认同)
  • 无论如何要结合名称和年龄?(比如SQL ORDER BY名称,年龄?) (9认同)
  • @TTT:请参阅[library documentation](https://docs.python.org/2/library/stdtypes.html#mutable-sequence-types)中的`list`和朋友。 (2认同)

pjz.. 49

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

my_list.sort(lambda x,y : cmp(x['name'], y['name']))

my_list 现在将成为你想要的.

(3年后)编辑补充:

key论点更有效,更整洁.现在更好的答案如下:

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

...... lambo,IMO,比operator.itemgetterYMMV 更容易理解.


Dologan.. 46

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

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

这是相当hackish,因为它依赖于将值转换为单个字符串表示形式进行比较,但它对于包含负数的数字的预期工作(尽管如果使用数字,您将需要使用零填充来适当地格式化字符串)

  • 无需转换为字符串.只需返回一个元组作为键. (14认同)
  • 使用稳定的timsort进行排序,您可以多次调用sorted以对多个条件进行排序 (2认同)

efotinis.. 28

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

'key'用于按任意值排序,'itemgetter'将该值设置为每个项目的'name'属性.


forzagreen.. 21

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


Bartosz Rada.. 19

我想你的意思是:

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

这将按如下方式排序:

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


小智.. 17

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

你可以这样做:

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


kiriloff.. 17

使用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变换值得注意的是它不使用命名的临时数组.

  • 从2.4开始,Python支持`key =`for..sort`,即2004年,它在C中的排序代码中进行Schwartzian变换; 因此这种方法仅对Pythons 2.0-2.3有用.所有这些都超过12年. (8认同)

Matej.. 16

您必须实现自己的比较函数,它将按名称键的值比较字典.请参阅从PythonInfo Wiki中排序Mini-HOW TO


uingtea.. 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}]


vvladymyrov.. 10

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


abby sobh.. 9

使用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

  • 我运行你的代码并在timeit.Timer args中发现了大方法熊猫的错误​​:你指定"setup_small",它应该是"setup_large".改变那个arg导致程序运行而没有完成,我在超过5分钟后停止了它.当我用"timeit(1)"运行时,大方法熊猫在7.3秒内完成,比LC或LC2差很多. (3认同)

Shank_Transf.. 5

让我说我是一个字典D与下面的元素.要排序只使用sort中的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

https://wiki.python.org/moin/HowTo/Sorting/#Key_Functions


Srisaila.. 5

如果你不需要原来listdictionaries,你可以用修改就地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_onenew_data

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