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

질문자 :Gern Blanston

이 질문의 답변은 커뮤니티의 노력 입니다. 이 게시물을 개선하려면 기존 답변을 수정하세요. 현재 새로운 답변이나 상호 작용을 허용하지 않습니다.

데이터베이스의 두 필드(문자열 필드와 숫자 필드)에서 읽은 값 사전이 있습니다. 문자열 필드는 고유하므로 사전의 키입니다.

키를 기준으로 정렬할 수 있지만 값을 기준으로 정렬하려면 어떻게 해야 합니까?

참고: 여기에서 스택 오버플로 질문을 읽었습니다 . 사전 값으로 사전 목록을 정렬하려면 어떻게 합니까? 그리고 아마도 사전 목록을 갖도록 내 코드를 변경할 수 있지만 사전 목록이 실제로 필요하지 않기 때문에 오름차순 또는 내림차순으로 정렬하는 더 간단한 솔루션이 있는지 알고 싶었습니다.

파이썬 3.7 이상 또는 CPython 3.6

Dict는 Python 3.7 이상에서 삽입 순서를 유지합니다. CPython 3.6에서도 동일하지만 구현 세부 사항 입니다.

 >>> x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0} >>> {k: v for k, v in sorted(x.items(), key=lambda item: item[1])} {0: 0, 2: 1, 1: 2, 4: 3, 3: 4}

또는

 >>> dict(sorted(x.items(), key=lambda item: item[1])) {0: 0, 2: 1, 1: 2, 4: 3, 3: 4}

이전 파이썬

사전을 정렬하는 것은 불가능하며 정렬된 사전의 표현을 얻기 위해서만 가능합니다. 사전은 본질적으로 순서가 없지만 목록 및 튜플과 같은 다른 유형은 그렇지 않습니다. 따라서 정렬된 값을 나타내기 위해 정렬된 데이터 유형이 필요하며, 이는 아마도 튜플 목록일 것입니다.

예를 들어,

 import operator x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0} sorted_x = sorted(x.items(), key=operator.itemgetter(1))

sorted_x 는 각 튜플의 두 번째 요소로 정렬된 튜플 목록입니다. dict(sorted_x) == x .

값 대신 키를 기준으로 정렬하려는 경우:

 import operator x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0} sorted_x = sorted(x.items(), key=operator.itemgetter(0))

Python3에서는 압축 풀기가 허용되지 않으므로 사용할 수 있습니다.

 x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0} sorted_x = sorted(x.items(), key=lambda kv: kv[1])

출력을 사전으로 원하면 collections.OrderedDict 를 사용할 수 있습니다.

 import collections sorted_dict = collections.OrderedDict(sorted_x)

Devin Jeanpierre

다음과 같이 간단합니다. sorted(dict1, key=dict1.get)

음, 실제로 "사전 값으로 정렬"하는 것이 가능합니다. 최근에 나는 Code Golf(스택 오버플로 질문 코드 골프: 단어 빈도 차트 )에서 그렇게 해야 했습니다. 요약하자면 문제는 다음과 같은 종류였습니다. 텍스트가 주어지면 각 단어가 얼마나 자주 나타나는지 세고 빈도가 감소하는 순서로 정렬된 상위 단어 목록을 표시합니다.

단어를 키로 사용하고 각 단어의 발생 횟수를 값으로 사용하여 사전을 구성하면 다음과 같이 단순화됩니다.

 from collections import defaultdict d = defaultdict(int) for w in text.split(): d[w] += 1

sorted(d, key=d.get) 를 사용하여 사용 빈도에 따라 정렬된 단어 목록을 얻을 수 있습니다. 정렬은 단어 발생 횟수를 정렬 키로 사용하여 사전 키를 반복합니다.

 for w in sorted(d, key=d.get, reverse=True): print(w, d[w])

나는 사람들이 "나는 키로 쉽게 사전을 정렬할 수 있지만 값으로 정렬하는 방법"이 무엇을 의미하는지 설명하기 위해 이 자세한 설명을 작성합니다. 그리고 원래 게시물은 그러한 문제를 해결하려고 했던 것 같습니다. 그리고 해결책은 위와 같이 값을 기반으로 일종의 키 목록을 수행하는 것입니다.

