어떻게 정렬이 사전에 가치입니까?

https://stackoverflow.com/questions/613183

03-07-2019
|

문제

나는 사전에서 읽은 값을 두 개의 필드에서는 데이터베이스:문자열 분야합니다.이 필드의 문자열은 독특하고,그래서 키의 사전입니다.

나는 정렬할 수 있는 열쇠에,하지만 어떻게 정렬 값에 따라?

참고:I have read Stack Overflow 여기에 문제 어떻게 정의 목록은 사전의 값으로 사전? 아마도 변경할 수 있 나의 코드의 목록을 가지고 사전에,하지만 제가 정말로 필요하지 않은 목록이 사전에 알고 싶어 있는 경우에는 간단한 솔루션을 정렬하거나 내림차순 또는 오름차순으로.

해결책

사전을 정렬 할 수는 없으며 분류 된 사전을 표현하는 것만 할 수 없습니다. 사전은 본질적으로 질서가 없지만 목록 및 튜플과 같은 다른 유형은 그렇지 않습니다. 따라서 정렬 된 값을 나타내려면 주문한 데이터 유형이 필요합니다. 정렬 된 값은 목록, 아마도 튜플 목록이 될 것입니다.

예를 들어,

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에서 [1] 우리는 사용할 수 있습니다

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

출력을 DITT로 원한다면 사용할 수 있습니다. collections.OrderedDict:

import collections

sorted_dict = collections.OrderedDict(sorted_x)

다른 팁

간단한 : `sorted(dict1, key=dict1.get)`

글쎄, 실제로 "사전 값으로 정렬"을 수행하는 것이 가능합니다. 최근에 나는 코드 골프에서 그것을해야했다 (스택 오버플로 질문 코드 골프 : 단어 주파수 차트). 요약 된 문제는 종류의 종류였습니다. 텍스트가 주어지면 각 단어가 얼마나 자주 발생하는지 계산하고 주파수를 줄여서 정렬 된 상단 단어의 목록을 표시합니다.

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

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]

나는 사람들이 종종 "키에 의해 사전을 쉽게 분류 할 수 있지만 가치별로 정렬하는 방법"이 종종 의미하는 바를 설명하기 위해이 자세한 설명을 작성하고 있습니다. 해결책은 위에 표시된 것처럼 값을 기반으로 한 종류의 키 목록을 수행하는 것입니다.

당신은 사용할 수 있습니다 :

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

이것은 사전 내의 각 항목 값으로 사전을 가장 작은 것에서 가장 큰 것부터 정렬합니다.

내림차순으로 정렬하려면 추가하십시오 reverse=True:

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

DICT는 정렬 할 수 없지만 정렬 된 목록을 작성할 수 있습니다.

정렬 된 DICT 값 목록 :

sorted(d.values())

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

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

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

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

질서는 정상적인 덕트처럼 행동합니다.

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

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

허용 된 답변이 유용하다는 것을 알았지 만, 참조로 업데이트되지 않았다는 사실에 놀랐습니다. 순서대로 표준 라이브러리에서 컬렉션 이러한 유형의 문제를 정확하게 해결하도록 설계된 실행 가능한 현대적인 대안으로 모듈.

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

공무원 순서대로 문서화는 매우 유사한 예제를 제공하지만 정렬 함수에 Lambda를 사용합니다.

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

거의 동일합니다 행크 게이의 대답:

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

또는 John Fouhy가 제안한대로 약간 최적화 :

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

그것은 종종 수 있습니다 아주 편리한 사용 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)

지금 당신은 이름을 얻을 수 있고의 점수는,말하자 두 번째 최고의 선수(index=1)매우 Pythonically 다음과 같다:

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

로 Python3.6 내장 dict 것입 주문

좋은 소식은,그래서 영업 이익의 원래 사용의 경우 매핑 쌍 검색된 데이터베이스에서 고유의 문자열 id 를 키로 숫자 값으로 값으로 내장 Python v3.6+dict,지중에 삽입하기 위해.

는 경우를 말한 결과 두 개의 열이 테이블에 표현이 데이터베이스 쿼리에서 다음과 같:

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)

항복 이 경우에는(새로운 Python3.6+내장 dict!):

foo 0
bar 1
baz 42

에서 동일한 주문별로 가치의 v.

어디에서 Python3.5 설치 내 컴퓨터에 그것은 현재 수익률:

bar 1
foo 0
baz 42

상세정보:

제안으로 2012 년 레이몬드 Hettinger(cf.메일에 python-dev 으로 주제 "더 콤팩트한 사전으로 빠른 반복" 시)(2016)에 발표 메일 빅터 Stinner python-dev 으로 주제 "Python3.6dict 된 컴팩트하고 개인전;키워드가 주" 로 인해 수정/의 구현 문제 27350 "소형 주문 dict" Python3.6 할 수 있을 내어 유지 삽입하기 위해!!

희망이 이어질 것입니다 얇은 레이어 OrderedDict 구현으로 첫 번째 단계입니다.로@JimFasarakis-힐라드 표시,일부 사용을 참조하십시오례 OrderedDict 유형 또한 미래입니다.내가 생각하는 파이썬 커뮤니티에서 큰 것을 주의 깊게 검사하는 경우에,이것은 시간의 테스트 스탠드,그리고 다음 단계가 될 것입니다.

시간을 다시 생각하는 우리의 습관을 놓치지 않을 가능성을 열에 의해 안정적인 순서는:

키워드 논쟁과
(중급)dict 스토리지

첫 번째기 때문에 그것을 용이하게 파견의 구현에서 기능 및 방법은 어떤 경우에.

두 번째로 그것을 장려를 더 쉽게 사용 dicts 로 중간 저장 처리하는 파이프라인.

레이몬드 Hettinger 친절하게 제공되는 문서에 설명하"기술 뒤에는 파이썬 3.6 전"-에서 자신의 샌프란시스코 파이썬은 만남 그룹이 발표 2016 년 월 08.

그리고 어쩌면 꽤 Stack Overflow 높은 꾸며 질문과 대답은 페이지를 받을 것이 개 이러한 정보의 많은 고품질의 대답이 필요에 따 버전 업데이트 too.

주의의 위험 부담(지만 또한 아래 참조 업데이트 2017-12-15):

로@ajcr 정당하게 사항:"순서-보존하면 이 새로운 구현으로 간주됩 구현한 세부사항 및 의존하지 않아야한다." (서 whatsnew36)지 nit 따기 지 인용 절단한 비관적인;-).계속으로"(이 나중에 변경될 수 있지만,그것은 원하는 이 새로운 dict 구현에서 언어에 대한 몇 출시하기 전에 언어 변경 사양을 위해 보존하는 의미에 대한 현재 및 미래의 모든 파이썬 구현;또한 이것을 유지하는 데 도움이 뒤로-이전 버전과의 호환성의 언어는 임의의 반복문은 여전히 유효하,예를 들어,Python3.5)."

그래서으로서 인간의 언어(예:독일어),사용법을 형성한 언어,그리고 이제 선언되었다...에 whatsnew36.

업데이트 2017-12-15:

에 메일 python-dev 목록,Guido 반로 섬 선언

이렇게 만든다."Dict 유지 삽입 주문은"지배하고 있습니다.감사합니다!

그래서,version3.6CPython 의 부작용 dict 삽입 주문입니다 지금의 일부가되어 spec(고 더 이상만 구현한 세부사항).는 메일 스레드 또한 표면 일부를 구별되는 디자인에 대한 목표 collections.OrderedDict 로에 의해 상기 레이몬드 Hettinger 동안 논의한다.

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

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

( "독점을 정리할 수 없다"는 질문을 읽지 못했습니다! 사실, 나는 키를 분류 할 수 있지만 값을 기준으로 어떻게 정렬 할 수 있습니까? " 키는 값의 가치에 따라 정렬되었습니다.)

주문은 잘 정의되지 않았습니다 (동일한 값을 가진 키는 출력 목록에서 임의 순서입니다).

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

즐기다 ;-)

이것은 코드입니다.

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}

값이 숫자 인 경우 사용할 수도 있습니다 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)]

다음 접근법을 시도하십시오. 다음 데이터로 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

"반전 인덱스"를 만들 수 있습니다.

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]

당신은 사용할 수 있습니다 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)])

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.

파이썬 3.7 문서 말 :

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

당신은 a를 사용할 수 있습니다 DITT 건너 뛰기 이것은 값으로 영구적으로 정렬되는 사전입니다.

>>> 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() 그런 다음 가치별로 정렬 된 순서로 반복 할 것입니다.

The를 사용하여 구현되었습니다 건너 뛰기 목록 Datafrsucture.

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

키로 전달할 수있는 사용자 지정 기능을 사용할 수도 있습니다.

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)

Dilettant가 지적했듯이, Python 3.6은 이제 할 것입니다 주문을 유지하십시오! 나는 반복 가능한 (튜플, 목록, dict)의 분류를 완화시키는 기능을 공유 할 것이라고 생각했다. 후자의 경우 키나 값을 정렬 할 수 있으며 숫자 비교를 고려할 수 있습니다. > = 3.6에 대해서만!

ints뿐만 아니라 문자열뿐만 아니라 끈을 고정시키는 반복적 인 반복에 정렬 된 사용을 시도 할 때 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")

여기에는 솔루션을 사용하에 지퍼 d.values() 고 d.keys().몇 줄이 링크(사전 개체 보기)입니다:

이것은 창조의(가치,키)쌍을 사용하여 지():쌍=zip(d.값(),d.키()).

그래서 우리는 다음을 수행할 수 있습니다:

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

사용 ValueStedDict ~에서 dicts:

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

DITT를 통해 반복하고 값으로 내림차순으로 정렬하십시오.

$ 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

값이 정수이고 Python 2.7 이상을 사용하는 경우 사용할 수 있습니다. collections.Counter 대신에 dict. 그만큼 most_common 메소드는 값으로 정렬 된 모든 항목을 제공합니다.

물론 사용해야합니다 OrderedDict 일반 파이썬 사전은 원래 순서를 유지하지 않기 때문입니다.

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

Python 2.7 이상이없는 경우 발전기 기능의 값을 반복하는 것입니다. ( OrderedDict 2.4 및 2.6의 경우 여기, 하지만

a) 나는 그것이 얼마나 잘 작동하는지 모르겠다

그리고

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 이상을 사용하지 않으면 인쇄 후 괄호를 제거해야합니다.

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

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

완전성을 위해 나는 사용 솔루션을 게시하고 있습니다. 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)]

방금 관련 기술을 배웠습니다 모두를위한 파이썬.

임시 목록을 사용하여 사전을 정렬하는 데 도움이 될 수 있습니다.

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

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

라이센스 : CC-BY-SA ~와 함께 속성

제휴하지 않습니다 StackOverflow