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

Cóż, w rzeczywistości można zrobić "Sortuj według wartości słownika". Ostatnio musiałem to zrobić w kodzie golfowym (pytanie o przepełnienie stosu Kod: Word frequency chart). Skrócony, problem był w rodzaju: biorąc pod uwagę tekst, policz, jak często każde słowo jest spotykane i wyświetl listę najważniejszych słów, posortowanych według malejącej częstotliwości.

Jeśli zbudujesz słownik z wyrazami jako kluczami i liczbą wystąpień każdego słowa jako wartość, uproszczone tutaj jako:

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

Następnie możesz uzyskać listę słów, uporządkowanych według częstotliwości użycia za pomocą sorted(d, key=d.get) - sortowanie jest powtarzane ponad kluczami słownikowymi, 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 mają na myśli przez "mogę łatwo sortować słownik według klucza, ale jak sortować według wartości" - I myślę, że OP próbował rozwiązać taki problem. A rozwiązaniem jest zrobienie pewnego rodzaju listy klucze, oparte na wartościach, jak pokazano powyżej.

Możesz użyć:

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

Posortuje słownik według wartości każdego wpisu w słowniku od najmniejszego do największego.

Dictów nie można posortować, ale można z nich zbudować 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 OrderedDict , który zapamiętuje 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ąc według wartości:

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

OrderedDict zachowuje się jak normalny dict:

>>> 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 korzystanie z Pythona 3.5

Chociaż uznałem zaakceptowaną odpowiedź za przydatną, byłem również zaskoczony, że nie została zaktualizowana do odniesienia OrderedDict z modułu biblioteki standardowej collections jako realnej, nowoczesnej alternatywy-zaprojektowanej do rozwiązania dokładnie tego typu problemów.

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

The official OrderedDict Dokumentacja oferuje bardzo podobny przykład, ale używając lambda do sortowania Funkcja:

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

Często może być bardzo przydatny w użyciu namedtuple. Na przykład masz słownik' nazwa 'jako klucze i 'wynik' jako wartości i chcesz sortować na 'wynik':

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

Sortowanie z najniższym wynikiem najpierw:

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

Sortowanie z najwyższym wynikiem najpierw:

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

Teraz możesz dostać nazwę i wynik, powiedzmy drugiego najlepszego gracza (index=1) bardzo Pythonically jak to:

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

Prawie tak samo jak odpowiedź Hanka Gay ' a;

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

Lub nieco zoptymalizowane zgodnie z sugestią Johna Fouhy ' ego;

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

Od Python 3.6 wbudowany dict będzie uporządkowany

Dobra wiadomość, więc oryginalny przypadek użycia op mapowania par pobranych z bazy danych z unikalnymi identyfikatorami łańcuchowymi jako kluczami i wartościami liczbowymi jako wartościami do wbudowanego Pythona V3.6+ dict, powinien teraz respektować kolejność wstawiania.

Jeśli powiesz wynikowe wyrażenia tabeli kolumn z zapytania bazy danych, takie jak:

SELECT a_key, a_value FROM a_table ORDER BY a_value;

Będzie przechowywana w dwóch krotkach Pythona, k_seq i v_seq (wyrównanych przez indeks numeryczny i z tej samej długości oczywiście), wtedy:

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)

W Tym Przypadku (Dla Nowego Pythona 3.6 + wbudowany dict!):

foo 0
bar 1
baz 42

W tym samym porządku na wartość v.

Gdzie w instalacji Pythona 3.5 na mojej maszynie aktualnie daje:

bar 1
foo 0
baz 42

Szczegóły:

Zgodnie z propozycją Raymonda Hettingera z 2012 r. (por. mail on python-dev with subject "bardziej kompaktowe słowniki z szybszą iteracją" ) i teraz (w 2016) ogłoszone w mailu przez Victor Stinner do python-dev z tematem "Python 3.6 dict staje się kompaktowy i dostaje prywatną wersję; i słowa kluczowe stają się uporządkowane" ze względu na poprawkę / implementację wydania 27350 "kompaktowy i uporządkowany dict" w Pythonie 3.6 będziemy teraz w stanie, używać wbudowanego dict do utrzymania kolejności wstawiania!!

Miejmy nadzieję, że doprowadzi to do cienkiej warstwy zamówionej implementacji Dict jako pierwszego kroku. Jak zauważył @ JimFasarakis-Hilliard, niektórzy widzą przypadki użycia dla Typ OrderedDict również w przyszłości. Myślę, że społeczność Pythona w ogóle dokładnie sprawdzi, czy to przetrwa próbę czasu i jakie będą następne kroki.

Czas przemyśleć nasze nawyki kodowania, aby nie przegapić możliwości otwartych przez stabilną kolejność:

• argumenty słów kluczowych i
• (intermediate) dict storage

Pierwszy, ponieważ w niektórych przypadkach ułatwia dyspozycję w implementacji funkcji i metod.

The po drugie, ponieważ zachęca do łatwiejszego wykorzystania dict s jako pośredniego przechowywania w rurociągach przetwórczych.

Raymond Hettinger uprzejmie dostarczył dokumentację wyjaśniającą " technologię stojącą za słownikami Pythona 3.6 " - z prezentacji grupy San Francisco Python Meetup 2016-DEC-08.

I być może całkiem sporo przepełnień stosu wysoko zdobione strony z pytaniami i odpowiedziami otrzymają warianty tych informacji i wiele wysokiej jakości odpowiedzi będzie wymagało aktualizacji wersji też.

Zastrzeżenie Emptor (ale również patrz poniżej Aktualizacja 2017-12-15):

Jak słusznie zauważa @ajcr: "aspekt zachowania porządku w tej nowej implementacji jest uważany za szczegół implementacji i nie należy na nim polegać."(z whatsnew36) nie nit, ale cytat został wycięty trochę pesymistycznie ; -). Kontynuuje jako " (może się to zmienić w przyszłości, ale pożądane jest, aby nowa implementacja dict w języku na kilka wydań przed zmiana specyfikacji języka na zlecenie-zachowanie semantyki dla wszystkich obecnych i przyszłych implementacji Pythona; pomaga to również zachować wsteczną kompatybilność ze starszymi wersjami języka, w których nadal obowiązuje losowa kolejność iteracji, np. Python 3.5)."

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

Aktualizacja 2017-12-15:

In a mail to the python-dev lista , Guido van Rossum zadeklarował:

Niech tak będzie. "Dict utrzymuje porządek wstawiania" to orzeczenie. Dzięki!

Tak więc efekt uboczny CPython w wersji 3.6 zamawiania wstawiania dict staje się teraz częścią specyfikacji języka (i nie jest już tylko szczegółem implementacji). Ten wątek mail ujawnił również pewne wyróżniające się cele projektowe dla collections.OrderedDict, jak przypomniał Raymond Hettinger podczas dyskusji.

Dany słownik

e = {1:39, 4:34, 7:110, 2:87}

Sortowanie

sred = sorted(e.items(), key=lambda value: value[1])

Wynik

[(4, 34), (1, 39), (2, 87), (7, 110)]

Możesz użyć funkcji lambda do sortowania rzeczy według wartości i przechowywania ich przetwarzanych wewnątrz zmiennej, w tym przypadku sred z e oryginalnym słownikiem.

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

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

(ludzie, którzy odpowiadają "nie da się posortować dict", nie przeczytali pytania! W rzeczywistości, " mogę sortować według kluczy, ale jak Mogę sortować na podstawie wartości?"wyraźnie oznacza, że chce listę kluczy posortowanych według wartości ich wartości.)

Proszę zauważyć, że kolejność nie jest dobrze zdefiniowana (klucze o tej samej wartości będą w dowolnej kolejności na liście wyjściowej).

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

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

Enjoy; -)

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

Rank

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

Jeśli wartości są liczbowe, Możesz również użyć licznika ze zbiorów

from collections import Counter

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


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

Technicznie rzecz biorąc, słowniki nie są sekwencjami i dlatego nie mogą być sortowane. Możesz zrobić coś takiego jak

sorted(a_dictionary.values())

Możesz utworzyć "odwrócony indeks", również

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ć kolekcji .Licznik . Uwaga, będzie to działać zarówno dla wartości liczbowych, jak i nieliczbowych.

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

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}

