Wie Sortiere ich ein Wörterbuch nach Wert?

https://stackoverflow.com/questions/613183

03-07-2019
|

Frage

Ich habe ein Wörterbuch der Werte aus zwei Feldern in einer Datenbank:ein string-Feld und ein numerisches Feld.Das string-Feld ist einzigartig, so dass der Schlüssel des Wörterbuchs.

Ich kann irgendwie auf den Tasten, aber wie kann ich die Sortierung basiert auf den Werten?

Hinweis:Ich habe gelesen, Stack-Overflow-Frage hier Wie Sortiere ich eine Liste von Wörterbüchern, die durch einen Wert des Wörterbuchs? und wahrscheinlich könnte sich ändern, meinen code, um eine Liste der Wörterbücher, aber da ich nicht wirklich brauchen, eine Liste der Wörterbücher, die ich wollte wissen, ob es eine einfachere Lösung zu Sortieren-entweder in aufsteigender oder absteigender Reihenfolge.

Lösung

Es ist nicht möglich, ein Wörterbuch zu sortieren, nur eine Darstellung eines Wörterbuchs zu erhalten, die sortiert wird. Wörterbücher sind von Natur aus ungeordnet, aber auch andere Typen, wie Listen und Tupeln, sind es nicht. Sie müssen also eine Art geordnete Daten sortierten Werte darzustellen, die eine List wahrscheinlich eine Liste von Tupeln sein werden.

Zum Beispiel

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

sorted_x wird eine Liste von Tupeln durch das zweite Element in jedem Tupel sortiert sein. dict(sorted_x) == x.

Und für diejenigen, die auf Schlüssel zu sortieren, anstatt Werte:

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

In Python3 seit dem Auspacken ist nicht erlaubt [1] wir verwenden können,

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

Wenn Sie die Ausgabe als dict möchten, können Sie collections.OrderedDict

import collections

sorted_dict = collections.OrderedDict(sorted_x)

Andere Tipps

So einfach wie: `sorted(dict1, key=dict1.get)`

Nun, es ist tatsächlich möglich, eine „Art von Wörterbuch-Werten“ zu tun. Vor kurzem hatte ich die in einem Code Golf (Stack-Überlauf Frage zu tun Code Golf: Worthäufigkeitsdiagramm ). Gekürzte, war das Problem der Art: Da ein Text, zählen, wie oft jedes Wort angetroffen wird und eine Liste der Top-Wörter angezeigt, sortiert nach Häufigkeit abnimmt.

Wenn Sie ein Wörterbuch mit den Worten als Schlüssel konstruieren und die Anzahl der Vorkommen jedes Wort als Wert, vereinfachte hier:

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

dann können Sie eine Liste der Wörter erhalten, nach Häufigkeit der Verwendung mit sorted(d, key=d.get) bestellt - die Art iteriert über die Dictionary-Schlüssel, um die Anzahl der Wortvorkommen als eine Art Schlüssel.

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

Ich schreibe diese ausführliche Erklärung zu verdeutlichen, was die Leute oft bedeuten, von „ich einfach ein Wörterbuch von Schlüssel sortieren, aber wie kann ich sortieren nach Wert“ - und ich denke, die OP ein solches Problem zu lösen versuchte. Und die Lösung ist eine Art Liste der Schlüssel zu tun, basierend auf den Werten, wie oben gezeigt.

Sie können verwendet werden:

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

Dies wird das Wörterbuch durch die Werte von jedem Eintrag im Wörterbuch vom kleinsten zum größten sortieren.

es sortieren in absteigender Reihenfolge nur reverse=True hinzufügen:

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

Dicts nicht sortiert werden können, aber Sie können eine sortierte Liste von ihnen bauen.

Eine sortierte Liste von dict Werten:

sorted(d.values())

Eine Liste von (Schlüssel, Wert) -Paare, nach Wert geordnet:

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

In den letzten Python 2.7, haben wir die neue OrderedDict Typ, der die Reihenfolge, in der erinnert sich an die Elemente hinzugefügt wurden.

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

Um ein neues bestellt Wörterbuch aus dem Original zu machen, die durch die Werte Sortierung:

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