Nas Banov

다음을 사용할 수 있습니다.

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

이렇게 하면 사전 내의 각 항목 값을 기준으로 사전을 가장 작은 것에서 가장 큰 것 순으로 정렬합니다.

내림차순으로 정렬하려면 reverse=True 추가하면 됩니다.

 sorted(d.items(), key=lambda x: x[1], reverse=True)

입력:

 d = {'one':1,'three':3,'five':5,'two':2,'four':4} a = sorted(d.items(), key=lambda x: x[1]) print(a)

산출:

 [('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]

Mark

사전은 정렬할 수 없지만 사전에서 정렬된 목록을 작성할 수 있습니다.

dict 값의 정렬된 목록:

 sorted(d.values())

값으로 정렬된 (키, 값) 쌍 목록:

 from operator import itemgetter sorted(d.items(), key=itemgetter(1))

Roberto Bonvallet

최근 Python 2.7에는 항목이 추가된 순서를 기억하는 새로운 OrderedDict 유형이 있습니다.

 >>> d = {"third": 3, "first": 1, "fourth": 4, "second": 2} >>> for k, v in d.items(): ... print "%s: %s" % (k, v) ... second: 2 fourth: 4 third: 3 first: 1 >>> d {'second': 2, 'fourth': 4, 'third': 3, 'first': 1}

값을 기준으로 정렬하여 원본에서 새로운 순서의 사전을 만들려면:

 >>> from collections import OrderedDict >>> d_sorted_by_value = OrderedDict(sorted(d.items(), key=lambda x: x[1]))

OrderedDict는 일반 딕셔너리처럼 작동합니다.

 >>> for k, v in d_sorted_by_value.items(): ... print "%s: %s" % (k, v) ... first: 1 second: 2 third: 3 fourth: 4 >>> d_sorted_by_value OrderedDict([('first': 1), ('second': 2), ('third': 3), ('fourth': 4)])

mykhal

업데이트: Python 3.5를 사용하여 2015년 12월 5일

허용된 답변이 유용하다는 것을 알았지만 표준 라이브러리 컬렉션 모듈의 OrderedDict를 실행 가능하고 현대적인 대안으로 참조하도록 업데이트되지 않았다는 사실에도 놀랐습니다.

 from operator import itemgetter from collections import OrderedDict x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0} sorted_x = OrderedDict(sorted(x.items(), key=itemgetter(1))) # OrderedDict([(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)])

공식 OrderedDict 문서도 매우 유사한 예를 제공하지만 정렬 기능에 람다를 사용합니다.

 # regular unsorted dictionary d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2} # dictionary sorted by value OrderedDict(sorted(d.items(), key=lambda t: t[1])) # OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

arcseldon

Hank Gay의 답변 과 거의 동일합니다.

 sorted([(value,key) for (key,value) in mydict.items()])

또는 John Fouhy가 제안한 대로 약간 최적화되었습니다.

 sorted((value,key) for (key,value) in mydict.items())

user26294

namedtuple 을 사용하는 것은 종종 매우 편리할 수 있습니다. 예를 들어 '이름'을 키로 사용하고 '점수'를 값으로 사용하는 사전이 있고 '점수'를 기준으로 정렬하려고 합니다.

 import collections Player = collections.namedtuple('Player', 'score name') d = {'John':5, 'Alex':10, 'Richard': 7}

가장 낮은 점수부터 먼저 정렬:

 worst = sorted(Player(v,k) for (k,v) in d.items())

가장 높은 점수를 먼저 정렬:

 best = sorted([Player(v,k) for (k,v) in d.items()], reverse=True)

이제 다음과 같이 매우 파이썬적으로 두 번째로 우수한 플레이어(인덱스=1)의 이름과 점수를 얻을 수 있습니다.

 player = best[1] player.name 'Richard' player.score 7

Remi

Python 3.6 부터 내장 dict가 주문됩니다.

좋은 소식입니다. 따라서 고유한 문자열 ID를 키로 사용하고 숫자 값을 내장 Python v3.6+ 사전에 값으로 사용하여 데이터베이스에서 검색된 쌍을 매핑하는 OP의 원래 사용 사례는 이제 삽입 순서를 준수해야 합니다.

다음과 같은 데이터베이스 쿼리의 결과로 생성된 두 개의 열 테이블 표현식을 말합니다.

 SELECT a_key, a_value FROM a_table ORDER BY a_value;

두 개의 Python 튜플, k_seq 및 v_seq(숫자 인덱스로 정렬되고 물론 동일한 길이로 정렬됨)에 저장됩니다.

 k_seq = ('foo', 'bar', 'baz') v_seq = (0, 1, 42) ordered_map = dict(zip(k_seq, v_seq))

나중에 다음과 같이 출력할 수 있습니다.

 for k, v in ordered_map.items(): print(k, v)

이 경우에 양보합니다(새로운 Python 3.6+ 내장 딕셔너리의 경우!):

 foo 0 bar 1 baz 42

v 값당 동일한 순서로

내 컴퓨터의 Python 3.5 설치에서 현재 다음을 생성합니다.

 bar 1 foo 0 baz 42

세부:

Raymond Hettinger가 2012년에 제안한 대로( "더 빠른 반복이 포함된 더 컴팩트한 사전"이라는 제목의 python-dev 메일 참조) 현재(2016년에) Victor Stinner가 "Python 3.6 dict이"라는 제목의 python-dev에 메일로 발표되었습니다. Python 3.6에서 문제 27350 "Compact and Ordered dict" 의 수정/구현으로 인해 키워드가 정렬되고 키워드가 정렬 됩니다. 이제 내장 딕셔너리를 사용하여 삽입 순서를 유지할 수 있습니다!!

이것이 첫 번째 단계로 얇은 레이어 OrderedDict 구현으로 이어지기를 바랍니다. @JimFasarakis-Hilliard가 지적했듯이 일부는 향후 OrderedDict 유형의 사용 사례도 볼 수 있습니다. 나는 파이썬 커뮤니티 전체가 이것이 시간의 시험을 견딜 수 있는지, 그리고 다음 단계가 무엇인지 신중하게 검사할 것이라고 생각합니다.

다음의 안정적인 순서로 열린 가능성을 놓치지 않기 위해 코딩 습관을 재고할 시간입니다.

• 키워드 인수 및
• (중간) 딕셔너리 저장

첫 번째는 경우에 따라 함수 및 메서드 구현 시 디스패치를 쉽게 해주기 때문입니다.

두 번째는 처리 파이프라인에서 중간 저장소로 dict 를 더 쉽게 사용하도록 권장하기 때문입니다.

Raymond Hettinger는 San Francisco Python Meetup Group 프레젠테이션 2016-DEC-08에서 " The Tech Behind Python 3.6 Dictionaries "를 설명하는 문서를 친절하게 제공했습니다.

그리고 아마도 꽤 많은 스택 오버플로 장식 질문 및 답변 페이지가 이 정보의 변형을 받을 것이며 많은 고품질 답변에도 버전별 업데이트가 필요할 것입니다.

주의 사항 Emptor(하지만 아래 업데이트 2017-12-15 참조):

@ajcr은 "이 새로운 구현의 순서 보존 측면은 구현 세부 사항으로 간주되며 의존해서는 안 됩니다."라고 적법하게 언급했습니다. ( whatsnew36 에서 ) 니트 따기가 아니라 인용이 약간 비관적으로 잘렸습니다 ;-). "(앞으로 변경될 수 있지만 현재 및 미래의 모든 Python 구현에 대한 순서 보존 의미론을 명령하기 위해 언어 사양을 변경하기 전에 몇 가지 릴리스의 언어에서 이 새로운 dict 구현을 갖는 것이 바람직합니다. 임의의 반복 순서가 여전히 유효한 언어의 이전 버전(예: Python 3.5)과의 하위 호환성을 유지하는 데 도움이 됩니다."

