¿Cómo ordeno un diccionario por valor?

Question

Tengo un diccionario de valores leído de dos campos en una base de datos: un campo de cadena y un campo numérico. El campo de cadena es único, por lo que esa es la clave del diccionario.

Puedo ordenar las claves, pero ¿cómo puedo clasificar según los valores?

Nota: He leído la pregunta sobre el desbordamiento de pila aquí ¿Cómo ordeno una lista de diccionarios por un valor del diccionario? y probablemente podría cambiar mi código para tener una lista de diccionarios, pero como realmente no necesito una lista de diccionarios, quería saber si hay una solución más simple para clasificar en orden ascendente o descendente.

Answer 1

No es posible ordenar un diccionario, solo para obtener una representación de un diccionario que está ordenado. Los diccionarios son intrínsecamente sin orden, pero otros tipos, como listas y tuplas, no lo son. Por lo tanto, necesita un tipo de datos ordenados para representar los valores ordenados, que será una lista & # 8212; probablemente una lista de tuplas.

Por ejemplo,

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

sorted_x será una lista de tuplas ordenadas por el segundo elemento en cada tupla. dict (sorted_x) == x .

Y para aquellos que deseen ordenar claves en lugar de valores:

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

En Python3, ya que no se permite el desempaque [1] podemos usar

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

Si desea que la salida sea un dict, puede usar collections.OrderedDict :

import collections

sorted_dict = collections.OrderedDict(sorted_x)

Answer 2

Tan simple como: ordenado (dict1, clave = dict1.get)

Bueno, en realidad es posible hacer un "ordenar por valores de diccionario". Recientemente tuve que hacer eso en un Código de golf (pregunta de desbordamiento de pila Código de golf: Gráfico de frecuencia de palabras ). En resumen, el problema era del mismo tipo: dado un texto, cuente con qué frecuencia se encuentra cada palabra y muestre una lista de las palabras principales, ordenadas por frecuencia decreciente.

Si construye un diccionario con las palabras como claves y el número de apariciones de cada palabra como valor, se simplifica aquí como:

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

luego puede obtener una lista de las palabras, ordenadas por frecuencia de uso con ordenadas (d, clave = d.get) : la ordenación se repite sobre las claves del diccionario, usando el número de palabras ocurrencias como una clave de clasificación.

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

Estoy escribiendo esta explicación detallada para ilustrar lo que la gente suele decir con "Puedo ordenar fácilmente un diccionario por clave, pero ¿cómo puedo ordenar por valor"? - Y creo que el OP estaba tratando de abordar este problema. Y la solución es hacer una lista de las claves, según los valores, como se muestra arriba.

Answer 3

Puedes usar:

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

Esto ordenará el diccionario por los valores de cada entrada dentro del diccionario de menor a mayor.

Para clasificarlo en orden descendente, simplemente agregue reverse = True :

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

Answer 4

Los dictados no se pueden ordenar, pero puedes construir una lista ordenada a partir de ellos.

Una lista ordenada de valores de dict:

sorted(d.values())

Una lista de pares (clave, valor), ordenados por valor:

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

Answer 5

En Python 2.7 reciente, tenemos el nuevo OrderedDict , que recuerda el orden en que se agregaron los elementos.

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

Para crear un nuevo diccionario ordenado a partir del original, ordenando por los valores:

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

El OrderedDict se comporta como 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

ACTUALIZACIÓN: 5 DE DICIEMBRE DE 2015 utilizando Python 3.5

Aunque encontré útil la respuesta aceptada, también me sorprendió que no se haya actualizado para hacer referencia a OrderedDict de la biblioteca estándar colecciones como una alternativa viable y moderna, diseñada para resolver exactamente este tipo de problema.

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

El oficial OrderedDict La documentación también ofrece un ejemplo muy similar, pero utilizando una lambda para la función de clasificación:

# 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

Más o menos lo mismo que La respuesta de Hank Gay :

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

O optimizado ligeramente como lo sugiere John Fouhy:

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

Answer 8

A menudo puede ser muy útil usar namedtuple . Por ejemplo, tiene un diccionario de 'nombre' como claves y 'puntuación' como valores y desea clasificar en 'puntuación':

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

ordenar primero con la puntuación más baja:

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

ordenar primero con la puntuación más alta:

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

Ahora puede obtener el nombre y la puntuación de, digamos el segundo mejor jugador (índice = 1) muy pitónicamente como este:

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

Answer 9

A partir de Python 3.6 se ordenará el dictado incorporado

