사전 값을 기준으로 사전 목록을 정렬하려면 어떻게합니까?

사전 목록이 있으며 각 항목을 특정 속성 값으로 정렬하고 싶습니다.

아래 배열을 고려하십시오.

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

으로 분류 할 때 name,이되어야

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

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)

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

... 람다는 IMO보다 이해하기 operator.itemgetter쉽지만 YMMV입니다.

여러 키로 목록을 정렬하려면 다음을 수행하십시오.

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

비교를 위해 값을 단일 문자열 표현으로 변환하는 데 의존하기 때문에 오히려 해킹 적이지만 음수를 포함하여 숫자에 대해 예상대로 작동합니다 (숫자를 사용하는 경우 0을 채워서 문자열을 적절하게 형식화해야 함)

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

'key'는 임의의 값으로 정렬하는 데 사용되고 'itemgetter'는 해당 값을 각 항목의 'name'속성으로 설정합니다.

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

나는 당신이 의미 한 것 같아요 :

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

이것은 다음과 같이 정렬됩니다.

sorted(l,cmp=lambda x,y: cmp(x['name'],y['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'))

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 Transform은 명명 된 임시 배열을 사용하지 않는다는 점에서 주목할 만합니다.

사전을 이름 키의 값으로 비교하는 자체 비교 기능을 구현해야합니다. PythonInfo Wiki에서 Mini-HOW TO 정렬 참조

언젠가 우리 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}]

대체 일반적인 해결책은 다음과 같습니다. 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)

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

원본 원본 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)

original이 필요한 경우 이를 전달 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}]

D아래에 요소 가있는 사전이 있다고 가정 해 봅시다 . 정렬하려면 키 인수를 정렬하여 다음과 같이 사용자 정의 함수를 전달하십시오.

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

이것을 확인하십시오 .

나는 람다 / 필터의 큰 팬 이었지만 시간 복잡성을 고려한다면 최선의 선택이 아닙니다.

첫 번째 옵션

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, 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 : 3 : 36 루프 당 루프

# 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 : 3 당 최고 : 0.438 usec

성능이 문제가된다면 내장 함수가 수작업으로 만든 함수보다 더 빠르게 수행하기 때문에 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)보다 빠릅니다.

다음은 lambdavs를 사용하여 정렬 속도를 비교 한 것 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 same sort order
sorted(l, key=lambda x: x['name']) == sorted(l, key=operator.itemgetter('name'))
True

두 기술 모두 목록을 동일한 순서로 정렬합니다 (코드 블록에서 최종 명령문을 실행하여 확인 됨).

다음 코드를 사용할 수 있습니다

sorted_dct = sorted(dct_name.items(), key = lambda x : x[1])