Tengo un diccionario de valores leídos 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 es la clave del diccionario.

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

Nota: he leído la pregunta de 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 ordenar en orden ascendente o descendente.

respuesta

Python 3.7+ o CPython 3.6

Los dictados conservan el orden de inserción en Python 3.7+. Lo mismo en CPython 3.6, pero es un detalle de implementación .

>>> x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
>>> {k: v for k, v in sorted(x.items(), key=lambda item: item[1])}
{0: 0, 2: 1, 1: 2, 4: 3, 3: 4}

o

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

Python más antiguo

No es posible ordenar un diccionario, solo para obtener una representación de un diccionario ordenado. Los diccionarios son inherentemente sin orden, pero otros tipos, como las listas y las tuplas, no lo son. Por lo tanto, necesita un tipo de datos ordenados para representar valores ordenados, que serán una lista, 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_xserá una lista de tuplas ordenadas por el segundo elemento de 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, dado que no se permite desempaquetar , 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 la salida como un dictado, puede usar collections.OrderedDict:

import collections

sorted_dict = collections.OrderedDict(sorted_x)

Tan simple como:sorted(dict1, key=dict1.get)

Bueno, en realidad es posible hacer una "ordenación por valores de diccionario". Recientemente tuve que hacer eso en un Código de golf (Pregunta de desbordamiento de pila Código de golf: tabla de frecuencia de palabras ). Resumido, el problema era del tipo: dado un texto, contar con qué frecuencia se encuentra cada palabra y mostrar una lista de las palabras principales, ordenadas por frecuencia decreciente.

Si construye un diccionario con las palabras como claves y el número de ocurrencias de cada palabra como valor, simplificado 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 sorted(d, key=d.get)- la ordenación itera sobre las claves del diccionario, usando el número de apariciones de palabras como una clave de ordenació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 a menudo quiere decir con "Puedo ordenar fácilmente un diccionario por clave, pero ¿cómo puedo ordenar por valor?", y creo que la publicación original estaba tratando de abordar ese problema. Y la solución es hacer una especie de lista de claves, según los valores, como se muestra arriba.

Podrías 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 ordenarlo en orden descendente simplemente agregue reverse=True:

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

Aporte:

d = {'one':1,'three':3,'five':5,'two':2,'four':4}
a = sorted(d.items(), key=lambda x: x[1])    
print(a)

Producción:

[('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]

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

Una lista ordenada de valores dict:

sorted(d.values())

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

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

En Python 2.7 reciente, tenemos el nuevo tipo 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 hacer 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 dictado 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)])

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

Si bien encontré útil la respuesta aceptada, también me sorprendió que no se haya actualizado para hacer referencia a OrderedDict del módulo de colecciones de bibliotecas estándar 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)])

La documentación oficial de OrderedDict también ofrece un ejemplo muy similar, pero usando 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)])

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

A partir de Python 3.6 , se ordenará el dict incorporado

Buenas noticias, por lo que el caso de uso original del OP de mapeo de pares recuperados de una base de datos con identificadores de cadena únicos como claves y valores numéricos como valores en un dictado integrado de Python v3.6+, ahora debería respetar el orden de inserción.

Si dice las expresiones de tabla de dos 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, por supuesto), entonces:

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)

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

Donde en la instalación de Python 3.5 en mi máquina actualmente produce:

bar 1
foo 0
baz 42

Detalles:

Tal como lo propuso en 2012 Raymond Hettinger (cf. correo en python-dev con el asunto "Diccionarios más compactos con una iteración más rápida" ) y ahora (en 2016) anunciado en un correo de Victor Stinner a python-dev con el 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 "Diccionario compacto y ordenado" en Python 3.6, ¡ahora podremos usar un dictado integrado para mantener el orden de inserción!

Con suerte, esto conducirá 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 que abre el ordenamiento estable de:

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

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

El segundo, ya que incentiva a usar más fácilmente dicts como almacenamiento intermedio en las tuberías de procesamiento.

Raymond Hettinger proporcionó amablemente documentación que explica " La tecnología detrás de los diccionarios de Python 3.6 ", de su presentación del Grupo Meetup de Python en San Francisco el 8 de diciembre de 2016.

Y tal vez algunas páginas de preguntas y respuestas decoradas con Stack Overflow 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 preservación del orden de esta nueva implementación se considera un detalle de implementación y no se debe confiar en él". (de whatsnew36 ) no es quisquilloso, pero la cita se cortó un poco pesimista ;-). Continúa como "(esto puede cambiar en el futuro, pero se desea tener esta nueva implementación de dict en el idioma durante algunos lanzamientos antes de cambiar la especificación del idioma para exigir la semántica de preservación del orden para todas las implementaciones actuales y futuras de Python; esto también ayuda a preservar la compatibilidad con versiones anteriores del lenguaje donde el orden de iteración aleatoria todavía está vigente, por ejemplo, Python 3.5)".

Entonces, como en algunos idiomas humanos (por ejemplo, el alemán), el uso da forma al idioma, y ​​ahora se ha declarado la voluntad... en whatsnew36 .

Actualización 2017-12-15:

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

Make it so. "Dict keeps insertion order" is the ruling. Thanks!

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

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

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

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

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

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

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 Pythonicamente así:

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

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

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

(¡Las personas que respondieron "No es posible ordenar un dictado" no leyeron la pregunta! De hecho, "Puedo ordenar las claves, pero ¿cómo puedo ordenar según los valores?" claramente significa que quiere una lista de las claves ordenadas según el valor de sus valores.)

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

Si los valores son numéricos, también puede usar Counterfrom 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)]    

En Python 2.7, simplemente haz lo siguiente:

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#ordereddict-examples-and-recipes

Disfrutar ;-)

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}

Röfl

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

Pruebe el siguiente enfoque. Definamos 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, 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 otro lado, si 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) debería devolver lo siguiente:

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

A partir de Python 3.6, dictlos objetos ahora se ordenan 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.

La documentación de Python 3.7 dice:

Changed in version 3.7: Dictionary order is guaranteed to be insertion order. This behavior was implementation detail of CPython from 3.6.

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 inversa tiene los valores; cada valor tiene una lista de claves aplicables.

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

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

Puede usar un dictado de omisión , que es un diccionario que se ordena 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 keys(), values()o items()entonces iterará en orden ordenado por valor.

Se implementa utilizando la estructura de datos de la lista de saltos.

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

Por supuesto, recuerde, debe usar OrderedDictporque 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 generadora. (Hay un OrderedDictpara 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 no está disponible).


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 quitar los paréntesis después de imprimir si no usa Python 3.0 o superior

Aquí hay una solución usando zip on d.values()yd.keys() . Unas pocas líneas más abajo en este enlace (en los objetos de vista de diccionario) es:

This allows the creation of (value, key) pairs using 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')]

Como señaló Dilettant , ¡Python 3.6 ahora mantendrá el orden ! Pensé en compartir una función que escribí que facilita la clasificación de un iterable (tupla, lista, dictado). 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 sorted en un iterable que contiene, por ejemplo, cadenas e ints, sorted() fallará. Por supuesto, puede forzar la comparación de cadenas con str(). Sin embargo, en algunos casos, desea realizar una comparación numérica real12 donde es más pequeño que 20(que no es el caso en la comparación de cadenas). Así que se me ocurrió lo siguiente. Cuando desee una comparación numérica explícita, puede usar la bandera num_as_numque intentará realizar una clasificación numérica explícita al intentar convertir todos los valores en flotantes. Si eso tiene éxito, realizará una clasificación numérica; de lo contrario, recurrirá a la comparación de cadenas.

Comentarios para mejorar bienvenidos.

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

La solución de colecciones mencionada en otra respuesta es absolutamente excelente, porque conserva una conexión entre la clave y el valor que, en el caso de los diccionarios, es extremadamente importante.

No estoy de acuerdo con la opción número uno presentada en otra respuesta, porque tira las llaves.

Utilicé la solución mencionada anteriormente (el código que se muestra a continuación) y conservé el acceso tanto a las claves como a los valores y, en mi caso, el orden estaba en los valores, pero la importancia era el orden de las claves después de ordenar los valores.

from collections import Counter

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


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

Use ValueSortedDict de dictados :

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

Acabo de aprender una habilidad relevante de Python for Everybody .

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 listas, el trazador de líneas 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')]

Iterar a través de un dict y ordenarlo 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

Si sus valores son enteros y usa Python 2.7 o más reciente, puede usar collections.Counteren lugar de dict. El most_commonmétodo le dará todos los elementos, ordenados por valor.

Esto funciona en 3.1.x:

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

En aras de la exhaustividad, estoy publicando una solución usando 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)]