따라서 일부 인간 언어(예: 독일어)에서와 같이 사용법이 언어를 형성하고 이제 ... whatsnew36 에서 의지가 선언되었습니다.

업데이트 2017-12-15:

python-dev list 에 보낸 메일 에서 Guido van Rossum은 다음과 같이 선언했습니다.

그렇게 만들어. "Dict는 삽입 순서를 유지합니다"가 판결입니다. 감사 해요!

따라서 dict 삽입 순서의 버전 3.6 CPython 부작용은 이제 언어 사양의 일부가 되었습니다(더 이상 구현 세부 사항이 아님). collections.OrderedDict 대한 몇 가지 구별되는 디자인 목표를 표면화했습니다. Raymond Hettinger가 토론 중에 상기시켰습니다.

Dilettant

나는 같은 문제가 있었고 다음과 같이 해결했습니다.

 WantedOutput = sorted(MyDict, key=lambda x : MyDict[x])

("딕셔너리를 정렬할 수 없습니다"라고 답한 사람은 질문을 읽지 않았습니다! 실제로 "키를 기준으로 정렬할 수 있지만 값을 기준으로 정렬하려면 어떻게 해야 하나요?" 키 값에 따라 정렬됩니다.)

순서가 잘 정의되어 있지 않다는 점에 유의하십시오(같은 값을 가진 키는 출력 목록에서 임의의 순서로 표시됩니다).

