Comment trier un dictionnaire par valeur?

Question

J'ai un dictionnaire de valeurs lu à partir de deux champs d'une base de données: un champ de chaîne et un champ numérique. Le champ de chaîne est unique, il s'agit donc de la clé du dictionnaire.

Je peux trier les clés, mais comment puis-je trier en fonction des valeurs?

Remarque: j'ai lu la question du débordement de la pile ici Comment trier une liste de dictionnaires selon une valeur du dictionnaire? et pourrais probablement changer mon code pour avoir une liste de dictionnaires, mais comme je n’ai pas vraiment besoin d’une liste de dictionnaires, je voulais savoir s’il existe une solution plus simple pour trier par ordre croissant ou décroissant.

Answer 1

Il n’est pas possible de trier un dictionnaire, mais uniquement d’obtenir une représentation d’un dictionnaire trié. Les dictionnaires sont intrinsèquement sans ordre, mais d'autres types, tels que les listes et les n-uplets, ne le sont pas. Vous avez donc besoin d’un type de données ordonné pour représenter les valeurs triées, qui sera une liste, probablement une liste de n-uplets.

Par exemple,

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

triés_x sera une liste de n-uplets triés par le deuxième élément de chaque tuple. dict (sort_x) == x .

Et pour ceux qui souhaitent trier les clés au lieu de valeurs:

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

En Python3, le décompactage n'étant pas autorisé, [1] , nous pouvons utiliser

.

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

Si vous voulez que la sortie soit sous forme de dict, vous pouvez utiliser collections.OrderedDict :

import collections

sorted_dict = collections.OrderedDict(sorted_x)

Answer 2

Aussi simple que: trié (dict1, clé = dict1.get)

Eh bien, il est en fait possible de faire un "tri par valeur de dictionnaire". Récemment, je devais le faire dans un code golf (question de débordement de pile code golf: Tableau de fréquence de mots ). En résumé, le problème était du genre: à partir d'un texte, comptez la fréquence à laquelle chaque mot est rencontré et affichez une liste des mots les plus fréquents, triés par fréquence décroissante.

Si vous construisez un dictionnaire avec les mots comme clés et le nombre d'occurrences de chaque mot comme valeur, simplifié ici comme suit:

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

alors vous pouvez obtenir une liste des mots, classés par fréquence d'utilisation avec triés (d, clé = d.get) - le tri itère sur les clés du dictionnaire, en utilisant le nombre de mots occurrences comme une clé de tri.

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

J'écris cette explication détaillée pour illustrer ce que les gens veulent dire par "je peux facilement trier un dictionnaire par clé, mais comment puis-je trier par valeur" - et je pense que le PO essayait de résoudre un tel problème. Et la solution consiste à faire une sorte de liste des clés, en fonction des valeurs, comme indiqué ci-dessus.

Answer 3

Vous pouvez utiliser:

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

Ceci triera le dictionnaire en fonction des valeurs de chaque entrée du dictionnaire, du plus petit au plus grand.

Pour le trier par ordre décroissant, ajoutez simplement reverse = True :

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

Answer 4

Les dict ne peuvent pas être triés, mais vous pouvez en créer une liste triée.

Liste triée des valeurs dict:

sorted(d.values())

Liste des paires (clé, valeur) triées par valeur:

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

Answer 5

Dans Python 2.7 récent, nous avons le nouveau OrderedDict , qui mémorise l'ordre dans lequel les éléments ont été ajoutés.

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

Pour créer un nouveau dictionnaire ordonné à partir de l’original, triez-le par valeur:

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

OrderedDict se comporte comme un dict normal:

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

Answer 6

MISE À JOUR DU 5 DÉCEMBRE 2015 avec Python 3.5

Bien que j'ai trouvé la réponse acceptée utile, j'ai également été surprise qu'elle n'ait pas été mise à jour pour faire référence à OrderedDict à partir du module Collections de bibliothèques standard en tant qu’alternative viable et moderne, conçue pour résoudre exactement ce type de problème.

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

L'officiel OrderedDict La documentation offre également un exemple très similaire, mais en utilisant un lambda pour la fonction de tri:

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

Answer 7

Quasiment la même chose que réponse de Hank Gay :

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

Ou légèrement optimisé comme suggéré par John Fouhy:

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

Answer 8

Il peut souvent être très pratique d'utiliser namedtuple . Par exemple, vous avez un dictionnaire de 'nom' en tant que clés et de 'score' en tant que valeurs et vous souhaitez effectuer un tri sur 'score':

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

triez d'abord le score le plus bas:

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

trier avec le score le plus élevé en premier:

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

Vous pouvez maintenant obtenir le nom et le score de, disons le deuxième meilleur joueur (index = 1) très pythoniquement comme ceci:

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

Answer 9

À partir de Python 3.6 , le dict intégré sera commandé

Bonne nouvelle, le cas d'utilisation original des paires de mappage extraites d'une base de données avec des identificateurs de chaîne uniques en tant que clés et des valeurs numériques en tant que valeurs dans une version intégrée de Python v3.6 + dict devrait désormais respecter l'ordre d'insertion.

