Mam słownik wartości odczytanych z dwóch pól w bazie danych: pola ciągu i pola numerycznego. Pole ciągu jest unikalne, więc jest to klucz słownika.

Mogę sortować według kluczy, ale jak mogę sortować według wartości?

Uwaga: przeczytałem tutaj pytanie Przepełnienie stosu Jak posortować listę słowników według wartości słownika? i prawdopodobnie może zmienić mój kod, aby mieć listę słowników, ale ponieważ tak naprawdę nie potrzebuję listy słowników, chciałem wiedzieć, czy istnieje prostsze rozwiązanie do sortowania w kolejności rosnącej lub malejącej.

Python 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}

Starszy Python

Nie można posortować słownika, aby uzyskać reprezentację posortowanego słownika. Słowniki są z natury uporządkowane, ale inne typy, takie jak listy i krotki, nie są. Potrzebujesz więc uporządkowanego typu danych do reprezentowania posortowanych wartości, które będą listą - prawdopodobnie listą krotek.

Na przykład,

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

sorted_xbędzie listą krotek posortowaną według drugiego elementu w każdej krotce. dict(sorted_x) == x.

A dla tych, którzy chcą sortować według kluczy zamiast wartości:

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

W Python3, ponieważ rozpakowywanie nie jest dozwolone [1] , możemy użyć

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

Jeśli chcesz, aby dane wyjściowe były w formie nagrania, możesz użyć collections.OrderedDict:

import collections

sorted_dict = collections.OrderedDict(sorted_x)

Tak prosty jak: sorted(dict1, key=dict1.get)

W rzeczywistości możliwe jest „sortowanie według wartości słownikowych”. Ostatnio musiałem to zrobić w Code Golf (pytanie o przepełnienie stosu Code golf: Wykres częstotliwości słów ). Skrócony, problem był tego rodzaju: biorąc pod uwagę tekst, policz, jak często napotyka się każde słowo, i wyświetl listę najważniejszych słów posortowanych według malejącej częstotliwości.

Jeśli konstruujesz słownik ze słowami jako kluczami i liczbą wystąpień każdego słowa jako wartością, uprościsz tutaj:

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

następnie możesz uzyskać listę słów, uporządkowaną według częstotliwości użycia z sorted(d, key=d.get)- sortowanie iteruje się po klawiszach słownika, używając liczby wystąpień słów jako klucza sortowania.

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

Piszę to szczegółowe wyjaśnienie, aby zilustrować, co ludzie często rozumieją przez: „Mogę łatwo posortować słownik według klucza, ale jak sortować według wartości” - i myślę, że oryginalny post próbował rozwiązać taki problem. Rozwiązaniem jest zrobienie listy kluczy w oparciu o wartości, jak pokazano powyżej.

Możesz użyć:

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

Spowoduje to sortowanie słownika według wartości każdego wpisu w słowniku od najmniejszej do największej.

Aby posortować w kolejności malejącej, po prostu dodaj reverse=True:

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

Wejście:

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

Wynik:

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

Dykty nie mogą być sortowane, ale możesz zbudować z nich posortowaną listę.

Posortowana lista wartości dict:

sorted(d.values())

Lista par (klucz, wartość), posortowana według wartości:

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

W najnowszym Pythonie 2.7 mamy nowy typ OrdersDict , który pamięta kolejność dodawania elementów.

>>> 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}

Aby utworzyć nowy uporządkowany słownik z oryginału, sortuj według wartości:

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

OrDERDict zachowuje się jak normalny dykt:

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

AKTUALIZACJA: 5 GRUDNIA 2015 r. Przy użyciu języka Python 3.5

Chociaż uznałem, że zaakceptowana odpowiedź jest przydatna, zdziwiłem się również, że nie została zaktualizowana, aby odwoływać się do OragedDict ze standardowego modułu zbiorów bibliotecznych jako realnej, nowoczesnej alternatywy - zaprojektowanej w celu rozwiązania dokładnie tego rodzaju problemu.

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

Oficjalna dokumentacja OrdersDict również oferuje bardzo podobny przykład, ale używając lambda dla funkcji sortowania:

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

Prawie tak samo jak odpowiedź Hanka Gaya :

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

