it-swarm.com.de

Wie sortiere ich ein Wörterbuch nach Wert?

Ich habe ein Wörterbuch mit Werten, die aus zwei Feldern in einer Datenbank gelesen wurden: einem Zeichenfolgenfeld und einem numerischen Feld. Das Zeichenfolgenfeld ist eindeutig, das ist also der Schlüssel des Wörterbuchs.

Ich kann nach den Schlüsseln sortieren, aber wie kann ich nach den Werten sortieren?

Hinweis: Ich habe hier die Frage zum Stapelüberlauf gelesen Wie sortiere ich eine Liste der Wörterbücher nach einem Wert des Wörterbuchs? und Wahrscheinlich könnte mein Code geändert werden, um eine Liste von Wörterbüchern zu erhalten, aber da ich keine Liste von Wörterbüchern wirklich benötige, wollte ich wissen, ob es eine einfachere Lösung gibt, um entweder in aufsteigender oder absteigender Reihenfolge zu sortieren.

3426
Gern Blanston

Es ist nicht möglich, ein Wörterbuch zu sortieren, sondern nur eine Darstellung eines sortierten Wörterbuchs zu erhalten. Wörterbücher sind von Natur aus nicht geordnet, andere Typen wie Listen und Tupel jedoch nicht. Sie benötigen also einen geordneten Datentyp, um sortierte Werte darzustellen. Dies ist eine Liste, wahrscheinlich eine Liste von Tupeln.

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_ ist eine Liste von Tupeln, die nach dem zweiten Element in jedem Tupel sortiert sind. dict(sorted_x) == x.

Und für diejenigen, die nach Schlüsseln anstatt nach Werten sortieren möchten:

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

In Python3 ist das Entpacken nicht erlaubt [1] können wir verwenden

_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 Diktat wünschen, können Sie collections.OrderedDict verwenden:

_import collections

sorted_dict = collections.OrderedDict(sorted_x)
_
4292

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

Nun, es ist tatsächlich möglich, eine "Sortierung nach Wörterbuchwerten" durchzuführen. Kürzlich musste ich das in einem Code Golf machen (Stack Overflow Frage Code Golf: Worthäufigkeitstabelle). Kurz gesagt, das Problem war von der Art: Geben Sie einen Text ein, zählen Sie, wie oft jedes Wort vorkommt, und zeigen Sie eine Liste der obersten Wörter an, sortiert nach abnehmender Häufigkeit.

Wenn Sie ein Wörterbuch mit den Wörtern als Schlüssel und der Anzahl der Vorkommen jedes Wortes als Wert erstellen, wird dies hier vereinfacht als:

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

anschließend können Sie mit sorted(d, key=d.get) eine Liste der Wörter nach Verwendungshäufigkeit sortieren. Die Sortierung durchläuft die Wörterbuchschlüssel, wobei die Anzahl der Wortvorkommen als Sortierschlüssel verwendet wird.

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

Ich schreibe diese ausführliche Erklärung, um zu veranschaulichen, was die Leute oft mit "Ich kann ein Wörterbuch leicht nach Schlüssel sortieren, aber wie sortiere ich nach Wert" meinen - und ich glaube, das OP hat versucht, ein solches Problem anzugehen. Die Lösung besteht darin, eine Liste der Schlüssel auf der Grundlage der oben gezeigten Werte zu erstellen.

1117
Nas Banov

Du könntest benutzen:

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

Dadurch wird das Wörterbuch nach den Werten der einzelnen Einträge im Wörterbuch vom kleinsten zum größten sortiert.

Um es in absteigender Reihenfolge zu sortieren, fügen Sie einfach reverse=True hinzu:

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

Dicts können nicht sortiert werden, Sie können jedoch eine sortierte Liste daraus erstellen.

Eine sortierte Liste der diktierten Werte:

sorted(d.values())

Eine Liste von (Schlüssel-, Wert-) Paaren, sortiert nach Wert:

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

In Python 2.7 haben wir den neuen OrderedDict -Typ, der sich an die Reihenfolge erinnert, in der 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}

So erstellen Sie aus dem Original ein neu geordnetes Wörterbuch, das nach den Werten sortiert wird:

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

Das OrderedDict verhält sich wie ein normales Diktat:

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

UPDATE: 5. DEZEMBER 2015 mit Python 3.5

Obwohl ich die akzeptierte Antwort als nützlich empfand, war ich auch überrascht, dass sie nicht aktualisiert wurde, um auf OrderedDict aus dem Standard zu verweisen bibliotheksmodul sammlungen als praktikable, moderne alternative - entwickelt, um genau diese art von problem 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 ebenfalls ein sehr ähnliches Beispiel, verwendet jedoch ein 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)])
95
arcseldon

