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

<p>у меня есть словарь значений, прочитанных из двух полей в базе данных: строковое поле и числовое поле. строковое поле уникально, так что это ключ словаря.</p><p>я могу сортировать по ключам, но как я могу сортировать по значениям?</p><p>примечание: здесь я прочитал вопрос переполнения стека <em> <a href="https://stackoverflow.com/questions/72899">как отсортировать список словарей по значению словаря?</a> </em> и возможно, я мог бы изменить свой код, чтобы получить список словарей, но так как мне не нужен список словарей, я хотел бы знать, есть ли более простое решение для сортировки в порядке возрастания или убывания.</p>

<p>сортировать словарь невозможно, только чтобы получить представление отсортированного словаря. словари по своей природе беспорядочные, но другие типы, такие как списки и кортежи, - нет. таким образом, вам нужен упорядоченный тип данных для представления отсортированных значений, который будет списком - вероятно, списком кортежей.</p><p>например,</p><pre><code>import operator x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0} sorted\_x = sorted(x.items(), key=operator.itemgetter(1)) </code></pre><p><code>sorted\_x</code> будет списком кортежей, отсортированным по второму элементу в каждом кортеже. <code>dict(sorted\_x) == x</code>.</p><p>а для желающих отсортировать по ключам вместо значений:</p><pre><code>import operator x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0} sorted\_x = sorted(x.items(), key=operator.itemgetter(0)) </code></pre><p>в python3, поскольку распаковка запрещена <a href="https://stackoverflow.com/a/15712231/4293057">[1]</a> мы можем использовать</p><pre><code>x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0} sorted\_x = sorted(x.items(), key=lambda kv: kv[1]) </code></pre><p>если вы хотите, чтобы вывод выводился как dict, вы можете использовать <a href="https://docs.python.org/3/library/collections.html#collections.ordereddict"><code>collections.ordereddict</code></a> :</p><pre><code>import collections sorted\_dict = collections.ordereddict(sorted\_x) </code></pre>

<h2>так же просто, как: <code>sorted(dict1, key=dict1.get)</code></h2><p>ну, на самом деле можно сделать "сортировку по значениям словаря". недавно мне пришлось сделать это в code golf (вопрос переполнения стека <em> <a href="https://stackoverflow.com/questions/3169051/code-golf-word-frequency-chart#3170549">code golf: word частотная диаграмма</a> </em>). сокращенно, проблема была в следующем виде: с учетом текста подсчитайте, как часто встречается каждое слово, и отобразите список главных слов, отсортированных по убыванию частоты.</p><p>если вы создаете словарь со словами в качестве ключей и числом вхождений каждого слова в качестве значения, то здесь это упрощается как:</p><pre><code>from collections import defaultdict d = defaultdict(int) for w in text.split(): d[w] += 1 </code></pre><p>затем вы можете получить список слов, упорядоченных по частоте использования, с помощью <code>sorted(d, key=d.get)</code> - сортировка перебирает ключи словаря, используя количество вхождений word в качестве ключа сортировки.</p><pre><code>for w in sorted(d, key=d.get, reverse=true): print w, d[w] </code></pre><p>я пишу это подробное объяснение, чтобы проиллюстрировать, что люди часто имеют в виду, "я могу легко отсортировать словарь по ключу, но как я могу отсортировать по значению" - и я думаю, что оп пытался решить такую проблему. и решение состоит в том, чтобы сделать вид списка ключей, основанный на значениях, как показано выше.</p>

<p>вы можете использовать:</p><pre><code>sorted(d.items(), key=lambda x: x[1]) </code></pre><p>это позволит отсортировать словарь по значениям каждой записи в словаре от наименьшего к наибольшему.</p><p>чтобы отсортировать его в порядке убывания, просто добавьте <code>reverse=true</code>:</p><pre><code>sorted(d.items(), key=lambda x: x[1], reverse=true) </code></pre>

<p>дики не могут быть отсортированы, но вы можете создать отсортированный список из них.</p><p>сортированный список значений dict:</p><pre><code>sorted(d.values()) </code></pre><p>список пар (ключ, значение), отсортированных по значению:</p><pre><code>from operator import itemgetter sorted(d.items(), key=itemgetter(1)) </code></pre>

<p>в недавнем python 2.7 у нас появился новый тип <a href="http://docs.python.org/dev/whatsnew/2.7.html#pep-372-adding-an-ordered-dictionary-to-collections">ordereddict</a> , который запоминает порядок, в котором элементы были добавлены.</p><pre><code>>>> 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} </code></pre><p>чтобы создать новый упорядоченный словарь из оригинала, отсортировав по значениям:</p><pre><code>>>> from collections import ordereddict >>> d\_sorted\_by\_value = ordereddict(sorted(d.items(), key=lambda x: x[1])) </code></pre><p>ordereddict ведет себя как обычный dict:</p><pre><code>>>> 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)]) </code></pre>

<p><strong> обновление: 5 декабря 2015 г. с использованием python 3.5 </strong></p><p>хотя я нашел полезный ответ, я также был удивлен, что он не был обновлен до ссылки <strong> <a href="https://docs.python.org/3/library/collections.html#collections.ordereddict">ordereddict</a> </strong> из стандарта модуль библиотеки <strong> коллекций </strong> как жизнеспособная, современная альтернатива, предназначенная для решения именно этого типа проблем.</p><pre><code>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)]) </code></pre><p>официальная <strong> <a href="https://docs.python.org/3/library/collections.html#collections.ordereddict">ordereddict</a> </strong> документация также предлагает очень похожий пример, но с использованием лямбды для функции сортировки:</p><pre><code># 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)]) </code></pre>

<p>почти так же, как <a href="https://stackoverflow.com/a/613207/11044033">ответ хэнка гея</a> :</p><pre><code>sorted([(value,key) for (key,value) in mydict.items()]) </code></pre><p>или слегка оптимизирован, как это было предложено джоном фухи:</p><pre><code>sorted((value,key) for (key,value) in mydict.items()) </code></pre>

<p>часто это может быть очень удобно для использования <b> <a href="http://docs.python.org/library/collections.html#collections.namedtuple">namedtuple</a> </b>, например, у вас есть словарь "имя" в качестве ключей и "оценка" в качестве значений, и вы хотите отсортировать по "оценка":</p><pre><code>import collections player = collections.namedtuple('player', 'score name') d = {'john':5, 'alex':10, 'richard': 7} </code></pre><p>сортировка с наименьшим количеством баллов:</p><pre><code>worst = sorted(player(v,k) for (k,v) in d.items()) </code></pre><p>сортировка с наибольшим количеством баллов:</p><pre><code>best = sorted([player(v,k) for (k,v) in d.items()], reverse=true) </code></pre><p>теперь вы можете получить имя и счет, скажем, второго лучшего игрока (index = 1), очень pythonly, как это:</p><pre><code>player = best[1] player.name 'richard' player.score 7 </code></pre>