/ p>

Si, par exemple, les expressions de table à deux colonnes obtenues à partir d'une requête de base de données, telles que:

SELECT a_key, a_value FROM a_table ORDER BY a_value;

serait stocké dans deux tuples Python, k_seq et v_seq (alignés par un index numérique et avec la même durée de parcours), puis:

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

Autoriser la sortie ultérieure sous:

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

cédant dans ce cas (pour le nouveau dict intégré de Python 3.6+!):

foo 0
bar 1
baz 42

dans le même ordre par valeur de v.

À quel endroit de l'installation de Python 3.5 sur ma machine, il génère actuellement:

bar 1
foo 0
baz 42

Détails:

Tel que proposé par Raymond Hettinger en 2012 (cf. mail sur python-dev avec le sujet "Dictionnaires plus compacts avec une itération plus rapide ) et maintenant (en 2016) annoncés dans un courrier de Victor Stinner à python-dev avec le sujet " Python 3.6 dict devient compact et obtient une version privée; et les mots clés sont classés par ordre " en raison de la résolution / mise en oeuvre du problème 27350 " Compact et ordonné dict "

Espérons que cela débouchera dans un premier temps sur une implémentation de OrderedDict en couche mince. Comme @ JimFasarakis-Hilliard l'a indiqué, certains voient les cas d'utilisation du type OrderedDict également à l'avenir. Je pense que la communauté Python en général va soigneusement inspecter, si cela résistera à l'épreuve du temps, et quelles seront les prochaines étapes.

Il est temps de repenser nos habitudes de codage afin de ne pas rater les possibilités ouvertes par la commande stable de:

• Arguments de mots clés et
• stockage de dict (intermédiaire)

Le premier, car il facilite dans certains cas la répartition des tâches dans les fonctions et les méthodes.

La seconde, car elle encourage à utiliser plus facilement les dict comme stockage intermédiaire dans les pipelines de traitement.

Raymond Hettinger a gracieusement fourni une documentation expliquant la procédure " La technologie Derrière les dictionnaires Python 3.6 " - extrait de sa présentation du groupe de rencontres San Francisco Python 2016-DÉC-08.

Et peut-être que certaines pages de questions et réponses très décorées de Stack Overflow recevront des variantes de cette information et de nombreuses réponses de haute qualité nécessiteront également une mise à jour par version.

Caveat Emptor (mais aussi voir ci-dessous la mise à jour 2017-12-15):

Comme @ajcr l'a fait remarquer à juste titre: "L'aspect de préservation de l'ordre de cette nouvelle implémentation est considéré comme un détail d'implémentation et ne doit pas être pris en compte." (à partir du whatsnew36 ) ne pas choisir, mais la citation était un peu pessimiste ;-). Il continue comme " (Cela peut changer dans le futur, mais nous souhaitons avoir cette nouvelle implémentation dict dans le langage de quelques versions avant de changer la spécification de la langue afin d’imposer une sémantique préservant les ordres pour toutes les implémentations actuelles et futures de Python. compatibilité avec les anciennes versions du langage où l'ordre d'itération aléatoire est toujours actif, par exemple Python 3.5). "

Comme dans certaines langues humaines (par exemple l'allemand), l'usage façonne la langue et le testament a maintenant été déclaré ... dans whatsnew36 .

Mise à jour le 15/12/2017:

Dans un mail à la liste python-dev , Guido van Rossum a déclaré:

  

Faites en sorte. "Dict conserve l'ordre d'insertion". est la décision. Merci!

Ainsi, l'effet secondaire de la commande d'insertion dict dans CPython version 3.6 est en train de devenir partie intégrante de la spécification de langage (et non plus uniquement d'un détail d'implémentation). Ce fil de discussion a également abordé certains objectifs de conception distinctifs pour les collections.OrderedDict , comme l'a rappelé Raymond Hettinger au cours de la discussion.

Answer 10

J'ai eu le même problème et je l'ai résolu comme suit:

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

(Les personnes ayant répondu "Il n'est pas possible de trier un dict" n'ont pas lu la question! En fait, "Je peux trier les clés, mais comment puis-je trier en fonction des valeurs?" signifie clairement qu'il souhaite une liste des clés triées en fonction de la valeur de leurs valeurs.)

Veuillez noter que l'ordre n'est pas bien défini (les clés avec la même valeur seront dans un ordre arbitraire dans la liste de sortie).

Answer 11

En Python 2.7, il suffit de faire:

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

copier-coller à partir de: http://docs.python.org/ dev / library / collections.html # ordereddict-exemples-and-recipes

Profitez ;-)

Answer 12

Ceci est le 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

Voici les résultats:

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}

Classement

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

Answer 13

Si les valeurs sont numériques, vous pouvez également utiliser Compteur sur les collections .

from collections import Counter

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

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

Answer 14

Essayez l’approche suivante. Définissons un dictionnaire appelé mydict avec les données suivantes:

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