Ziemlich genau wie Hank Gay's 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())
74
user26294

Es kann oft sehr praktisch sein namedtuple. Zum Beispiel haben Sie ein Wörterbuch mit 'Name' als Schlüsseln und 'Punktzahl' als Werten und möchten nach 'Punktzahl' sortieren:

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

sortierung mit der niedrigsten Punktzahl zuerst:

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

sortierung mit der höchsten Punktzahl zuerst:

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

Jetzt können Sie den Namen und die Punktzahl des zweitbesten Spielers (Index = 1) in sehr pythonischer Form abrufen:

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

Ab Python 3.6 wird das eingebaute Diktat bestellt

Gute Nachrichten, daher sollte der ursprüngliche Anwendungsfall des OP für das Zuordnen von Paaren, die aus einer Datenbank mit eindeutigen Zeichenfolgen-IDs als Schlüssel und numerischen Werten als Werte in einem integrierten Python v3.6 + -Dikt abgerufen wurden, jetzt die Einfügung berücksichtigen Bestellung.

Wenn sagen, die resultierenden zwei Spaltentabellenausdrücke aus einer Datenbankabfrage wie:

SELECT a_key, a_value FROM a_table ORDER BY a_value;

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

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

Später ausgeben als:

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

ergebnis in diesem Fall (für das neue Python 3.6+ eingebaute Diktat!):

foo 0
bar 1
baz 42

in der gleichen Reihenfolge pro Wert von v.

Wo in der Python 3.5-Installation auf meinem Computer ergibt sich derzeit:

bar 1
foo 0
baz 42

Einzelheiten:

Wie 2012 von Raymond Hettinger vorgeschlagen (vgl. Mail zu Python-Dev mit Betreff "Kompaktere Wörterbücher mit schnellerer Iteration" ) und jetzt (2016) in einer Mail von Victor Stinner an Python-Dev angekündigt mit Betreff "Python 3.6 dict wird kompakt und erhält eine private Version; und Schlüsselwörter werden sortiert" aufgrund der Korrektur/Implementierung von Ausgabe 27350 "Kompakt und sortiert dict" in Python 3.6 Wir werden nun in der Lage sein, ein eingebautes Diktat zu verwenden, um die Reihenfolge der Einfügungen aufrechtzuerhalten !!

Hoffentlich führt dies als ersten Schritt zu einer Thin-Layer-Implementierung von OrderedDict. Wie @ JimFasarakis-Hilliard angedeutet hat, werden einige Anwendungsfälle für den Typ OrderedDict auch in Zukunft angezeigt. Ich denke, die Python Community im Allgemeinen wird sorgfältig prüfen, ob dies den Test der Zeit bestehen wird und wie die nächsten Schritte aussehen werden.

Zeit, unsere Codierungsgewohnheiten zu überdenken, um die Möglichkeiten nicht zu verpassen, die sich durch die stabile Bestellung von:

  • Schlüsselwortargumente und
  • (Zwischen-) Diktatspeicher

Das erste, weil es in einigen Fällen den Versand bei der Implementierung von Funktionen und Methoden erleichtert.

Der zweite Grund ist, dass es einfacher ist, dicts als Zwischenspeicher für die Verarbeitung von Pipelines zu verwenden.

Raymond Hettinger stellte freundlicherweise eine Dokumentation zur Verfügung, in der " The Tech Behind Python 3.6 Dictionaries " - aus seiner Meetup-Gruppenpräsentation 2016-DEC-08 in San Francisco Python erläutert wurde.

Und vielleicht erhalten einige hoch dekorierte Fragen- und Antwortseiten mit Stapelüberlauf Varianten dieser Informationen, und für viele hochqualitative Antworten ist auch ein Versionsupdate erforderlich.

Vorbehalt Emptor (siehe aber auch Update 2017-12-15 unten):

Zu Recht bemerkt @ajcr: "Der Aspekt der Aufrechterhaltung der Reihenfolge dieser neuen Implementierung wird als Implementierungsdetail betrachtet und sollte nicht als vertrauenswürdig angesehen werden." (aus dem whatsnew36 ) nicht nit picking, aber das zitat wurde etwas pessimistisch geschnitten ;-). Es wird wie folgt fortgesetzt: "(Dies kann sich in Zukunft ändern. Es ist jedoch wünschenswert, dass diese neue Diktumsimplementierung für einige Releases in der Sprache vorliegt, bevor die Sprachspezifikation geändert wird, um die auftragserhaltende Semantik für alle aktuellen und zukünftigen Python Implementierungen, dies hilft auch, die Abwärtskompatibilität mit älteren Versionen der Sprache zu erhalten, in der die zufällige Iterationsreihenfolge noch gültig ist, zB Python 3.5). "