<h1>начиная с <a href="https://docs.python.org/3.6/whatsnew/3.6.html">python 3.6</a> встроенный dict будет упорядочен</h1><p>хорошие новости, поэтому исходный вариант использования op для отображения пар, извлеченных из базы данных с уникальными строковыми идентификаторами в качестве ключей и числовыми значениями в качестве значений во встроенном python v3.6 + dict, теперь должен учитывать вставку порядок.</p><p>если, скажем, результирующие выражения таблицы в два столбца из запроса к базе данных, как:</p><pre><code>select a\_key, a\_value from a\_table order by a\_value; </code></pre><p>будет храниться в двух python кортежах, k\_seq и v\_seq (выровненных по числовому индексу и, конечно же, с одинаковой длиной), затем:</p><pre><code>k\_seq = ('foo', 'bar', 'baz') v\_seq = (0, 1, 42) ordered\_map = dict(zip(k\_seq, v\_seq)) </code></pre><p>разрешить вывод позже как:</p><pre><code>for k, v in ordered\_map.items(): print(k, v) </code></pre><p>уступая в этом случае (для нового python 3.6+ встроенного dict!):</p><pre><code>foo 0 bar 1 baz 42 </code></pre><p>в том же порядке на значение v.</p><p>где при установке на моем компьютере python 3.5 он в настоящее время выдает:</p><pre><code>bar 1 foo 0 baz 42 </code></pre><h2>подробности:</h2><p>как было предложено в 2012 году рэймондом хеттингером (см. почту на python-dev с темой <a href="https://mail.python.org/pipermail/python-dev/2012-december/123028.html">"более компактные словари с более быстрой итерацией"</a> ), а теперь (в 2016 году) объявлено в письме виктора стиннера на почту python-dev. with subject <a href="https://mail.python.org/pipermail/python-dev/2016-september/146327.html">"python 3.6 dict становится компактным и получает приватную версию; ключевые слова становятся упорядоченными"</a> из-за исправления/реализации проблемы 27350 <a href="http://bugs.python.org/issue27350">"compact and order dict"</a> in python 3.6 теперь мы сможем использовать встроенный dict для поддержания порядка вставки !!</p><p>надеемся, что это приведет к тонкому слою реализации ordereddict в качестве первого шага. как указывало @ jimfasarakis-hilliard, некоторые видят варианты использования для типа ordereddict и в будущем. я думаю, что сообщество python будет тщательно проверять, выдержит ли это испытание временем, и какие будут следующие шаги.</p><p>время переосмыслить наши привычки кодирования, чтобы не упустить возможности, открываемые стабильным упорядочением:</p><ul> <li>ключевое слово аргументы и</li> <li>промежуточное хранение</li> </ul><p>первый, потому что в некоторых случаях он облегчает выполнение функций и методов.</p><p>второе, так как оно поощряет более простое использование <code>dict</code>s в качестве промежуточного хранилища в конвейерах обработки.</p><p>рэймонд хеттингер любезно предоставил документацию, объясняющую " <a href="https://dl.dropboxusercontent.com/u/3967849/sfmu2/\_build/html/goal.html">технология позади python 3.6 словари</a> =" - из его презентации в сан-франциско python meetup group 2016-dec-08.</p><p>и, может быть, довольно много страниц с вопросами и ответами в stack overflow получат варианты этой информации, и многие высококачественные ответы также потребуют обновления для каждой версии.</p><h3>предостережение emptor (но также см. ниже обновление 2017-12-15):</h3><p>как справедливо отмечает @ajcr: "сохраняющий порядок аспект этой новой реализации считается деталью реализации и на нее не следует полагаться". (из <a href="https://docs.python.org/3.6/whatsnew/3.6.html">whatsnew36</a> ) не придирки, <strong>, но </strong> цитата была вырезана немного пессимистично ;-). это продолжается как "(это может измениться в будущем, но желательно иметь эту новую реализацию dict в языке в течение нескольких выпусков, прежде чем изменять спецификацию языка, чтобы предписывать семантику сохранения порядка для всех текущих и будущих python реализации; это также помогает сохранить обратную совместимость со старыми версиями языка, где все еще действует случайный порядок итераций, например python 3.5). "</p><p>как и в некоторых человеческих языках (например, немецком), использование определяет язык, и завещание было объявлено ... in <a href="https://docs.python.org/3.6/whatsnew/3.6.html">whatsnew36</a> .</p><h3>обновление 2017-12-15:</h3><p>в <a href="https://mail.python.org/pipermail/python-dev/2017-december/151283.html">письмо в список python-dev</a> гвидо ван россум объявил:</p><blockquote> <p>сделай это так. "dict сохраняет порядок вставки" - это решение. спасибо!</p> </blockquote><p>таким образом, побочный эффект cpython версии 3.6 от порядка вставки dict теперь становится частью языковой спецификации (а не только детали реализации). в этой почтовой ветке также появились некоторые отличительные цели дизайна для <code>collections.ordereddict</code>, как напомнил рэймонд хеттингер во время обсуждения.</p>

<p>данный словарь</p><pre><code>e = {1:39, 4:34, 7:110, 2:87} </code></pre><p>сортировка</p><pre><code>sred = sorted(e.items(), key=lambda value: value[1]) </code></pre><p>результат</p><pre><code>[(4, 34), (1, 39), (2, 87), (7, 110)] </code></pre><p>вы можете использовать лямбда-функцию, чтобы отсортировать вещи по значению и сохранить их обработанными внутри переменной, в этом случае <strong>sred</strong> с <strong>e</strong> исходным словарем.</p><p>надеюсь, это поможет!</p>