Die OrderedDict verhält sich wie ein normaler 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)])

UPDATE: 5. Dezember 2015 mit Python 3.5

Während ich die akzeptierte Antwort nützlich gefunden, ich war auch überrascht, dass es nicht aktualisiert wurde referenzieren OrderedDict aus der Standardbibliothek Sammlungen Modul als eine tragfähige, moderne Alternative -. entwickelt, um genau von Problem dieser Art zu lösen

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

Die offizielle OrderedDict Dokumentation bietet ein sehr ähnliches Beispiel auch, aber eine Lambda für die Sortierfunktion:

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

So ziemlich die gleichen wie Hank Homosexuell Antwort :

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

oder leicht optimiert, wie von John Fouhy vorgeschlagen:

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

Es kann oft sehr praktisch sein verwenden namedtuple . Zum Beispiel haben Sie ein Wörterbuch von ‚name‘ als Schlüssel und ‚Partitur‘ als Werte, und Sie wollen auf ‚Score‘ sortieren:

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

mit der niedrigsten Punktzahl Sortierung zuerst:

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

mit der höchsten Punktzahl Sortierung zuerst:

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

Jetzt können Sie den Namen und die Punktzahl von bekommen, sagen wir mal das zweitbeste Spieler (Index = 1) sehr Pythonically wie folgt aus:

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

Wie von Python 3.6 die eingebaute in dict wird bestellt werden

Ein gute Nachricht, so dass die ursprüngliche Anwendungsfall der OP Paar Mapping aus einer Datenbank mit eindeutigem String-IDs als Schlüssel abgerufen und numerischen Werte als Wert in eine integrierten Python v3.6 + dict, sollte nun den Einsatz, um respektieren.

Wenn sagen die resultierenden zweispaltige Tabelle Ausdrücke aus einer Datenbank-Abfrage wie:

SELECT a_key, a_value FROM a_table ORDER BY a_value;

in zwei Python gespeichert würde Tupeln, k_seq und v_seq (ausgerichtet durch numerischen Index und mit der gleichen Länge natürlich), dann gilt:

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

zur Ausgabe zulassen später als:

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

was in diesem Fall (für den neuen Python 3.6+ Einbau-dict!):

foo 0
bar 1
baz 42

in der gleichen Reihenfolge pro Wert von v.

Wo in dem Python 3.5 auf meinem Rechner installiert es zur Zeit ergibt:

bar 1
foo 0
baz 42

Details:

Wie im Jahr 2012 von Raymond Hettinger (vgl Mail über python-dev mit dem Betreff vorgeschlagen "Kompaktere Wörterbücher mit schnellen Iteration" ) und jetzt (2016) in einer E-Mail von Victor Stinner zu python-dev mit dem Betreff angekündigt "Python 3.6 dict wird kompakt und eine eigene Version bekommt, und Keywords bestellt werden" aufgrund der fix / Umsetzung Ausgabe 27350 "Compact und bestellt dict" in Python 3.6 werden wir nun in der Lage sein, ein zu verwenden, built-in dict Einsatzauftrag !!

maintain

Hoffentlich auf eine dünne Schicht OrderedDict Implementierung als einen ersten Schritt führen wird. Wie @ JimFasarakis-Hilliard angegeben ist, sehen einige Anwendungsfälle für die OrderedDict Art auch in der Zukunft. Ich denke, die Python-Gemeinschaft im Allgemeinen wird sorgfältig prüfen, ob dies den Test der Zeit steht, und was die nächsten Schritte sein werden.

Zeit unsere Codierung Gewohnheiten zu überdenken, um nicht die Möglichkeiten, die stabile Anordnung der geöffneten zu verpassen:

Keyword Argumente und
(Zwischen-) dict Lagerung

Die erste, weil es Versand bei der Umsetzung von Funktionen und Methoden in einigen Fällen erleichtert.

der zweite als es fördert leichter dicts als Zwischenspeicher in Verarbeitungspipelines zu verwenden.

Raymond Hettinger kindly Dokumentation zu erklären " Die Tech Hinter Python 3.6 Wörterbücher ." - von seiner San Francisco Python Meetup-Gruppe Präsentation 2016-DEC-08