So wie in einigen menschlichen Sprachen (z. B. Deutsch) prägt der Gebrauch die Sprache, und der Wille wurde jetzt erklärt ... in whatsnew36 .

Update 15.12.2017:

In einer Mail an die Python-Dev-Liste erklärte Guido van Rossum:

Mach es so. "Dict behält die Reihenfolge der Einfügungen bei" lautet die Entscheidung. Vielen Dank!

Der CPython-Nebeneffekt der Version 3.6 der Reihenfolge der Diktateinfügungen wird nun Teil der Sprachspezifikation (und nicht mehr nur ein Implementierungsdetail). Dieser Mail-Thread hat auch einige markante Designziele für collections.OrderedDict aufgedeckt, wie Raymond Hettinger während der Diskussion erinnerte.

67
Dilettant

Gegebenes Wörterbuch

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

Sortierung

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

Ergebnis

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

Sie können eine Lambda-Funktion verwenden, um Dinge nach Wert zu sortieren und sie verarbeitet in einer Variablen zu speichern, in diesem Fall sred mit e dem ursprünglichen Wörterbuch.

Ich hoffe, das hilft!

44
bishop

Ich hatte das gleiche Problem und habe es folgendermaßen gelöst:

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

(Leute, die antworten "Es ist nicht möglich, ein Diktat zu sortieren", haben die Frage nicht gelesen. Tatsächlich bedeutet "Ich kann nach den Schlüsseln sortieren, aber wie kann ich nach den Werten sortieren?", Dass er eine Liste von möchte die Schlüssel sortiert nach dem Wert ihrer Werte.)

Bitte beachten Sie, dass die Reihenfolge nicht genau definiert ist (Schlüssel mit demselben Wert werden in der Ausgabeliste in einer willkürlichen Reihenfolge angezeigt).

40
jimifiki

Führen Sie in Python 2.7 einfach Folgendes aus:

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

kopieren-Einfügen von: http://docs.python.org/dev/library/collections.html#ordereddict-examples-and-recipes

Genießen ;-)

34
sweetdream

Technisch gesehen sind Wörterbücher keine Sequenzen und können daher nicht sortiert werden. Sie können so etwas tun

sorted(a_dictionary.values())

vorausgesetzt, Leistung ist keine große Sache.

26
Hank Gay

Wenn die Werte numerisch sind, können Sie auch Counter from collections verwenden.

from collections import Counter

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

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

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}

Rang

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

Versuchen Sie den folgenden Ansatz. Definieren wir ein Wörterbuch namens mydict mit den folgenden Daten:

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

Wenn man das Wörterbuch nach Schlüsseln sortieren wollte, konnte man etwas tun wie:

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

Dies sollte die folgende Ausgabe zurückgeben:

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

Wenn man dagegen ein Wörterbuch nach dem Wert sortieren möchte (wie in der Frage angegeben), kann 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 (Sortieren des Wörterbuchs nach Wert) sollte Folgendes zurückgeben:

bob: 1
alan: 2
danny: 3
carl: 40
23
Nathaniel Payne

Sie können auch einen "invertierten Index" erstellen

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

Jetzt hat Ihre Inverse die Werte; Jeder Wert enthält eine Liste der anwendbaren Schlüssel.

for k in sorted(inverse):
    print k, inverse[k]
21
S.Lott

Sie können den collections.Counter verwenden. Beachten Sie, dass dies sowohl für numerische als auch für nicht numerische Werte funktioniert.

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

Dies gibt die Liste der Schlüssel-Wert-Paare im Wörterbuch zurück, sortiert nach dem Wert vom höchsten zum niedrigsten:

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

Verwenden Sie für das nach Schlüssel sortierte Wörterbuch Folgendes:

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

Die Rückgabe ist eine Liste von Tupeln, da Wörterbücher selbst nicht sortiert werden können.

Dies kann sowohl ausgedruckt als auch zur weiteren Berechnung gesendet werden.

16
Zags

Ab Python 3.6 werden dict Objekte nun nach Einfügereihenfolge sortiert. 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}

Vorher mussten Sie OrderedDict verwenden.

Python 3.7-Dokumentation sagt:

In Version 3.7 geändert: Die Reihenfolge des Wörterbuchs ist garantiert die Reihenfolge des Einfügens. Dieses Verhalten war Implementierungsdetail von CPython ab 3.6.

16
Maxime Chéramy

Sie können ein dict überspringen verwenden, das ein Wörterbuch ist, das permanent nach Wert sortiert ist.

>>> 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, iterieren Sie in sortierter Reihenfolge nach Wert.

Die Implementierung erfolgt mit der Datenstruktur Liste überspringen .

15
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
13
Argun

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

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

Wie von Dilettant betont , Python 3.6 behält jetzt die Reihenfolge ! Ich dachte, ich würde eine von mir geschriebene Funktion mit anderen teilen, die das Sortieren eines iterablen Elements (Tupel, Liste, Diktat) erleichtert. Im letzteren Fall können Sie entweder nach Schlüsseln oder nach Werten sortieren und den numerischen Vergleich berücksichtigen. Nur für> = 3.6!

Wenn Sie versuchen, sortiert für eine Iteration zu verwenden, die z. Strings sowie Ints, Sorted () schlagen fehl. Natürlich können Sie den String-Vergleich mit str () erzwingen. In einigen Fällen möchten Sie jedoch einen tatsächlichen numerischen Vergleich durchführen, wobei 12 kleiner als 20 ist (was beim Zeichenfolgenvergleich nicht der Fall ist). Also habe ich mir folgendes ausgedacht. Wenn Sie einen expliziten numerischen Vergleich wünschen, können Sie das Flag num_as_num verwenden, das versucht, eine explizite numerische Sortierung durchzuführen, indem versucht wird, alle Werte in Gleitkommazahlen umzuwandeln. Wenn dies erfolgreich ist, wird eine numerische Sortierung durchgeführt, andernfalls wird auf einen Zeichenfolgenvergleich zurückgegriffen.

Verbesserungsvorschläge oder Push-Anfragen 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")
10
Bram Vanroy

Hier ist eine Lösung mit Zip on d.values() UND d.keys() . Ein paar Zeilen weiter unten (bei Dictionary-Ansichtsobjekten) ist:

Dies ermöglicht die Erstellung von (Wert-, Schlüssel-) Paaren mit Zip (): pairs = Zip (d.values ​​(), d.keys ()).

Wir können also Folgendes tun:

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

Verwenden Sie ValueSortedDict aus 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)]
7
ponty

Durchlaufen Sie ein Diktat und sortieren Sie es in absteigender Reihenfolge nach seinen Werten:

$ 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
6
juhoh

Wenn Ihre Werte Ganzzahlen sind und Sie Python 2.7 oder neuer verwenden, können Sie collections.Counter anstelle von dict verwenden. Mit der _most_common_ -Methode erhalten Sie alle Elemente, sortiert nach dem Wert.

6
Petr Viktorin

Ich kam mit diesem ein,

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

Für Python 3.x: x.items() ersetzt iteritems().

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

Oder versuchen Sie es mit 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]))
6
kiriloff

Sie können die sortierte Funktion von Python verwenden

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

So können Sie verwenden:

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

Besuchen Sie diesen Link für weitere Informationen zur sortierten Funktion: https://docs.python.org/2/library/functions.html#sorted

6
kkk

Ich habe gerade relevante Fertigkeiten von Python for Everybody gelernt.

Sie können eine temporäre Liste verwenden, 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 möchten, ändern Sie einfach die ursprüngliche Sortierzeile in:

tmp = sorted(tmp, reverse=True)

Unter Verwendung des Listenverständnisses wäre der eine Liner:

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

Denken Sie natürlich daran, dass Sie OrderedDict verwenden müssen, da reguläre Python Wörterbücher nicht die ursprüngliche Reihenfolge beibehalten.

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

Wenn Sie nicht über Python 2.7 oder höher verfügen, können Sie die Werte in einer Generatorfunktion am besten durchlaufen. (Es gibt ein OrderedDict für 2.4 und 2.6 hier , aber

a) Ich weiß nicht, wie gut es funktioniert

und

b) Sie müssen es natürlich herunterladen und installieren. Wenn Sie keinen Administratorzugriff haben, ist die Option leider nicht verfügbar.)


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 ausdrucken

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

Denken Sie daran, die Klammern nach dem Drucken zu entfernen, wenn Sie nicht Python 3.0 oder höher verwenden

5
ytpillai

Dies funktioniert in 3.1.x:

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

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

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

Aus Gründen der Abwärtskompatibilität mit älteren Versionen von Python halte ich die OrderedDict-Lösung für sehr unklug. Sie möchten etwas, das mit Python 2.7 und älteren Versionen funktioniert.