<p>у меня была такая же проблема, и я решил ее так:</p><pre><code>wantedoutput = sorted(mydict, key=lambda x : mydict[x]) </code></pre><p>(люди, которые отвечают "невозможно отсортировать диктовку", не читали вопрос! на самом деле, "я могу сортировать по ключам, но как я могу сортировать по значениям?" ясно означает, что ему нужен список ключи отсортированы по значению их значений.)</p><p>обратите внимание, что порядок не определен (ключи с одинаковыми значениями будут в произвольном порядке в списке вывода).</p>

<p>в python 2.7 просто выполните:</p><pre class="lang-py prettyprint-override"><code>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)]) </code></pre><p>скопируйте и вставьте из: <a href="http://docs.python.org/dev/library/collections.html#ordereddict-examples-and-recipes">http://docs.python.org/dev/library/collections.html#ordereddict-examples-and-recipes</a> </p><p>наслаждаться ;-)</p>

<p>технически словари не являются последовательностями, и поэтому не могут быть отсортированы. вы можете сделать что-то вроде</p><pre><code>sorted(a\_dictionary.values()) </code></pre><p>при условии, что производительность не так уж и велика.</p>

<p>это код:</p><pre><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 </code></pre><p>вот результаты:</p><p><strong>original</strong></p><pre><code>{'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} </code></pre><p><strong>rofl</strong></p><pre><code>{'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} </code></pre><p><strong>ранг</strong></p><pre><code>{'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} </code></pre>

<p>если значения являются числовыми, вы также можете использовать <a href="https://docs.python.org/library/collections.html#collections.counter"><code>counter</code></a> from <a href="https://docs.python.org/library/collections.html">collection</a> .</p><pre><code>from collections import counter x = {'hello': 1, 'python': 5, 'world': 3} c = counter(x) print(c.most\_common()) >> [('python', 5), ('world', 3), ('hello', 1)] </code></pre>

<p>попробуйте следующий подход. давайте определим словарь mydict со следующими данными:</p><pre><code>mydict = {'carl':40, 'alan':2, 'bob':1, 'danny':3} </code></pre><p>если кто-то хочет отсортировать словарь по ключам, можно сделать что-то вроде:</p><pre><code>for key in sorted(mydict.iterkeys()): print "%s: %s" % (key, mydict[key]) </code></pre><p>это должно вернуть следующий вывод:</p><pre><code>alan: 2 bob: 1 carl: 40 danny: 3 </code></pre><p>с другой стороны, если кто-то хочет отсортировать словарь по значению (как это задается в вопросе), можно сделать следующее:</p><pre><code>for key, value in sorted(mydict.iteritems(), key=lambda (k,v): (v,k)): print "%s: %s" % (key, value) </code></pre><p>результат этой команды (сортировка словаря по значению) должен вернуть следующее:</p><pre><code>bob: 1 alan: 2 danny: 3 carl: 40 </code></pre>

<p>вы можете создать "инвертированный индекс", также</p><pre><code>from collections import defaultdict inverse= defaultdict( list ) for k, v in originaldict.items(): inverse[v].append( k ) </code></pre><p>теперь ваш обратный имеет значения; у каждого значения есть список применимых ключей.</p><pre><code>for k in sorted(inverse): print k, inverse[k] </code></pre>

<p>вы можете использовать <a href="http://docs.python.org/2/library/collections.html#collections.counter">collection.counter</a> . обратите внимание, что это будет работать как для числовых, так и для нечисловых значений.</p><pre><code>>>> 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)]) </code></pre>

<p>это возвращает список пар ключ-значение в словаре, отсортированных по значению от самого высокого до самого низкого:</p><pre><code>sorted(d.items(), key=lambda x: x[1], reverse=true) </code></pre><p>для словаря, отсортированного по ключу, используйте следующее:</p><pre><code>sorted(d.items(), reverse=true) </code></pre><p>возвращаемым является список кортежей, потому что сами словари не могут быть отсортированы.</p><p>это может быть как распечатано, так и отправлено в дальнейшие вычисления.</p>

<p>начиная с python 3.6, объекты <code>dict</code> теперь упорядочены по порядку вставки. это официально в спецификации python 3.7.</p><pre><code>>>> words = {"python": 2, "blah": 4, "alice": 3} >>> dict(sorted(words.items(), key=lambda x: x[1])) {'python': 2, 'alice': 3, 'blah': 4} </code></pre><p>до этого вам приходилось использовать <code>ordereddict</code>.</p><p> <a href="https://docs.python.org/3.7/library/stdtypes.html#typesmapping">документация по python 3.7</a> говорит:</p><blockquote> <p>изменено в версии 3.7: порядок словаря гарантированно является порядком вставки. такое поведение было деталью реализации cpython от 3.6.</p> </blockquote>

<p>вы можете использовать <a href="https://pypi.python.org/pypi/skipdict/1.0">пропустить dict</a> , который является словарем, который постоянно сортируется по значению.</p><pre><code>>>> 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} </code></pre><p>если вы используете <code>keys()</code>, <code>values()</code> или <code>items()</code>, вы будете выполнять итерацию в отсортированном порядке по значению.</p><p>это реализовано с использованием <a href="http://en.wikipedia.org/wiki/skip\_list">пропустить список</a> структура данных.</p>

<pre><code>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 </code></pre>

<p>вы также можете использовать пользовательскую функцию, которую можно передать клавише.</p><pre><code>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) </code></pre>

<p> <a href="https://stackoverflow.com/a/39424969/1150683">как указал дилетант</a> , python 3.6 теперь <em> сохранит порядок </em>! я думал, что у меня будет функция, которую я написал, которая упрощает сортировку итерируемого (tuple, list, dict). в последнем случае вы можете сортировать либо по ключам, либо по значениям, и это может учитывать числовое сравнение. <strong> только для> = 3.6! </strong></p><p>когда вы пытаетесь использовать сортировку по итерируемой, которая содержит, например, строки, а также int, sorted () потерпит неудачу. конечно, вы можете форсировать сравнение строк с помощью str (). однако в некоторых случаях вы хотите выполнить <em> фактическое </em> числовое сравнение, где <code>12</code> меньше, чем <code>20</code> (что не имеет место при сравнении строк). итак, я придумал следующее. когда вы хотите явное числовое сравнение, вы можете использовать флаг <code>num\_as\_num</code>, который попытается выполнить явную числовую сортировку, пытаясь преобразовать все значения в числа с плавающей точкой. если это удастся, он выполнит числовую сортировку, иначе он прибегнет к сравнению строк.</p><p>комментарии для улучшения или <a href="https://github.com/bramvanroy/pylt3/blob/master/pylt3/type\_helpers.py#l68-l100">push-запросы</a> добро пожаловать.</p><pre><code>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") </code></pre>

<p>вот решение, использующее zip on <a href="https://docs.python.org/2/library/stdtypes.html#dictionary-view-objects"><code>d.values()</code> и <code>d.keys()</code></a> . несколько строк по этой ссылке (в объектах словаря):</p><blockquote> <p>это позволяет создавать пары (значение, ключ) с помощью zip (): pair = zip (d.values (), d.keys ()).</p> </blockquote><p>таким образом, мы можем сделать следующее:</p><pre><code>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')] </code></pre>

<p>используйте <strong> valuesorteddict </strong> из <a href="http://pypi.python.org/pypi/dicts">dicts</a> :</p><pre><code>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)] </code></pre>

<p>конечно, помните, вам нужно использовать <code>ordereddict</code>, потому что обычные словари python не сохраняют первоначальный порядок.</p><pre><code>from collections import ordereddict a = ordereddict(sorted(originaldict.items(), key=lambda x: x[1])) </code></pre><hr><p>если у вас нет python 2.7 или выше, лучшее, что вы можете сделать, - это перебирать значения в функции генератора. (существует <code>ordereddict</code> для 2.4 и 2.6 <a href="https://pypi.python.org/pypi/ordereddict">здесь</a> , но</p><p>а) я не знаю, насколько хорошо это работает</p><p>а также</p><p>б) вы должны скачать и установить его, конечно. если у вас нет доступа с правами администратора, то, боюсь, опция отключена.)</p><hr><pre><code>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]) </code></pre><hr><p>вы также можете распечатать каждое значение</p><pre><code>for bleh, meh in gen(mydict): print(bleh, meh) </code></pre><p>пожалуйста, не забудьте удалить скобки после печати, если не используете python 3.0 или выше</p>