jimifiki

값이 숫자인 경우 컬렉션의 Counter 를 사용할 수도 있습니다.

 from collections import Counter x = {'hello': 1, 'python': 5, 'world': 3} c = Counter(x) print(c.most_common()) >> [('python', 5), ('world', 3), ('hello', 1)]

Ivan Sas

Python 2.7에서는 다음을 수행하십시오.

 from collections import OrderedDict # regular unsorted dictionary d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2} # dictionary sorted by key OrderedDict(sorted(d.items(), key=lambda t: t[0])) OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)]) # dictionary sorted by value OrderedDict(sorted(d.items(), key=lambda t: t[1])) OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

복사-붙여넣기: http://docs.python.org/dev/library/collections.html#ordereddict-examples-and-recipes

즐기다 ;-)

sweetdream

이것은 코드입니다:

 import operator origin_list = [ {"name": "foo", "rank": 0, "rofl": 20000}, {"name": "Silly", "rank": 15, "rofl": 1000}, {"name": "Baa", "rank": 300, "rofl": 20}, {"name": "Zoo", "rank": 10, "rofl": 200}, {"name": "Penguin", "rank": -1, "rofl": 10000} ] print ">> Original >>" for foo in origin_list: print foo print "\n>> Rofl sort >>" for foo in sorted(origin_list, key=operator.itemgetter("rofl")): print foo print "\n>> Rank sort >>" for foo in sorted(origin_list, key=operator.itemgetter("rank")): print foo

결과는 다음과 같습니다.

원래의

 {'name': 'foo', 'rank': 0, 'rofl': 20000} {'name': 'Silly', 'rank': 15, 'rofl': 1000} {'name': 'Baa', 'rank': 300, 'rofl': 20} {'name': 'Zoo', 'rank': 10, 'rofl': 200} {'name': 'Penguin', 'rank': -1, 'rofl': 10000}

로플

 {'name': 'Baa', 'rank': 300, 'rofl': 20} {'name': 'Zoo', 'rank': 10, 'rofl': 200} {'name': 'Silly', 'rank': 15, 'rofl': 1000} {'name': 'Penguin', 'rank': -1, 'rofl': 10000} {'name': 'foo', 'rank': 0, 'rofl': 20000}

계급

 {'name': 'Penguin', 'rank': -1, 'rofl': 10000} {'name': 'foo', 'rank': 0, 'rofl': 20000} {'name': 'Zoo', 'rank': 10, 'rofl': 200} {'name': 'Silly', 'rank': 15, 'rofl': 1000} {'name': 'Baa', 'rank': 300, 'rofl': 20}

PedroMorgan

다음 방법을 시도하십시오. 다음 데이터를 사용하여 mydict라는 사전을 정의해 보겠습니다.

 mydict = {'carl':40, 'alan':2, 'bob':1, 'danny':3}

사전을 키로 정렬하려면 다음과 같이 할 수 있습니다.

 for key in sorted(mydict.iterkeys()): print "%s: %s" % (key, mydict[key])

그러면 다음 출력이 반환되어야 합니다.

 alan: 2 bob: 1 carl: 40 danny: 3

반면에 값으로 사전을 정렬하려면(질문에서 묻는 것처럼) 다음을 수행할 수 있습니다.

 for key, value in sorted(mydict.iteritems(), key=lambda (k,v): (v,k)): print "%s: %s" % (key, value)

이 명령의 결과(값으로 사전 정렬)는 다음을 반환해야 합니다.

 bob: 1 alan: 2 danny: 3 carl: 40

Nathaniel Payne

Python 3.6부터 dict 객체는 이제 삽입 순서로 정렬됩니다. 공식적으로 Python 3.7의 사양에 있습니다.

 >>> words = {"python": 2, "blah": 4, "alice": 3} >>> dict(sorted(words.items(), key=lambda x: x[1])) {'python': 2, 'alice': 3, 'blah': 4}

OrderedDict 를 사용해야 했습니다.

Python 3.7 문서 는 다음과 같이 말합니다.

버전 3.7에서 변경: 사전 순서는 삽입 순서로 보장됩니다. 이 동작은 3.6부터 CPython의 구현 세부 사항이었습니다.

Maxime Chéramy

"역 인덱스"를 만들 수도 있습니다.

 from collections import defaultdict inverse= defaultdict( list ) for k, v in originalDict.items(): inverse[v].append( k )

이제 역함수에 값이 있습니다. 각 값에는 적용 가능한 키 목록이 있습니다.

 for k in sorted(inverse): print k, inverse[k]

S.Lott

collections.Counter 를 사용할 수 있습니다. 이것은 숫자 값과 숫자가 아닌 값 모두에서 작동합니다.

 >>> x = {1: 2, 3: 4, 4:3, 2:1, 0:0} >>> from collections import Counter >>> #To sort in reverse order >>> Counter(x).most_common() [(3, 4), (4, 3), (1, 2), (2, 1), (0, 0)] >>> #To sort in ascending order >>> Counter(x).most_common()[::-1] [(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)] >>> #To get a dictionary sorted by values >>> from collections import OrderedDict >>> OrderedDict(Counter(x).most_common()[::-1]) OrderedDict([(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)])

Abhijit

키에 전달할 수 있는 사용자 정의 함수를 사용할 수도 있습니다.

 def dict_val(x): return x[1] x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0} sorted_x = sorted(x.items(), key=dict_val)

Vishwanath Rawat

값에 따라 영구적으로 정렬되는 사전인 건너뛰기 사전 을 사용할 수 있습니다.

 >>> data = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0} >>> SkipDict(data) {0: 0.0, 2: 1.0, 1: 2.0, 4: 3.0, 3: 4.0}

keys() , values() 또는 items() 을 사용하는 경우 값을 기준으로 정렬된 순서로 반복합니다.

건너뛰기 목록 데이터 구조를 사용하여 구현됩니다.

malthe

from django.utils.datastructures import SortedDict def sortedDictByKey(self,data): """Sorted dictionary order by key""" sortedDict = SortedDict() if data: if isinstance(data, dict): sortedKey = sorted(data.keys()) for k in sortedKey: sortedDict[k] = data[k] return sortedDict

Argun

물론 일반 Python 사전은 원래 순서를 유지하지 않기 때문에 OrderedDict 를 사용해야 함을 기억하십시오.

 from collections import OrderedDict a = OrderedDict(sorted(originalDict.items(), key=lambda x: x[1]))

---

Python 2.7 이상이 없는 경우 가장 좋은 방법은 생성기 함수의 값을 반복하는 것입니다. (AN 있습니다 OrderedDict 2.4 및 2.6은 여기에 있지만,

) 나는 그것이 얼마나 잘 작동하는지 모른다

그리고

b) 당연히 다운받아 설치해야 합니다. 관리자 권한이 없는 경우 옵션이 없을 수 있습니다.)

---

 def gen(originalDict): for x, y in sorted(zip(originalDict.keys(), originalDict.values()), key=lambda z: z[1]): yield (x, y) #Yields as a tuple with (key, value). You can iterate with conditional clauses to get what you want. for bleh, meh in gen(myDict): if bleh == "foo": print(myDict[bleh])

---

모든 값을 인쇄할 수도 있습니다.

 for bleh, meh in gen(myDict): print(bleh, meh)

Python 3.0 이상을 사용하지 않는 경우 인쇄 후 괄호를 제거하는 것을 잊지 마십시오.

ytpillai

Dilettant가 지적했듯이 Python 3.6은 이제 순서를 유지합니다 ! 나는 iterable(tuple, list, dict)의 정렬을 용이하게 하는 내가 작성한 함수를 공유할 것이라고 생각했습니다. 후자의 경우 키 또는 값을 기준으로 정렬할 수 있으며 숫자 비교를 고려할 수 있습니다. >= 3.6에만 해당!

예를 들어 문자열과 int를 포함하는 iterable에서 sorted를 사용하려고 하면 sorted()가 실패합니다. 물론 str()을 사용하여 문자열 비교를 강제할 수 있습니다. 12 20 보다 작은 실제 숫자 비교를 수행하려고 합니다(문자열 비교에서는 그렇지 않음). 그래서 나는 다음을 생각해 냈습니다. 명시적 숫자 비교를 원할 때 모든 값을 부동 소수점으로 변환하려고 시도하여 명시적 숫자 정렬을 시도하는 num_as_num 성공하면 숫자 정렬을 수행하고, 그렇지 않으면 문자열 비교에 의존합니다.

개선을 위한 의견을 환영합니다.

 def sort_iterable(iterable, sort_on=None, reverse=False, num_as_num=False): def _sort(i): # sort by 0 = keys, 1 values, None for lists and tuples try: if num_as_num: if i is None: _sorted = sorted(iterable, key=lambda v: float(v), reverse=reverse) else: _sorted = dict(sorted(iterable.items(), key=lambda v: float(v[i]), reverse=reverse)) else: raise TypeError except (TypeError, ValueError): if i is None: _sorted = sorted(iterable, key=lambda v: str(v), reverse=reverse) else: _sorted = dict(sorted(iterable.items(), key=lambda v: str(v[i]), reverse=reverse)) return _sorted if isinstance(iterable, list): sorted_list = _sort(None) return sorted_list elif isinstance(iterable, tuple): sorted_list = tuple(_sort(None)) return sorted_list elif isinstance(iterable, dict): if sort_on == 'keys': sorted_dict = _sort(0) return sorted_dict elif sort_on == 'values': sorted_dict = _sort(1) return sorted_dict elif sort_on is not None: raise ValueError(f"Unexpected value {sort_on} for sort_on. When sorting a dict, use key or values") else: raise TypeError(f"Unexpected type {type(iterable)} for iterable. Expected a list, tuple, or dict")

Bram Vanroy

d.values() 및 d.keys() 에 zip을 사용하는 솔루션입니다. 이 링크의 몇 줄(사전 보기 개체에서)은 다음과 같습니다.

이렇게 하면 zip()을 사용하여 (값, 키) 쌍을 만들 수 있습니다. pairs = zip(d.values(), d.keys()).

따라서 다음을 수행할 수 있습니다.

 d = {'key1': 874.7, 'key2': 5, 'key3': 8.1} d_sorted = sorted(zip(d.values(), d.keys())) print d_sorted # prints: [(5, 'key2'), (8.1, 'key3'), (874.7, 'key1')]

Scott