Die in einer anderen Antwort erwähnte Sammlungslösung ist jedoch absolut hervorragend, da Sie eine Verbindung zwischen dem Schlüssel und dem Wert neu trainieren, was im Fall von Wörterbüchern äußerst wichtig ist.

Ich bin nicht einverstanden mit der Wahl Nummer eins, die in einer anderen Antwort präsentiert wird, weil sie die Schlüssel wegwirft.

Ich habe die oben erwähnte Lösung (Code unten gezeigt) verwendet und den Zugriff auf Schlüssel und Werte beibehalten. In meinem Fall lag die Reihenfolge bei den Werten, aber die Wichtigkeit lag in der Reihenfolge der Schlüssel nach der Bestellung der Werte.

from collections import Counter

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


>> [('python', 5), ('world', 3), ('hello', 1)]
4
Eamonn Kenny
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
3
lessthanl0l

Thomas Cokelaer erklärt dies auf sehr elegante Weise. Ich möchte einen kurzen Hinweis auf seinen Artikel erwähnen.

Betrachten wir das folgende Wörterbuch.

d = {"Pierre": 42, "Anne": 33, "Zoe": 24}

Um anhand der Werte zu sortieren, werden einige der folgenden Ansätze vorgestellt.

sorted Funktion und operator Modul

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


sorted Funktion und lambda Funktion

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


sorted Funktion und Rückgabe eines bestellten Wörterbuchs

In den vorherigen Methoden sind die zurückgegebenen Objekte die Liste der Tupel. Wir haben also kein Wörterbuch mehr. Wir können ein OrderedDict verwenden, wenn wir es vorziehen.

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


sorted Funktion und Listenverständnis

sorted_d = sorted((value, key) for (key,value) in d.items())

He machte jedoch auch einen kurzen Vergleich des obigen Verfahrens.

3
iNet

Neben der Verwendung des eingebauten Moduls usw. versuche ich, es manuell zu lösen ..... zuerst habe ich eine Funktion erstellt, deren Aufgabe es ist, für jedes Element des Diktats einen minimalen Wert zurückzugeben:

def returnminDict(_dct):
    dict_items = _dct.items()
    list_items = list(dict_items)
    init_items = list_items[0]
    for i in range(len(list_items)):
        if list_items[i][1] > init_items[1]:
           continue
        else:
           init_items = list_items[i]
    return init_items

Zweitens , jetzt haben wir eine Funktion, die einen Gegenstand mit minimalem Wert zurückgibt, dann erstelle ich ein neues Diktat und schleife dann über das Diktat:

def SelectDictSort(_dct):
    new_dict = {}
    while _dct:
        mindict = returnminDict(_dct)
        new_dict.update(dict((mindict,)))
        _dct.pop(mindict[0])
    return new_dict

ich versuche dies SelectDictSort({2: 5, 5: 1, 4: 3, 1: 1, 0: 1, 9: 2, 8: 2}) wird zurückgeben:

{0: 1, 1: 1, 5: 1, 8: 2, 9: 2, 4: 3, 2: 5}

Hmmm ... ich weiß nicht, was richtig ist, aber das, was ich versucht habe ...

(aktualisierter Code von retrun new_dct auf return new_dict)

1
Wira Bhakti

Mit Python 3.2:

x = {"b":4, "a":3, "c":1}
for i in sorted(x.values()):
    print(list(x.keys())[list(x.values()).index(i)])
0
raton
>>> import collections
>>> x = {1: 2, 3: 4, 4:3, 2:1, 0:0}
>>> sorted_x = collections.OrderedDict(sorted(x.items(), key=lambda t:t[1]))
>>> OrderedDict([(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)])

OrderedDict ist eine Unterklasse von dict

0
liuzhijun

Diese Methode verwendet kein Lambda und funktioniert gut mit Python 3.6:

 # sort dictionary by value
d = {'a1': 'fsdfds', 'g5': 'aa3432ff', 'ca':'zz23432'}
def getkeybyvalue(d,i):
    for k, v in d.items():
        if v == i:
            return (k)

sortvaluelist = sorted(d.values())

# In >> Python 3.6+ << the INSERTION-ORDER of a dict is preserved. That is,
# when creating a NEW dictionary and filling it 'in sorted order',
# that order will be maintained.
sortresult ={}
for i1 in sortvaluelist:   
    key = getkeybyvalue(d,i1)
    sortresult[key] = i1
print ('=====sort by value=====')
print (sortresult)
print ('=======================')
0
xiyurui