<p>итерируйте через dict и сортируйте его по значениям в порядке убывания:</p><pre><code>$ 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 </code></pre>

<p>если ваши значения являются целыми числами и вы используете python 2.7 или новее, вы можете использовать <a href="http://docs.python.org/py3k/library/collections.html#collections.counter"><code>collections.counter</code></a> вместо <code>dict</code>. метод <code>most\_common</code> выдаст вам все элементы, отсортированные по значению.</p>

<p>я придумал это,</p><pre><code>import operator x = {1: 2, 3: 4, 4:3, 2:1, 0:0} sorted\_x = {k[0]:k[1] for k in sorted(x.items(), key=operator.itemgetter(1))} </code></pre><p>для python 3.x: <code>x.items()</code> заменяя <code>iteritems()</code>.</p><pre><code>>>> sorted\_x {0: 0, 1: 2, 2: 1, 3: 4, 4: 3} </code></pre><p>или попробуйте с <code>collections.ordereddict</code>!</p><pre><code>x = {1: 2, 3: 4, 4:3, 2:1, 0:0} from collections import ordereddict od1 = ordereddict(sorted(x.items(), key=lambda t: t[1])) </code></pre>

<p>вы можете использовать отсортированную функцию python</p><p><code>sorted(iterable[, cmp[, key[, reverse]]])</code></p><p>таким образом, вы можете использовать:</p><p><code>sorted(dictionary.items(),key = lambda x :x[1])</code></p><p>посетите эту ссылку для получения дополнительной информации о отсортированной функции: <a href="https://docs.python.org/2/library/functions.html#sorted">https://docs.python.org/2/library/functions.html#sorted</a> </p>

<p>это работает в 3.1.x:</p><pre><code>import operator slovar\_sorted=sorted(slovar.items(), key=operator.itemgetter(1), reverse=true) print(slovar\_sorted) </code></pre>

<p>ради полноты я выкладываю решение, используя <a href="http://docs.python.org/2/library/heapq.html">heapq</a> . обратите внимание, что этот метод будет работать как для числовых, так и для нечисловых значений.</p><pre><code>>>> 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)] </code></pre>

<p>только что выучил соответствующий навык у <a href="https://www.coursera.org/learn/python-data/lecture/0ou0n/10-tuples">python for everybody</a> .</p><p>вы можете использовать временный список для сортировки словаря:</p><pre><code>#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) </code></pre><p>если вы хотите отсортировать список в порядке убывания, просто измените исходную строку сортировки на:</p><pre><code>tmp = sorted(tmp, reverse=true) </code></pre><p>используя понимание списка, один вкладыш будет:</p><pre><code>#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)) </code></pre><p>пример вывода:</p><pre><code>#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')] </code></pre>

<pre><code>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 </code></pre>

<p>из-за требований сохранить обратную совместимость со старыми версиями <a href="http://en.wikipedia.org/wiki/python\_%28programming\_language%29">python</a> я думаю, что решение ordereddict очень неразумно. вы хотите что-то, что работает с python 2.7 и более ранними версиями.</p><p>но решение коллекций, упомянутое в другом ответе, абсолютно превосходно, потому что вы переобучаете связь между ключом и значением, что в случае словарей чрезвычайно важно.</p><p>я не согласен с выбором номер один, представленным в другом ответе, потому что он выбрасывает ключи.</p><p>я использовал решение, упомянутое выше (код, показанный ниже), и сохранил доступ к ключам и значениям, и в моем случае упорядочение было по значениям, но важным было упорядочение ключей после упорядочения значений.</p><pre><code>from collections import counter x = {'hello':1, 'python':5, 'world':3} c=counter(x) print c.most\_common() >> [('python', 5), ('world', 3), ('hello', 1)] </code></pre>

