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

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

특정 키 값에 따라 사전 목록을 정렬하려면 어떻게 해야 합니까?지정:

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

「 」로 정렬했을 name , 이 합니다. : , 음음음음음 음 , , , , , , , , , 。

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

이 함수는key=

newlist = sorted(list_to_be_sorted, key=lambda d: d['name']) 

또는 함수를 직접 정의하는 대신 를 사용할 수 있습니다.

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)

import operator

키='name'을 기준으로 사전 목록을 정렬하려면:

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

키='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제제 、 하하하하원원 。

또는 더 나은 방법:

2.가 있습니다.key인수가 더 효율적이고 더 깔끔합니다.

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

operator.itemgetter다를 수

여러 키를 기준으로 목록을 정렬하려면 다음을 수행합니다.

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 패딩으로 문자열을 적절히 포맷해야 합니다).

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

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

'key'는 임의 값을 기준으로 정렬하는 데 사용되며 'itemgetter'는 각 항목의 '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 변환에 대한 자세한 내용은 다음과 같습니다.

컴퓨터 과학에서 슈워츠 변환은 항목 목록을 정렬하는 효율성을 향상시키기 위해 사용되는 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}]

Panda 패키지를 사용하는 것도 다른 방법이지만, 대규모 실행 시간은 다른 방법이 제안하는 기존 방법보다 훨씬 느립니다.

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 = [];\
[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

다음은 일반적인 대체 해결책입니다. 키와 값을 기준으로 딕트의 요소를 정렬합니다.

이 기능의 장점 - 키를 지정할 필요가 없으며 일부 사전에서 일부 키가 누락되어도 계속 작동합니다.

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)

이 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_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아래 요소를 사용합니다.하려면 , 의 키 합니다.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

이것 좀 봐.

저는 람다 필터의 광팬입니다.그러나 시간 복잡성을 고려할 경우 이 옵션을 사용하는 것이 좋습니다.

첫 번째 옵션

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 µsec/루프

# 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 µsec/루프

퍼포먼스가 걱정된다면operator.itemgetterlambda내장된 기능이 수작업 기능보다 더 빠르게 수행되기 때문입니다.itemgetter기능이 보다 약 20% 고속으로 동작하는 것 같습니다.lambda제 테스트에 근거해서요

https://wiki.python.org/moin/PythonSpeed 에서 :

마찬가지로 내장된 함수는 손으로 만든 동등한 함수에 비해 더 빨리 실행됩니다.예를 들어 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

두 기술 모두 동일한 순서로 목록을 정렬하지만(코드 블록의 마지막 문 실행에 의해 확인됨) 첫 번째 기술이 조금 더 빠릅니다.

이 답변의 코멘트 섹션에서 @Claudiu to @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': '우유소', '연령': 10},
{'name': 'HOMER', 'age': 39}]

일부 컬럼에서는 내림차순으로 정렬됩니다.CMPS 배열은 cmp 함수에 대해 글로벌하며 필드 이름을 포함하고 asc의 경우 inv == -1로 descmps 배열은 cmp 함수에 대해 글로벌합니다.

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)

언급URL : https://stackoverflow.com/questions/72899/how-do-i-sort-a-list-of-dictionaries-by-a-value-of-the-dictionary