Si l'on veut trier le dictionnaire par clé, on peut faire quelque chose comme:

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

Ceci devrait renvoyer le résultat suivant:

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

D'autre part, si l'on souhaite trier un dictionnaire par valeur (comme le demande la question), on peut procéder comme suit:

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

Le résultat de cette commande (triant le dictionnaire par valeur) devrait renvoyer ce qui suit:

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

Answer 15

Vous pouvez créer un "index inversé", également

.

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

Votre inverse a maintenant les valeurs; chaque valeur a une liste de clés applicables.

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

Answer 16

Vous pouvez utiliser le collections.Counter . Notez que cela fonctionnera pour les valeurs numériques et non numériques.

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

Answer 17

À partir de Python 3.6, les objets dict sont maintenant classés par ordre d'insertion. C'est officiellement dans les spécifications de 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}

Avant cela, vous deviez utiliser OrderedDict .

La

documentation sur Python 3.7 dit:

  

Modifié dans la version 3.7: l'ordre d'insertion du dictionnaire est garanti   ordre. Ce comportement était le détail d'implémentation de CPython à partir de 3.6.

Answer 18

Vous pouvez utiliser un ignorer le dict , qui est un dictionnaire classé de manière permanente par valeur.

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

Si vous utilisez des clés () , des valeurs () ou des éléments () , vous effectuerez une itération dans l'ordre trié par valeur.

Il est implémenté à l'aide de la Ignorer la liste .

Answer 19

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

Answer 20

Vous pouvez également utiliser une fonction personnalisée pouvant être transmise à la clé.

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)

Answer 21

Comme l'a souligné Dilettant , Python 3.6 va maintenant garder la commande ! Je pensais partager une fonction que j'ai écrite qui facilite le tri d'un itérable (tuple, liste, dict). Dans ce dernier cas, vous pouvez trier les clés ou les valeurs et prendre en compte la comparaison numérique. Seulement pour > = 3,6!

Lorsque vous essayez d'utiliser une option triée sur une valeur pouvant être vérifiée, par exemple. Les chaînes ainsi que les ints, sortis () échoueront. Bien sûr, vous pouvez forcer la comparaison de chaînes avec str (). Toutefois, dans certains cas, vous souhaitez effectuer une comparaison numérique réelle où 12 est inférieur à 20 (ce qui n'est pas le cas dans la comparaison de chaînes). Alors je suis venu avec ce qui suit. Lorsque vous souhaitez une comparaison numérique explicite, vous pouvez utiliser l'indicateur num_as_num qui essaiera d'effectuer un tri numérique explicite en essayant de convertir toutes les valeurs en valeurs flottantes. Si cela réussit, il effectuera un tri numérique, sinon il aura recours à la comparaison de chaînes.

Commentaires pour amélioration ou demandes push bienvenue.

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

Answer 22

Voici une solution utilisant zip sur d. values ??() et d.keys () . Quelques lignes en bas de ce lien (sur les objets de la vue Dictionnaire):

  

Ceci permet la création de paires (valeur, clé) à l'aide de zip (): pairs = zip (d.values ??(), d.keys ()).

Nous pouvons donc procéder comme suit:

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

Answer 23

Utilisez ValueSortedDict à partir des 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)]

Answer 24

Parcourez un dict et triez-le par ordre décroissant:

$ 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

Answer 25

Si vos valeurs sont des entiers et que vous utilisez Python 2.7 ou une version ultérieure, vous pouvez utiliser collections.Counter au lieu de dict . La méthode most_common vous donnera tous les éléments, triés par valeur.

Answer 26

Bien sûr, rappelez-vous que vous devez utiliser OrderedDict car les dictionnaires Python standard ne conservent pas la commande d'origine.

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

Si vous ne possédez pas Python 2.7 ou une version ultérieure, le mieux que vous puissiez faire est d'effectuer une itération sur les valeurs d'une fonction du générateur. (Il existe un OrderedDict pour les versions 2.4 et 2.6, ici , mais

a) Je ne sais pas si ça marche bien

et

b) Vous devez le télécharger et l’installer bien sûr. Si vous ne disposez pas d'un accès administrateur, alors je crains que l'option ne soit supprimée.)

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

Vous pouvez également imprimer chaque valeur

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

N'oubliez pas de supprimer les parenthèses après l'impression si vous n'utilisez pas Python 3.0 ou une version ultérieure

Answer 27

Ceci fonctionne en 3.1.x:

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

Answer 28

Par souci d'exhaustivité, je publie une solution à l'aide de heapq . Notez que cette méthode fonctionnera pour les valeurs numériques et non numériques

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

Answer 29

Vient d'acquérir une compétence pertinente auprès de Python pour tout le monde . .

Vous pouvez utiliser une liste temporaire pour vous aider à trier le dictionnaire:

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

Si vous souhaitez trier la liste par ordre décroissant, remplacez simplement la ligne de tri d'origine par:

tmp = sorted(tmp, reverse=True)

En utilisant la compréhension de liste, le liner serait:

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

Exemple de sortie:

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

Answer 30

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