Python 如何根据字典的值对字典列表进行排序?
我有一个字典列表,希望每个条目都按特定值排序 考虑到清单:Python 如何根据字典的值对字典列表进行排序?,python,list,sorting,dictionary,data-structures,Python,List,Sorting,Dictionary,Data Structures,我有一个字典列表,希望每个条目都按特定值排序 考虑到清单: [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}] 按名称排序时,应为: [{'name':'Bart', 'age':10}, {'name':'Homer', 'age':39}] 您必须实现自己的比较函数,该函数将通过名称键的值来比较字典。看我想你的意思是: [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]
[{'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']))
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)
“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'))
如果要按多个键对列表进行排序,可以执行以下操作:
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编程
用于提高项目列表排序效率的习惯用法。这
当排序为空时,习惯用法适用于基于比较的排序
实际上是基于
元素,其中计算该属性是一项密集操作
应至少执行几次。施瓦茨学派
转换值得注意的是,它不使用命名的临时数组
假设我有一本包含以下元素的字典
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)
使用包是另一种方法,尽管其大规模运行速度比其他人提出的更传统的方法慢得多:
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+)DICT列表的一些基准值:
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
有时我们需要使用
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}]
如果不需要
词典的原始列表
,可以使用自定义键函数使用sort()
方法就地修改它
关键功能:
def get_name(d):
""" Return the value of a key in a dictionary. """
return d["name"]
要排序的列表
:
data_one = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age': 10}]
将其分类到位:
data_one.sort(key=get_name)
如果需要原始的列表
,请调用sorted()
函数,将列表
和键函数传递给它,然后将返回的排序的列表
分配给一个新变量:
data_two = [{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age': 10}]
new_data = sorted(data_two, key=get_name)
打印data\u one
和new\u data
>>> print(data_one)
[{'name': 'Bart', 'age': 10}, {'name': 'Homer', 'age': 39}]
>>> print(new_data)
[{'name': 'Bart', 'age': 10}, {'name': 'Homer', 'age': 39}]
我一直是lambda过滤器的忠实粉丝。但是,如果考虑时间复杂度,则不是最好的选择。
第一选择
第二种选择
执行时间的快速比较
1000000个回路,最好为3个:每个回路0.736微秒
1000000个回路,最佳3个:每个回路0.438微秒
如果性能是一个问题,我会使用operator.itemgetter
而不是lambda
,因为内置函数比手工制作的函数执行得更快。根据我的测试,itemgetter
函数的执行速度似乎比lambda
快约20%
发件人:
类似地,内置函数比手工构建的等价函数运行得更快。例如,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语句进行验证),但第一种方法要快一点。使用key不仅更干净,而且效率更高。最快的方法是添加newlist.reverse()语句。否则,您可以定义一个比较,如cmp=lambda x,y:-cmp(x['name'],y['name'])。如果排序值是一个数字,您可以说:lambda k:(k['age']*-1)以获得反向排序如果您使用itemgetter(i),这也适用于元组列表
其中i
是要排序的元组元素的索引。itemgetter
接受多个参数:itemgetter(1,2,3)
是一个返回元组的函数,类似于obj[1]、obj[2]、obj[3]
,因此可以使用它进行复杂排序。是否要将名称和年龄合并?(比如在SQL中按名称、年龄排序?@monojohnny:是的,只要让键返回一个元组,key=lambda k:(k['name',k['age'])
。(或key=itemgetter('name','age')
)。元组的cmp
将
def get_name(d):
""" Return the value of a key in a dictionary. """
return d["name"]
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