<p> <a href="http://thomas-cokelaer.info/blog/2017/12/how-to-sort-a-dictionary-by-values-in-python/">томас кокелер</a> объясняет это очень элегантно. мне нравится упомянуть краткую заметку о его статье.</p><p>давайте рассмотрим следующий словарь.</p><pre><code>d = {"pierre": 42, "anne": 33, "zoe": 24} </code></pre><p>для сортировки на основе значений представлены следующие подходы.</p><p><strong> <code>sorted</code> функция и <code>operator</code> модуль </strong></p><pre><code>import operator sorted\_d = sorted(d.items(), key=operator.itemgetter(1)) </code></pre><p><br></p><p><strong> <code>sorted</code> функция и <code>lambda</code> функция </strong></p><pre><code>sorted\_d = sorted(d.items(), key=lambda x: x[1]) </code></pre><p><br></p><p><strong> <code>sorted</code> функцию и вернуть упорядоченный словарь </strong></p><p>в предыдущих методах возвращаемые объекты являются списком кортежей. так что у нас больше нет словаря. мы можем использовать <code>ordereddict</code>, если захотим.</p><pre><code>from collections import ordereddict sorted\_d = ordereddict(sorted(d.items(), key=lambda x: x[1])) </code></pre><p><br> <strong> <code>sorted</code> функция и понимание списка </strong></p><pre><code>sorted\_d = sorted((value, key) for (key,value) in d.items()) </code></pre><p>тем не менее, <a href="http://thomas-cokelaer.info/blog/2017/12/how-to-sort-a-dictionary-by-values-in-python/">он</a> также сделал быстрый тест вышеупомянутой процедуры.</p>

<p>помимо использования встроенного модуля и т.д., я пытаюсь решить его вручную ..... <strong>сначала</strong> я создал функцию, задачей которой является возвращение минимального значения каждому элементу dict:</p><pre><code>def returnmindict(\_dct): dict\_items = \_dct.items() list\_items = list(dict\_items) init\_items = list\_items[0] for i in range(len(list\_items)): if list\_items[i][1] > init\_items[1]: continue else: init\_items = list\_items[i] return init\_items </code></pre><p><strong>second</strong>, теперь у нас есть функция, которая возвращает элемент с минимальным значением, затем я делаю новый dict, затем зацикливаю его:</p><pre><code>def selectdictsort(\_dct): new\_dict = {} while \_dct: mindict = returnmindict(\_dct) new\_dict.update(dict((mindict,))) \_dct.pop(mindict[0]) return new\_dict </code></pre><p>я пытаюсь это <code>selectdictsort({2: 5, 5: 1, 4: 3, 1: 1, 0: 1, 9: 2, 8: 2})</code> вернется:</p><pre><code>{0: 1, 1: 1, 5: 1, 8: 2, 9: 2, 4: 3, 2: 5} </code></pre><p>хммм ... я не знаю, что правильно, но это то, что я пытался ....</p><p>(обновлен код с <code>retrun new\_dct</code> до <code>return new\_dict</code>)</p>

<p>использование python 3.2:</p><pre><code>x = {"b":4, "a":3, "c":1} for i in sorted(x.values()): print(list(x.keys())[list(x.values()).index(i)]) </code></pre>

<pre><code>>>> import collections >>> x = {1: 2, 3: 4, 4:3, 2:1, 0:0} >>> sorted\_x = collections.ordereddict(sorted(x.items(), key=lambda t:t[1])) >>> ordereddict([(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)]) </code></pre><p><code>ordereddict</code> является подклассом <code>dict</code></p>

<p>этот метод не будет использовать лямбду и хорошо работает на python 3.6:</p><pre><code> # sort dictionary by value d = {'a1': 'fsdfds', 'g5': 'aa3432ff', 'ca':'zz23432'} def getkeybyvalue(d,i): for k, v in d.items(): if v == i: return (k) sortvaluelist = sorted(d.values()) # in >> python 3.6+ << the insertion-order of a dict is preserved. that is, # when creating a new dictionary and filling it 'in sorted order', # that order will be maintained. sortresult ={} for i1 in sortvaluelist: key = getkeybyvalue(d,i1) sortresult[key] = i1 print ('=====sort by value=====') print (sortresult) print ('=======================') </code></pre>