Buenas noticias, por lo que el caso de uso original del OP de pares de mapas recuperados de una base de datos con ids de cadenas únicas como claves y valores numéricos como valores en un dictado de Python v3.6 + incorporado, ahora debe respetar el orden de inserción.

Si dice las dos expresiones de tabla de columnas resultantes de una consulta de base de datos como:

SELECT a_key, a_value FROM a_table ORDER BY a_value;

se almacenaría en dos tuplas de Python, k_seq y v_seq (alineadas por índice numérico y con la misma longitud de curso), luego:

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

Permitir la salida más tarde como:

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

cediendo en este caso (¡para el nuevo dict incorporado de Python 3.6+!):

foo 0
bar 1
baz 42

en el mismo orden por valor de v.

En la instalación de Python 3.5 en mi máquina, actualmente se obtiene:

bar 1
foo 0
baz 42

Detalles:

Como lo propuso Raymond Hettinger en 2012 (consulte el correo en python-dev con el tema " Diccionarios más compactos con iteración más rápida " ) y ahora (en 2016) anunciados en un correo de Victor Stinner a python-dev con asunto " Python 3.6 dict se convierte en compacto y obtiene una versión privada; y las palabras clave se ordenan " debido a la corrección / implementación del problema 27350 " Compacto y ordenado " en Python 3.6 ahora podremos usar un dict incorporado para mantener el orden de inserción.

Esperemos que esto conduzca a una implementación de OrderedDict de capa delgada como primer paso. Como indicó @ JimFasarakis-Hilliard, algunos ven casos de uso para el tipo OrderedDict también en el futuro. Creo que la comunidad de Python en general inspeccionará cuidadosamente, si esto resistirá la prueba del tiempo, y cuáles serán los próximos pasos.

Es hora de repensar nuestros hábitos de codificación para no perder las posibilidades abiertas por un pedido estable de:

• Argumentos de palabras clave y
• (intermedio) dict almacenamiento

El primero porque facilita el despacho en la implementación de funciones y métodos en algunos casos.

El segundo, ya que fomenta el uso más fácil de dict s como almacenamiento intermedio en las canalizaciones de procesamiento.

Raymond Hettinger proporcionó amablemente la documentación que explica " La tecnología detrás de los diccionarios Python 3.6 " - de su presentación del Grupo de Meetup de Python de San Francisco 2016-DEC-08.

Y tal vez algunas páginas de preguntas y respuestas con mucha decoración de Overflow de Stack recibirán variantes de esta información y muchas respuestas de alta calidad también requerirán una actualización por versión.

Caveat Emptor (pero también vea la actualización a continuación 2017-12-15):

Como @ajcr señala acertadamente: " El aspecto de preservar el orden de esta nueva implementación se considera un detalle de implementación y no se debe confiar en él. " (de whatsnew36 ) no selección de liendres, pero La cita fue cortada un poco pesimista ;-). Continúa como " (Esto puede cambiar en el futuro, pero se desea tener esta nueva implementación de dict en el lenguaje para algunas versiones antes de cambiar la especificación del idioma para ordenar la semántica de preservación de órdenes para todas las implementaciones actuales y futuras de Python; esto también ayuda a preservar al revés. compatibilidad con versiones anteriores del lenguaje donde el orden de iteración aleatoria todavía está vigente, por ejemplo, Python 3.5). "

Así como en algunos idiomas humanos (por ejemplo, alemán), el uso configura el idioma, y ??ahora se ha declarado la voluntad ... en whatsnew36 .

Actualización 2017-12-15:

En un correo a la lista de python-dev , Guido van Rossum declaró:

  

Hazlo así. " Dict mantiene el orden de inserción " es el fallo ¡Gracias!

Por lo tanto, el efecto secundario de la versión 3.6 CPython del orden de inserción de dict ahora se está convirtiendo en parte de la especificación del lenguaje (y ya no es solo un detalle de implementación). Ese hilo de correo también surgió algunos objetivos de diseño distintivos para collections.OrderedDict , como lo recordó Raymond Hettinger durante la discusión.

Answer 10

Tuve el mismo problema, y ??lo resolví así:

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

(Las personas que responden " No es posible ordenar un dict " ¡no han leído la pregunta! De hecho, " Puedo ordenar en las teclas, pero ¿cómo puedo ordenar en función de los valores? '' significa claramente que quiere una lista de las claves ordenadas de acuerdo con el valor de sus valores.)

Tenga en cuenta que el pedido no está bien definido (las claves con el mismo valor estarán en un orden arbitrario en la lista de resultados).

Answer 11

En Python 2.7, simplemente haz:

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

copiar y pegar desde: http://docs.python.org/ dev / library / collections.html # orderdict-examples-and-recipes

Disfruta ;-)

Answer 12

Este es el código:

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

Aquí están los resultados:

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}

Rango

{'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 los valores son numéricos, también puede usar Counter de colecciones .

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

Pruebe el siguiente enfoque. Permítanos definir un diccionario llamado mydict con los siguientes datos:

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

Si uno quisiera ordenar el diccionario por claves, se podría hacer algo como:

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

Esto debería devolver el siguiente resultado:

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

Por otra parte, si uno quisiera ordenar un diccionario por valor (como se pregunta en la pregunta), podría hacer lo siguiente:

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

El resultado de este comando (ordenar el diccionario por valor) debe devolver lo siguiente:

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

Answer 15

Puede crear un " índice invertido " ;, también

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

Ahora tu inverso tiene los valores; cada valor tiene una lista de claves aplicables.

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

Answer 16

Puede usar collections.Counter . Tenga en cuenta que esto funcionará tanto para valores numéricos como no numéricos.

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

A partir de Python 3.6, los objetos dict ahora están ordenados por orden de inserción. Está oficialmente en las especificaciones 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}

Antes de eso, tenías que usar OrderedDict .

documentación de Python 3.7 dice:

  

Modificado en la versión 3.7: se garantiza que el orden del diccionario sea inserción   orden. Este comportamiento fue detalle de implementación de CPython desde 3.6.

Answer 18

Puede usar un skip dict , que es un diccionario que está ordenado permanentemente por valor.

>>> 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 usa las teclas () , values ??() o items () , iterará en orden ordenado por valor.

Se implementa utilizando la lista de omisión estructura de datos.

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

También puede usar una función personalizada que se puede pasar a la clave.

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

Como lo señaló Dilettant , Python 3.6 ahora mantendrá el orden . Pensé que compartiría una función que escribí que facilita la clasificación de un iterable (tupla, lista, dict). En el último caso, puede ordenar por claves o valores, y puede tener en cuenta la comparación numérica. ¡Solo para > = 3.6!

Cuando intenta usar ordenado en un iterable que contiene, p. cadenas así como ints, sorted () fallará. Por supuesto, puede forzar la comparación de cadenas con str (). Sin embargo, en algunos casos, desea hacer una comparación numérica real donde 12 es menor que 20 (que no es el caso en la comparación de cadenas). Entonces se me ocurrió lo siguiente. Cuando desee una comparación numérica explícita, puede utilizar el indicador num_as_num , que intentará realizar una clasificación numérica explícita al tratar de convertir todos los valores a flotantes. Si eso tiene éxito, hará una ordenación numérica, de lo contrario recurrirá a la comparación de cadenas.

Comentarios para mejoras o solicitudes de inserción bienvenido.

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

Aquí hay una solución usando zip en d. valores () y d.keys () . Unas pocas líneas en este enlace (en los objetos de la vista de Diccionario) es:

  

Esto permite la creación de pares (valor, clave) usando zip (): pairs = zip (d.values ??(), d.keys ()).

Entonces podemos hacer lo siguiente:

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

Utilice ValueSortedDict de 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

Iterar a través de un dict y ordenarlos por sus valores en orden descendente:

$ 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 sus valores son enteros, y usa Python 2.7 o más reciente, puede usar collections.Counter en lugar de dict . El método most_common le dará todos los elementos, ordenados por el valor.

Answer 26

Por supuesto, recuerde, debe usar OrderedDict porque los diccionarios regulares de Python no mantienen el orden original.

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

---

Si no tiene Python 2.7 o superior, lo mejor que puede hacer es iterar sobre los valores en una función de generador. (Hay un OrderedDict para 2.4 y 2.6 aquí , pero

a) No sé qué tan bien funciona

y

b) Tienes que descargarlo e instalarlo por supuesto. Si no tiene acceso administrativo, me temo que la opción está fuera.

---

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

---

También puede imprimir cada valor

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

Recuerde eliminar los paréntesis después de la impresión si no utiliza Python 3.0 o superior

Answer 27

Esto funciona en 3.1.x:

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

Answer 28

En aras de la integridad, estoy publicando una solución utilizando heapq . Tenga en cuenta que este método funcionará tanto para valores numéricos como no numéricos

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

Acabo de aprender habilidades relevantes de Python para todos .

Puede usar una lista temporal para ayudarlo a ordenar el diccionario:

#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 desea ordenar la lista en orden descendente, simplemente cambie la línea de clasificación original a:

tmp = sorted(tmp, reverse=True)

Usando la comprensión de la lista, la única línea sería:

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

Salida de muestra:

#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