Jeśli ktoś chciałby posortować słownik według kluczy, można by zrobić coś takiego:

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

To powinno zwrócić następujące wyjście:

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

Z drugiej strony, jeśli ktoś chciał posortować słownik według wartości( jak jest zadane w pytaniu), można zrobić co następuje:

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ć "po": {]}

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

Możesz użyć skip dict, 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żywasz keys(), values() lub items() Następnie będzie iteracja w kolejności posortowanej według wartości.

Jest zaimplementowany przy użyciu pomiń listę datastruktura.

Zwraca listę par klucz-wartość w słowniku, posortowaną według wartości od najwyższej do najniższej:

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

Dla słownika posortowanego według klucza, użyj następującego:

sorted(d.items(), reverse=True)

Zwrot jest listą krotek, ponieważ nie można posortować samych słowników.

To może być zarówno wydrukowane lub wysłane do dalszych obliczeń.

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

Można również użyć funkcji niestandardowej, którą można przekazać do key.

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)

Jeszcze jednym sposobem jest użycie funkcji labmda

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

Oto rozwiązanie za pomocą zip na d.values() oraz d.keys(). Kilka linijek w dół tego linku (na obiektach widoku słownika) to:

Pozwala to na tworzenie par (wartość, klucz) za pomocą zip (): pairs = zip (d.values (), D.keys ()).

Więc możemy zrobić co następuje:

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

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

Iterować przez dict i posortować go według jego 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

Wymyśliłem ten,

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

Dla Pythona 3.x: x.items() zastępuje iteritems().

>>> sorted_x
{0: 0, 1: 2, 2: 1, 3: 4, 4: 3}

Lub spróbuj collections.OrderedDict!

x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
from collections import OrderedDict

od1 = OrderedDict(sorted(x.items(), key=lambda t: t[1]))

Możesz użyć posortowanej funkcji Pythona

sorted(iterable[, cmp[, key[, reverse]]])

W ten sposób możesz użyć:

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

Odwiedź ten link, aby uzyskać więcej informacji na temat sortowanej funkcji: https://docs.python.org/2/library/functions.html#sorted

Oczywiście, pamiętaj, że musisz użyć {[5] } ponieważ 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 Pythona 2.7 lub nowszego, najlepsze co możesz zrobić, to iterację wartości w funkcji generatora. (Tutaj jest zamówiony Dict dla 2.4 i 2.6 , Ale

a) I don't know about how well it works 

I

b) You have to download and install it of course. If you do not have administrative access, then I'm afraid the option's out.)

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 również wydrukować każdą wartość

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

Pamiętaj, aby usunąć nawiasy po wydrukowaniu, jeśli nie używanie Pythona 3.0 lub nowszego

Jak zauważył Dilettant, Python 3.6 będzie teraz zachowywał porządek ! Pomyślałem, że podzielę się napisaną przeze mnie funkcją, która ułatwia sortowanie iterowalnych (tuple, list, dict). W tym drugim przypadku można sortować według kluczy lub wartości i brać pod uwagę porównanie liczbowe. tylko dla > = 3.6!

Jeśli spróbujesz użyć sorted na iterable, który przechowuje np. ciągi znaków i ints, sorted() zakończy się niepowodzeniem. Oczywiście można wymusić porównywanie łańcuchów za pomocą str(). Jednak w niektórych przypadkach chcesz wykonać rzeczywiste porównanie liczbowe, gdzie 12 jest mniejsze niż 20 (co nie ma miejsca w porównaniu ciągów). Więc wymyśliłem co następuje. Jeśli chcesz jawnego porównania liczbowego, możesz użyć znacznika num_as_num, który spróbuje wykonać jawne sortowanie liczbowe, próbując przekonwertować wszystkie wartości na pływaki. Jeśli to się powiedzie, zrobi sortowanie numeryczne, w przeciwnym razie ucieknie się do porównywania łańcuchów.

Komentarze do poprawy lub push prośby Witam.

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

Jeśli twoje wartości są liczbami całkowitymi i używasz Pythona 2.7 lub nowszego, możesz użyć collections.Counter zamiast dict. Metoda most_common wyświetli wszystkie elementy posortowane według wartości.