dicts 에서 ValueSortedDict 사용:

 from dicts.sorteddict import ValueSortedDict d = {1: 2, 3: 4, 4:3, 2:1, 0:0} sorted_dict = ValueSortedDict(d) print sorted_dict.items() [(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]

ponty

Python for Everything 에서 관련 기술을 방금 배웠습니다.

임시 목록을 사용하여 사전을 정렬할 수 있습니다.

 #Assume dictionary to be: d = {'apple': 500.1, 'banana': 1500.2, 'orange': 1.0, 'pineapple': 789.0} # create a temporary list tmp = [] # iterate through the dictionary and append each tuple into the temporary list for key, value in d.items(): tmptuple = (value, key) tmp.append(tmptuple) # sort the list in ascending order tmp = sorted(tmp) print (tmp)

목록을 내림차순으로 정렬하려면 원래 정렬 라인을 다음과 같이 변경하면 됩니다.

 tmp = sorted(tmp, reverse=True)

목록 이해를 사용하면 하나의 라이너는 다음과 같습니다.

 #Assuming the dictionary looks like d = {'apple': 500.1, 'banana': 1500.2, 'orange': 1.0, 'pineapple': 789.0} #One liner for sorting in ascending order print (sorted([(v, k) for k, v in d.items()])) #One liner for sorting in descending order print (sorted([(v, k) for k, v in d.items()], reverse=True))

샘플 출력:

 #Asending order [(1.0, 'orange'), (500.1, 'apple'), (789.0, 'pineapple'), (1500.2, 'banana')] #Descending order [(1500.2, 'banana'), (789.0, 'pineapple'), (500.1, 'apple'), (1.0, 'orange')]

mcgag

dict를 반복하고 값을 기준으로 내림차순으로 정렬합니다.

 $ python --version Python 3.2.2 $ cat sort_dict_by_val_desc.py dictionary = dict(siis = 1, sana = 2, joka = 3, tuli = 4, aina = 5) for word in sorted(dictionary, key=dictionary.get, reverse=True): print(word, dictionary[word]) $ python sort_dict_by_val_desc.py aina 5 tuli 4 joka 3 sana 2 siis 1

juhoh

값이 정수이고 Python 2.7 이상을 사용하는 경우 dictcollections.Counter 를 사용할 수 있습니다. most_common 메소드는 값을 기준으로 정렬된 모든 항목을 제공합니다.

Petr Viktorin

이것은 3.1.x에서 작동합니다.

 import operator slovar_sorted=sorted(slovar.items(), key=operator.itemgetter(1), reverse=True) print(slovar_sorted)

iFail

완전성을 위해 heapq 를 사용하여 솔루션을 게시하고 있습니다. 이 방법은 숫자 값과 숫자가 아닌 값 모두에 적용됩니다.

 >>> x = {1: 2, 3: 4, 4:3, 2:1, 0:0} >>> x_items = x.items() >>> heapq.heapify(x_items) >>> #To sort in reverse order >>> heapq.nlargest(len(x_items),x_items, operator.itemgetter(1)) [(3, 4), (4, 3), (1, 2), (2, 1), (0, 0)] >>> #To sort in ascending order >>> heapq.nsmallest(len(x_items),x_items, operator.itemgetter(1)) [(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]

Abhijit

months = {"January": 31, "February": 28, "March": 31, "April": 30, "May": 31, "June": 30, "July": 31, "August": 31, "September": 30, "October": 31, "November": 30, "December": 31} def mykey(t): """ Customize your sorting logic using this function. The parameter to this function is a tuple. Comment/uncomment the return statements to test different logics. """ return t[1] # sort by number of days in the month #return t[1], t[0] # sort by number of days, then by month name #return len(t[0]) # sort by length of month name #return t[0][-1] # sort by last character of month name # Since a dictionary can't be sorted by value, what you can do is to convert # it into a list of tuples with tuple length 2. # You can then do custom sorts by passing your own function to sorted(). months_as_list = sorted(months.items(), key=mykey, reverse=False) for month in months_as_list: print month

lessthanl0l

출처 : 여기를 클릭하세요

출처 : http:www.stackoverflow.com/questions/613183/how-do-i-sort-a-dictionary-by-value