Как мне отсортировать словарь по значению?

Question

У меня есть словарь значений, считанных из двух полей в базе данных:строковое поле и числовое поле.Поле string уникально, так что это ключ словаря.

Я могу выполнить сортировку по ключам, но как я могу выполнить сортировку на основе значений?

Примечание:Я прочитал вопрос о переполнении стека здесь Как мне отсортировать список словарей по значению словаря? и, вероятно, мог бы изменить свой код, чтобы в нем был список словарей, но поскольку мне на самом деле не нужен список словарей, я хотел знать, есть ли более простое решение для сортировки по возрастанию или по убыванию.

Answer 1

Невозможно отсортировать словарь, только чтобы получить представление отсортированного словаря. Словари по своей природе беспорядочные, но другие типы, такие как списки и кортежи, - нет. Таким образом, вам нужен упорядоченный тип данных для представления отсортированных значений, который будет списком & # 8212; вероятно, списком кортежей.

Например,

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

sorted_x будет списком кортежей, отсортированным по второму элементу в каждом кортеже. dict (sorted_x) == x .

А для желающих сортировать по ключам вместо значений:

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

В Python3 распаковка запрещена. [1] мы можем использовать

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

Если вы хотите, чтобы выходные данные были в форме комментария, вы можете использовать collections.OrderedDict :

import collections

sorted_dict = collections.OrderedDict(sorted_x)

Answer 2

Так же просто, как: sorted(dict1, key=dict1.get)

Ну, на самом деле можно выполнить "сортировку по словарным значениям".Недавно мне пришлось сделать это в Code Golf (вопрос о переполнении стека Код гольф:Диаграмма частотности слов).В сокращенном виде проблема была такого рода:получив текст, подсчитайте, как часто встречается каждое слово, и выведите на экран список самых популярных слов, отсортированных по убыванию частоты.

Если вы создадите словарь со словами в качестве ключей и количеством вхождений каждого слова в качестве значения, упрощенный здесь как:

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

затем вы можете получить список слов, упорядоченных по частоте употребления с sorted(d, key=d.get) - сортировка выполняется по ключам словаря, используя количество вхождений слова в качестве ключа сортировки.

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

Я пишу это подробное объяснение, чтобы проиллюстрировать, что люди часто подразумевают под "Я могу легко отсортировать словарь по ключу, но как мне отсортировать по значению" - и я думаю, что OP пытался решить такую проблему.И решение состоит в том, чтобы составить своего рода список ключей, основанный на значениях, как показано выше.

Answer 3

Вы можете использовать:

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

Это позволит отсортировать словарь по значениям каждой записи в словаре от наименьшего к наибольшему.

Чтобы отсортировать его в порядке убывания, просто добавьте reverse = True :

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

Answer 4

Дики не могут быть отсортированы, но вы можете создать отсортированный список из них.

Сортированный список значений dict:

sorted(d.values())

Список пар (ключ, значение), отсортированных по значению:

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

Answer 5

В недавнем Python 2.7 у нас есть новые OrderedDict , который запоминает порядок добавления элементов.

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

Чтобы создать новый упорядоченный словарь из оригинала, сортируя по значениям:

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

OrderedDict ведет себя как обычный диктант:

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

ОБНОВЛЕНИЕ: 5 декабря 2015 года с использованием Python 3.5

Хотя я нашел полезный ответ, я также был удивлен, что он не был обновлен до ссылки OrderedDict из стандартного модуля библиотеки collection как жизнеспособная современная альтернатива, предназначенная для решения именно этого типа проблем.

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

Официальный OrderedDict Документация также предлагает очень похожий пример, но с использованием лямбды для функции сортировки:

# 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

Почти так же, как и ответ Хэнка Гея :

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

Или слегка оптимизирован, как это было предложено Джоном Фухи:

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

Answer 8

Часто это может быть очень удобно в использовании названный двойкой.Например, у вас есть словарь "name" в качестве ключей и "score" в качестве значений, и вы хотите выполнить сортировку по "score":

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

сортировка с наименьшим количеством баллов в первую очередь:

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

сортировка с наибольшим количеством баллов в первую очередь:

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

Теперь вы можете получить имя и оценку, скажем, второго лучшего игрока (индекс = 1), очень по-питонически, вот так:

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

Answer 9

По состоянию на Python 3.6 встроенный dict будет заказан

Хорошие новости, таким образом, первоначальный вариант использования OP для сопоставления пар, извлеченных из базы данных с уникальными идентификаторами строк в качестве ключей и числовыми значениями в качестве значений, во встроенный Python v3.6 + dict, теперь должен соблюдать порядок вставки.