Und vielleicht einige ziemlich Stack-Überlauf hoch dekoriert Frage- und Antwort-Seiten werden Varianten dieser Informationen und viele qualitativ hochwertige Antworten erhalten auch ein pro Versions-Update erforderlich ist.

Gewährleistungsausschluß (siehe aber auch unter Update 2017.12.15):

Wie @ajcr zu Recht bemerkt: „Die Reihenfolge erhalt Aspekt dieser neuen Implementierung wird eine Implementierung Detail betrachtet und sollten nicht als verlässlich angesehen werden.“ (Aus dem whatsnew36 ) nicht Korinthenkacker, und das Zitat war ein bisschen pessimistisch ;-) geschnitten. Weiter geht es als "(dies in der Zukunft ändern, aber es ist wünschenswert, für einige Versionen dieser neuen dict Implementierung in der Sprache zu haben, bevor die Sprache spec Ändern ordnungserhalt Semantik für alle gegenwärtigen und zukünftigen Python-Implementierungen zu beauftragen, das auch hilft bewahren Rückwärtskompatibilität mit älteren Versionen der Sprache, wo zufälliger Iterationsreihenfolge noch in Kraft ist, zB Python 3.5). "

So wie in einigen menschlichen Sprachen (zum Beispiel Deutsch), prägt Verwendung der Sprache und der Wille nun erklärt wurde ... in whatsnew36 .

Aktualisieren 2017.12.15:

In einer Mail an die Python-dev Liste , Guido van Rossum erklärt:

Machen Sie es so. „Dict hält Einsetzfolge“ ist das Urteil. Vielen Dank!

die Version 3.6 CPython Nebenwirkung von dict Insertion Bestellung So, nun ist Teil der Sprache spec wird (und nicht mehr nur eine Implementierung Detail). Der Mail-Thread aufgetaucht auch einige Unterscheidungsdesignziele für collections.OrderedDict wie von Raymond Hettinger während der Diskussion erinnert.

Ich hatte das gleiche Problem, und ich löste es wie folgt aus:

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

(Menschen, die Antwort: „Es ist nicht möglich, eine dict zu sortieren“ nicht lesen die Frage! In der Tat: „Ich kann auf den Tasten sortieren, aber wie kann ich auf den Werten sortieren basiert?“ Bedeutet eindeutig, dass er will eine Liste der sortierten Schlüssel entsprechend dem Wert ihrer Werte.)

Bitte beachten Sie, dass die Reihenfolge nicht gut (Tasten mit dem gleichen Wert in einer beliebigen Reihenfolge in der Ausgabeliste sein wird) definiert ist.

In Python 2.7, einfach tun:

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

copy-paste von: http://docs.python.org/ dev / library / collections.html # ordereddict-Beispiele-and-Rezepte

Genießen Sie; -)

Dies ist der Code:

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

Hier sind die Ergebnisse:

Original

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

Wenn die Werte numerisch sind Sie auch von Counter verwenden < a href = "https://docs.python.org/library/collections.html" rel = "nofollow noreferrer"> Sammlungen .

from collections import Counter

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

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

Versuchen Sie, die folgende Vorgehensweise. Lassen Sie uns ein Wörterbuch definieren myDict mit folgenden Daten genannt:

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

Wenn man das Wörterbuch sortieren, indem Schlüssel wollte, könnte man so etwas wie:

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

Dies sollte die folgende Ausgabe zurück:

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

Auf der anderen Seite, wenn man ein Wörterbuch nach Wert sortiert werden will (wie in der Frage gestellt wird), könnte man folgendes tun:

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

Das Ergebnis dieses Befehls (das Wörterbuch nach Wert sortieren) zurückkehren sollte wie folgt vor:

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

Sie können einen "invertierten Index" erstellen, auch

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

Jetzt ist Ihre inversen die Werte; jeder Wert hat eine Liste der gültigen Schlüssel.

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

Sie können über den collections.Counter . Beachten Sie, dass dies für die Arbeit sowohl numerische als auch nicht-numerische Werte.

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

Starten von Python 3.6, dict Objekte werden nun durch Auftrag bestellt. Es ist offiziell in den Spezifikationen von 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}