Lub lekko zoptymalizowany, jak sugerował John Fouhy:

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

Korzystanie z namedtuple często może być bardzo przydatne . Na przykład masz słownik „nazwa” jako klucze i „wynik” jako wartości i chcesz posortować według „wynik”:

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

sortowanie najpierw od najniższego wyniku:

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

sortowanie najpierw z najwyższym wynikiem:

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

Teraz możesz uzyskać nazwę i wynik, powiedzmy, drugiego najlepszego gracza (indeks = 1) bardzo pythonicznie:

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

Począwszy od Python 3.6 wbudowany słownik zostanie zamówiony

Dobra wiadomość, więc oryginalny przypadek użycia OP dla par mapowania pobranych z bazy danych z unikalnymi identyfikatorami łańcuchów jako kluczami i wartościami liczbowymi jako wartościami do wbudowanego dict Pythona v3.6 +, powinien teraz przestrzegać kolejności wstawiania.

Jeśli powiedz wynikowe wyrażenia z dwóch kolumn z zapytania do bazy danych, takie jak:

SELECT a_key, a_value FROM a_table ORDER BY a_value;

będą przechowywane w dwóch krotkach Pythona, k_seq i v_seq (wyrównane według indeksu numerycznego i oczywiście o tej samej długości), a następnie:

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

Pozwól na wyjście później jako:

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

ustępując w tym przypadku (dla nowego wbudowanego słownika Python 3.6+!):

foo 0
bar 1
baz 42

w tym samym porządku według wartości v.

Gdzie w instalacji Pythona 3.5 na moim komputerze daje on obecnie:

bar 1
foo 0
baz 42

Detale:

Jak zaproponował Raymond Hettinger w 2012 r. (Por. Poczta na python-dev z tematem „Bardziej kompaktowe słowniki z szybszą iteracją” ), a teraz (w 2016 r.) Ogłoszony w mailu Victora Stinnera do python-dev z tematem „ Dict Python 3.6 staje się kompaktowy i dostaje wersję prywatną, a słowa kluczowe zostają uporządkowane ”z powodu poprawki / wdrożenia wydania 27350 „ Kompaktowy i uporządkowany dykt ” w Pythonie 3.6 będziemy teraz mogli użyć wbudowanego dykta do utrzymania kolejności wstawiania !!

Mamy nadzieję, że doprowadzi to do wdrożenia cienkiej warstwy OrdersDict jako pierwszego kroku. Jak wskazał @ JimFasarakis-Hilliard, niektórzy zobaczą przypadki użycia dla typu OrdersDict również w przyszłości. Myślę, że cała społeczność Pythona dokładnie sprawdzi, czy to wytrzyma próbę czasu i jakie będą kolejne kroki.

Czas przemyśleć nasze nawyki programistyczne, aby nie przegapić możliwości, jakie daje stabilne porządkowanie:

• Argumenty słów kluczowych i
• (pośrednie) przechowywanie nagrań

Po pierwsze, ponieważ w niektórych przypadkach ułatwia wysyłanie przy wdrażaniu funkcji i metod.

Drugi, ponieważ zachęca do łatwiejszego wykorzystania dicts jako magazynu pośredniego w rurociągach przetwórczych.

Raymond Hettinger uprzejmie dostarczył dokumentację wyjaśniającą „ The Tech Behind Python 3.6 Dictionaries ” - z prezentacji w San Francisco Python Meetup Group 2016-DEC-08.

I może całkiem sporo stron z pytaniami i odpowiedziami o wysokim przepełnieniu stosu otrzyma warianty tych informacji i wiele wysokiej jakości odpowiedzi będzie wymagać aktualizacji dla każdej wersji.

Zastrzeżenie Emptor (ale także patrz poniżej aktualizacja 2017-12-15):

Jak słusznie zauważa @ajcr: „Aspekt utrzymywania porządku w tej nowej implementacji jest uważany za szczegół implementacji i nie należy na nim polegać”. (z whatsnew36 ) nie wybieranie nitów, ale cytat został nieco pesymistyczny ;-). Kontynuuje jako „(może się to zmienić w przyszłości, ale pożądane jest, aby ta nowa implementacja dict w języku była dostępna przez kilka wydań przed zmianą specyfikacji języka, aby narzucić obowiązującą semantykę zachowującą porządek dla wszystkich bieżących i przyszłych implementacji Pythona; to również pomaga zachować kompatybilność wsteczną ze starszymi wersjami języka, w którym wciąż obowiązuje kolejność losowych iteracji, np. Python 3.5). ”

Tak jak w niektórych ludzkich językach (np. Niemiecki), użycie kształtuje język, a wola została teraz zadeklarowana ... w whatsnew36 .

Aktualizacja 15.12.2017:

W liście do listy python-dev Guido van Rossum oświadczył:

Zrób to tak. „Dict utrzymuje kolejność wstawiania” to orzeczenie. Dzięki!

Tak więc efekt uboczny CPython wersji 3.6 porządkowania wstawiania dyktów staje się teraz częścią specyfikacji języka (a nie tylko szczegółem implementacji). Ten wątek pocztowy zawierał również niektóre wyróżniające się cele projektowe, o collections.OrderedDictczym przypomniał Raymond Hettinger podczas dyskusji.

Miałem ten sam problem i rozwiązałem go w następujący sposób:

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

(Ludzie, którzy odpowiedzieli „Nie można posortować nagrania”, nie przeczytali pytania! W rzeczywistości „Mogę sortować według kluczy, ale jak mogę sortować według wartości?” Wyraźnie oznacza, że ​​chce listy klucze posortowane według wartości ich wartości).

Zauważ, że kolejność nie jest dobrze zdefiniowana (klucze o tej samej wartości będą w dowolnej kolejności na liście wyników).

Jeśli wartości są liczbowe, możesz także użyć Counterz kolekcji .

from collections import Counter

x = {'hello': 1, 'python': 5, 'world': 3}
c = Counter(x)
print(c.most_common())

>> [('python', 5), ('world', 3), ('hello', 1)]    

W Pythonie 2.7 po prostu wykonaj:

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

skopiuj-wklej z: http://docs.python.org/dev/library/collections.html#ordereddict-examples-and-recipes

Cieszyć się ;-)

To jest kod:

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

Oto wyniki:

Oryginalny

{'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}

Rofl

{'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}

Ranga

{'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}

Wypróbuj następujące podejście. Zdefiniujmy słownik o nazwie mydict z następującymi danymi:

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

Gdyby ktoś chciał posortować słownik według kluczy, mógłby zrobić coś takiego:

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

Powinno to zwrócić następujące dane wyjściowe:

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

Z drugiej strony, jeśli ktoś chciałby posortować słownik według wartości (jak zadaje pytanie), mógłby wykonać następujące czynności:

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

Wynik tego polecenia (sortowanie słownika według wartości) powinien zwrócić następujące informacje:

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

Począwszy od Pythona 3.6, dictobiekty są teraz uporządkowane według kolejności wstawiania. Jest to oficjalnie zawarte w specyfikacji 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}

Wcześniej musiałeś użyć OrderedDict.

Dokumentacja Python 3.7 mówi:

Zmieniono w wersji 3.7: kolejność wstawiania słownika jest gwarantowana. To zachowanie było szczegółową implementacją CPython z 3.6.

Możesz także utworzyć „indeks odwrócony”

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

Teraz twoja odwrotność ma wartości; każda wartość ma listę odpowiednich kluczy.

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

Możesz użyć licznika collections.Counter . Uwaga: będzie to działać zarówno dla wartości liczbowych, jak i nienumerycznych.

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

Możesz użyć pomijania, który jest słownikiem trwale posortowanym według wartości.

>>> 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}

Jeśli użyjesz keys(), values()albo items()będziesz iterował w posortowanej kolejności według wartości.

Jest realizowany przy użyciu struktury danych listy pominięć.

Możesz także użyć funkcji niestandardowej, którą można przekazać do klucza.

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)

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

Jak zauważył Dilettant , Python 3.6 zachowa teraz porządek ! Pomyślałem, że podzielę napisaną przeze mnie funkcję, która ułatwia sortowanie iterowalnych (krotka, lista, dyktafon). W tym drugim przypadku można sortować według kluczy lub wartości i może ono uwzględniać porównanie numeryczne.Tylko dla> = 3,6!

Gdy spróbujesz użyć sorted na iterable, który przechowuje np. Łańcuchy, jak również ints, sorted () zakończy się niepowodzeniem. Oczywiście możesz wymusić porównanie ciągów za pomocą str (). Jednak w niektórych przypadkach chcesz dokonać rzeczywistego porównania numerycznego, gdzie 12jest mniejsze niż 20(co nie ma miejsca w porównaniu ciągów). Więc wymyśliłem następujące. Jeśli chcesz jawnego porównania numerycznego, możesz użyć flagi, num_as_numktóra spróbuje przeprowadzić jawne sortowanie numeryczne, próbując przekonwertować wszystkie wartości na zmiennoprzecinkowe. Jeśli to się powiedzie, przeprowadzi sortowanie numeryczne, w przeciwnym razie użyje porównania ciągów.

Komentarze do ulepszeń lub prośby push są mile widziane.

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

Oto rozwiązanie wykorzystujące zip d.values()id.keys() . Kilka linii w dół tego linku (w obiektach widoku słownika) to:

Pozwala to na tworzenie par (wartość, klucz) za pomocą zip (): pairs = zip (d. Wartości (), d. Klucze ()).

Możemy więc wykonać następujące czynności:

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

Oczywiście pamiętaj, że musisz użyć, OrderedDictponieważ zwykłe słowniki Pythona nie zachowują oryginalnej kolejności.

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

Jeśli nie masz języka Python w wersji 2.7 lub nowszej, najlepsze, co możesz zrobić, to iterować wartości w funkcji generatora. (Jest to OrderedDict2,4 i 2,6 tutaj , ale

a) Nie wiem, jak dobrze to działa

i

b) Oczywiście musisz go pobrać i zainstalować. Jeśli nie masz dostępu administracyjnego, obawiam się, że ta opcja jest niedostępna).

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

Możesz także wydrukować każdą wartość

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

Pamiętaj, aby usunąć nawiasy po wydrukowaniu, jeśli nie używasz języka Python 3.0 lub nowszego

Użyj ValueSortedDict z 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)]

Działa to w wersji 3.1.x:

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

Właśnie nauczyłem się odpowiednich umiejętności od Python for Everybody .

Możesz użyć tymczasowej listy, aby pomóc w sortowaniu słownika:

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

Jeśli chcesz posortować listę w kolejności malejącej, po prostu zmień oryginalną linię sortowania na:

tmp = sorted(tmp, reverse=True)

Korzystając ze zrozumienia listy, jedną linijką byłoby:

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

Przykładowe dane wyjściowe:

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

Iteruj przez dykt i sortuj je według wartości w porządku malejącym:

$ 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

Jeśli twoje wartości są liczbami całkowitymi i używasz języka Python 2.7 lub nowszego, możesz użyć collections.Counterzamiast niego dict. Ta most_commonmetoda da ci wszystkie elementy posortowane według wartości.

Dla kompletności zamieszczam rozwiązanie za pomocą heapq . Uwaga: ta metoda będzie działać zarówno dla wartości liczbowych, jak i nienumerycznych

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

Ze względu na wymagania dotyczące zachowania kompatybilności wstecznej ze starszymi wersjami Pythona myślę, że rozwiązanie OrdersDict jest bardzo nierozsądne. Chcesz czegoś, co działa z Pythonem 2.7 i starszymi wersjami.

Ale rozwiązanie dotyczące kolekcji, o którym mowa w innej odpowiedzi, jest absolutnie doskonałe, ponieważ przekwalifikowujecie połączenie między kluczem a wartością, co w przypadku słowników jest niezwykle ważne.

Nie zgadzam się z wyborem numer jeden przedstawionym w innej odpowiedzi, ponieważ wyrzuca klucze.

Użyłem rozwiązania wspomnianego powyżej (kod pokazany poniżej) i zachowałem dostęp zarówno do kluczy, jak i wartości, aw moim przypadku kolejność była na wartościach, ale ważna była kolejność kluczy po zamówieniu wartości.

from collections import Counter

x = {'hello':1, 'python':5, 'world':3}
c=Counter(x)
print c.most_common()


>> [('python', 5), ('world', 3), ('hello', 1)]