Если, скажем, результирующие выражения таблицы с двумя столбцами из запроса к базе данных, например:

SELECT a_key, a_value FROM a_table ORDER BY a_value;

будет сохранен в двух кортежах Python, k_seq и v_seq (выровненных по числовому индексу и, конечно, одинаковой длины), тогда:

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

Разрешить выводить позже как:

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

уступающий в этом случае (для нового Python 3.6+ встроенный dict!):

foo 0
bar 1
baz 42

в том же порядке по значению v.

Где в установке Python 3.5 на моей машине он в настоящее время выдает:

bar 1
foo 0
baz 42

Подробные сведения:

Как предложил в 2012 году Раймонд Хеттингер (ср.письмо на python-dev с темой "Более компактные словари с более быстрой итерацией") и теперь (в 2016 году) анонсировано в письме Виктора Стиннера python-dev с темой "Python 3.6 dict становится компактным и получает закрытую версию;и ключевые слова становятся упорядоченными " из-за исправления / реализации проблемы 27350 "Компактный и упорядоченный диктант" в Python 3.6 теперь мы сможем использовать встроенный dict для поддержания порядка вставки!!

Надеюсь, это приведет к тонкослойной реализации OrderedDict в качестве первого шага.Как указал @JimFasarakis-Hilliard, некоторые видят варианты использования типа OrderedDict также в будущем.Я думаю, что сообщество Python в целом тщательно проверит, выдержит ли это испытание временем и какими будут следующие шаги.

Пришло время переосмыслить наши привычки кодирования, чтобы не упустить возможности, открывающиеся благодаря стабильному упорядочиванию:

• Аргументы ключевого слова и
• (промежуточное) хранилище диктовки

Первый потому, что в некоторых случаях это облегчает диспетчеризацию при реализации функций и методов.

Второй, поскольку он побуждает к более легкому использованию dictиспользуется в качестве промежуточного хранилища в технологических трубопроводах.

Рэймонд Хеттингер любезно предоставил документацию , объясняющую "Технология, лежащая в основе словарей Python 3.6" - из его презентации группы Python Meetup в Сан-Франциско, 2016,08 декабря.

И, возможно, довольно много страниц вопросов и ответов с высоким уровнем переполнения стека получат варианты этой информации, и многие высококачественные ответы также потребуют обновления для каждой версии.

Будьте внимательны (но также смотрите ниже обновление 2017-12-15):

Как справедливо отмечает @ajcr:"Аспект сохранения порядка в этой новой реализации считается деталью реализации, и на него не следует полагаться". (из что новое36) не придирчивый выбор, но цитата была сокращена немного пессимистично ;-).Это продолжается как " (это может измениться в будущем, но желательно иметь эту новую реализацию dict в языке для нескольких выпусков, прежде чем изменять спецификацию языка, чтобы обеспечить сохранение порядка семантики для всех текущих и будущих реализаций Python;это также помогает сохранить обратную совместимость со старыми версиями языка, где все еще действует случайный порядок итераций, напримерPython 3.5)."

Так как в некоторых человеческих языках (например,Немецкий), использование формирует язык, и теперь воля объявлена ...в что новое36.

Обновление 2017-12-15:

В отправить письмо в список разработчиков python, Заявил Гвидо ван Россум:

Сделай это так."Dict сохраняет порядок вставки" - это правило.Спасибо!

Итак, побочный эффект CPython версии 3.6 упорядочения вставки dict теперь становится частью спецификации языка (а не только деталью реализации).В этой почтовой ветке также всплыли некоторые отличительные цели дизайна для collections.OrderedDict как напомнил Рэймонд Хеттингер во время обсуждения.

Answer 10

У меня была та же проблема, и я решил ее так:

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

(Люди, которые отвечают на вопрос "Сортировать диктовку не представляется возможным", не читали вопрос! На самом деле "Я могу сортировать по ключам, но как я могу сортировать по значениям?" что он хочет список ключей, отсортированных по значению их значений.)

Обратите внимание, что порядок не определен правильно (ключи с одинаковыми значениями будут в произвольном порядке в списке вывода).

Answer 11

В Python 2.7 просто выполните:

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

скопируйте и вставьте из: http://docs.python.org/ DEV / библиотека / collections.html # ordereddict-примеры-и-рецепты

Наслаждайтесь; -)

Answer 12

Это и есть код:

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

Вот результаты:

Оригинал

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

Рофл

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

Ранг

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

Если значения являются числовыми, вы также можете использовать Counter из коллекций .

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

Попробуйте следующий подход. Давайте определим словарь mydict со следующими данными:

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

Если кто-то хочет отсортировать словарь по ключам, можно сделать что-то вроде:

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

Это должно вернуть следующий вывод:

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

С другой стороны, если кто-то хочет отсортировать словарь по значению (как задается в вопросе), можно сделать следующее:

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

Результат этой команды (сортировка словаря по значению) должен вернуть следующее:

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

Answer 15

Вы также можете создать «инвертированный индекс», также

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

Теперь ваш обратный имеет значения; у каждого значения есть список применимых ключей.

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

Answer 16

Вы можете использовать collection.Counter . Обратите внимание, что это будет работать как для числовых, так и для нечисловых значений.

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

Начиная с Python 3.6, объекты dict теперь упорядочены по порядку вставки. Это официально в спецификациях 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}

До этого вам приходилось использовать OrderedDict .

Документация по Python 3.7 гласит:

  

Изменено в версии 3.7: порядок словаря гарантированно будет вставлен   порядок. Такое поведение было деталью реализации CPython от 3.6.

Answer 18

Вы можете использовать пропустить диктант это словарь, который постоянно сортируется по значению.

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

Если вы используете keys(), values() или items() затем вы выполните итерацию в порядке сортировки по значению.

Это реализовано с использованием пропустить список структура данных.

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

Вы также можете использовать пользовательскую функцию, которую можно передать ключу.

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

Как указывает Dilettant , Python 3.6 теперь будет поддерживать порядок ! Я думал, что у меня будет функция, которую я написал, которая облегчает сортировку итерируемого (кортеж, список, dict). В последнем случае вы можете сортировать либо по ключам, либо по значениям, и это может учитывать числовое сравнение. Только для > = 3,6!

Когда вы пытаетесь использовать сортировку по итерируемой, например, Строки, а также int, sorted () потерпит неудачу. Конечно, вы можете форсировать сравнение строк с помощью str (). Однако в некоторых случаях вы хотите выполнить фактическое числовое сравнение, где 12 меньше, чем 20 (что не так при сравнении строк). Итак, я придумал следующее. Когда вы хотите явное числовое сравнение, вы можете использовать флаг num_as_num , который попытается выполнить явную числовую сортировку, пытаясь преобразовать все значения в числа с плавающей точкой. Если это удастся, он выполнит числовую сортировку, в противном случае он прибегнет к сравнению строк.

Комментарии для улучшения или push-запросы добро пожаловать.

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

Вот решение, использующее zip на d.values() и d.keys().Несколькими строками ниже по этой ссылке (на объектах просмотра словаря) находится:

Это позволяет создавать пары (значение, ключ) с помощью zip():пары = zip(d.значения(), d.ключи()).

Итак, мы можем сделать следующее:

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

Используйте ValueSortedDict из dicts :

from dicts.sorteddict import ValueSortedDict
d = {1: 2, 3: 4, 4:3, 2:1, 0:0}
sorted_dict = ValueSortedDict(d)
print sorted_dict.items() 

[(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]

Answer 24

Итерация по диктовке и сортировка по ее значениям в порядке убывания:

$ 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

Если ваши значения целые и вы используете Python 2.7 или новее, вы можете использовать collection.Counter вместо dict . Метод most_common выдаст вам все элементы, отсортированные по значению.

Answer 26

Конечно, помните, вам нужно использовать OrderedDict , потому что обычные словари Python не сохраняют первоначальный порядок.

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

<Ч>

Если у вас нет Python 2.7 или выше, лучшее, что вы можете сделать, - это перебирать значения в функции генератора. (Существует OrderedDict для 2.4 и 2.6 здесь , но

а) Я не знаю, насколько хорошо это работает

и

б) Вы должны загрузить и установить его, конечно. Если у вас нет доступа с правами администратора, то, боюсь, опция отключена.)

<Ч>

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

<Ч>

Вы также можете распечатать каждое значение

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

Пожалуйста, не забудьте удалить скобки после печати, если вы не используете Python 3.0 или выше

Answer 27

Это работает в 3.1.x:

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

Answer 28

Для полноты картины я выкладываю решение, используя heapq . Обратите внимание, что этот метод будет работать как с числовыми, так и с нечисловыми значениями

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

Только что выучил соответствующий навык у Python для всех .

Вы можете использовать временный список для сортировки словаря:

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

Если вы хотите отсортировать список в порядке убывания, просто измените исходную строку сортировки на:

tmp = sorted(tmp, reverse=True)

Используя понимание списка, один вкладыш будет:

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

Пример вывода:

#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