Davor hatte man OrderedDict verwenden.

Python 3.7 Dokumentation sagt:

Changed in Version 3.7: Wörterbuch, um garantiert Einfügung sein Bestellung. Dieses Verhalten war Implementierungsdetail von CPython von 3,6.

Sie können mit einem skip dict das ist ein Wörterbuch, das von Wert permanent sortiert wird.

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

Wenn Sie keys(), values() oder items() verwenden dann werden Sie in sortierter Reihenfolge von Wert laufen.

Es implementiert ist unter Verwendung der Liste überspringen Datenstruktur.

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

Sie können auch benutzerdefinierte Funktion verwenden, die Schlüssel übergeben werden können.

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)

Wie Dilettant wies darauf hin, Python 3.6 wird nun hält die Reihenfolge ! Ich dachte, dass ich eine Funktion teilen, die ich schrieb, dass die Sortierung eines iterable (Tupel, Liste, dict) erleichtert. Im letzteren Fall können Sie entweder auf Schlüssel oder Werten sortieren, und es kann numerischen Vergleich berücksichtigt werden. Nur bei> = 3.6!

Wenn Sie versuchen, mit auf einem iterable sortiert, die zum Beispiel hält sowie Ints Strings, sortiert () fehl. Natürlich können Sie String-Vergleich mit str (Kraft). Doch in einigen Fällen mögen Sie tun ist numerischer Vergleich, wo 12 kleiner als 20 ist (was nicht der Fall in String-Vergleich ist). So kam ich mit dem Follow-up. Wenn Sie expliziten numerischen Vergleich möchten, können Sie das Flag num_as_num verwenden, die durch den Versuch explizite numerische Sortierung zu tun versuchen, alle Werte auf Schwimmern zu konvertieren. Wenn das gelingt, wird es die numerische Sortierung tun, sonst wird es zu String-Vergleich zurückgreifen.

Kommentare für Verbesserungen oder Anfragen schieben willkommen.

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

Hier ist eine Lösung, mit Reißverschluss auf d.values() und d.keys().Ein paar Zeilen nach unten diesem link (auf Dictionary-Objekte anzeigen), ist:

Dies ermöglicht die Schaffung von (value, key) - Paare mit zip():pairs = zip(d....Werte(), d....keys()).

So wir können tun die folgenden:

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

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

Iterate durch ein dict und sortieren sie durch ihre Werte in absteigender Reihenfolge:

$ 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

Wenn Sie Ihre Werte ganze Zahlen sind, und Sie verwenden Python 2.7 oder höher, können Sie collections.Counter statt dict. Die most_common Methode geben Sie alle Artikel, die durch den Wert sortiert.

Natürlich, denken Sie daran, Sie müssen OrderedDict verwenden, da normale Python Wörterbücher nicht die ursprüngliche Reihenfolge halten.

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

Wenn Sie nicht Python 2.7 oder höher, das Beste, was Sie tun können, ist Iterierte über die Werte in einer Generatorfunktion. (Es gibt eine OrderedDict für 2.4 und 2.6 hier , aber

a) Ich weiß nicht, wie gut es funktioniert

und

b) Sie müssen herunterladen und natürlich installieren. Wenn Sie nicht über Administratorzugriff verfügen, dann bin ich die Options aus Angst.)

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

Sie können auch jeden Wert auszudrucken

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

Bitte beachten Sie die Klammern nach dem Druck zu entfernen, wenn nicht Python 3.0 oder höher

mit

Das funktioniert in 3.1.x:

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

Der Vollständigkeit halber werde ich eine Lösung Posting mit heapq . Beachten Sie, dass diese Methode für die Arbeit sowohl numerische als auch nicht-numerische Werte

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

haben gerade gelernt, relevante Fähigkeiten von Python für Jedermann .

Sie können eine temporäre Liste verwenden Sie, um das Wörterbuch zu sortieren:

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

Wenn Sie die Liste in absteigender Reihenfolge sortieren, füllen Sie einfach die ursprüngliche Sortierung ändern Zeile:

tmp = sorted(tmp, reverse=True)

Liste Verständnis verwenden, das Motto wäre:

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

Beispielausgabe:

#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

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow