Как отсортировать словарь по ключу?

Вот производительность предлагаемых решений:

from collections import OrderedDict
from sortedcontainers import SortedDict
import json

keys = np.random.rand(100000)
vals = np.random.rand(100000)

d = dict(zip(keys, vals))

timeit SortedDict(d)
#45.8 ms ± 780 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit sorted(d.items())
#91.9 ms ± 707 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit OrderedDict(sorted(d.items(), key=lambda x: x[0]))
#93.7 ms ± 1.52 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit dict(sorted(dic.items()))
#113 ms ± 824 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit OrderedDict(sorted(dic.items()))
#122 ms ± 2.65 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

timeit json.dumps(d, sort_keys=True)
#259 ms ± 9.42 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Как мы видим, решение Гранта Дженкса на сегодняшний день является самым быстрым.

Если вы знаете, что все ваши ключи имеют один и тот же тип или имеют типы, которые поддерживают '<' (меньше, чем __lt__ python), тогда вы можете использовать dict(sorted(your_dict.items(), key=lambda _: _[0])) простой для понимания однострочный код

Я нашел простой способ сортировки словаря - это создать новый, основанный на отсортированных элементах «ключ: значение» того, который вы пытаетесь отсортировать. Если вы хотите отсортировать dict = {}, получить все его элементы с помощью связанного метода, отсортировать их с помощью функции sorted(), а затем создать новый словарь.

Вот код, использующий понимание словаря:

sorted_dict = {k:v for k,v in sorted(dict.items())}

Здесь уже есть множество ответов, демонстрирующих популярные способы сортировки словаря Python. Я подумал, что добавлю еще несколько менее очевидных способов для тех, кто приходит сюда из Google и ищет нестандартные идеи.

Пример словаря: d = {2: 'c', 1: 'b', 0: 'a', 3: 'd'}

Понимание словаря

# Converts to list, sorts, re-converts to dict
{k: v for k, v in sorted(list(d))}

Использование лямбда-выражений

Сортировка не всегда предназначена для упорядочивания строго по возрастанию или убыванию. Для более условной сортировки используйте вышеуказанный метод в сочетании с lamdas:

{k: v for k, v in sorted(d.items(), key=lambda v: ord(v[1]))}

Дополнительные примеры

В этой ветке уже достаточно хороших примеров. Еще несколько примеров, а также крайних случаев и странностей можно найти в этой статье о сортировке словарей в Python.

Что касается формулировки вопроса, большинство ответов здесь дают правильный ответ.

Однако, учитывая, как вещи должны быть на самом деле, с учетом десятилетий и десятилетий компьютерных наук, я совершенно удивляюсь, что на самом деле здесь есть только один ответ (от пользователя GrantJ), предполагающий использование сортированных ассоциативных контейнеров (sortedcontainers), которые сортируют элементы на основе ключа в точке их вставки.

Это позволит избежать массивного воздействия на производительность на каждый вызов sort(...) (как минимум O(N*log(N)), где N - это количество элементов (логически это применимо ко всем таким решениям, которые здесь предлагают чтобы использовать sort(...)). Учтите, что для всех таких решений, sort(...) нужно будет вызывать каждый раз, когда необходимо получить доступ к коллекции как отсортированной ПОСЛЕ она была изменена путем добавления / удаления элементы ...

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

Постройте dict с нуля по мере продвижения. Имейте вторую структуру данных, список, со списком ключей. Пакет bisect имеет функцию insort, которая позволяет вставлять в отсортированный список или сортировать ваш список после полного заполнения вашего dict. Теперь, когда вы перебираете свой dict, вы вместо этого перебираете список для доступа к каждому ключу по порядку, не беспокоясь о представлении структуры dict (которая не была создана для сортировки).

Простой способ сделать это:

d = {2:3, 1:89, 4:5, 3:0}

s = {k : d[k] for k in sorted(d)}

s

Out[1]: {1: 89, 2: 3, 3: 0, 4: 5} 

Эта функция будет рекурсивно сортировать любой словарь по его ключу. То есть, если какое-либо значение в словаре также является словарем, оно также будет отсортировано по его ключу. Если вы работаете на CPython 3.6 или более поздней версии, можно просто изменить использование dict, а не OrderedDict.

from collections import OrderedDict

def sort_dict(d):
    items = [[k, v] for k, v in sorted(d.items(), key=lambda x: x[0])]
    for item in items:
        if isinstance(item[1], dict):
            item[1] = sort_dict(item[1])
    return OrderedDict(items)
    #return dict(items)

Я придумал однострочную сортировку по диктовке.

>> a = {2:3, 1:89, 4:5, 3:0}
>> c = {i:a[i] for i in sorted(a.keys())}
>> print(c)
{1: 89, 2: 3, 3: 0, 4: 5}
[Finished in 0.4s]

Надеюсь, это будет полезно.

Или используйте pandas,

Демо:

>>> d={'B':1,'A':2,'C':3}
>>> df=pd.DataFrame(d,index=[0]).sort_index(axis=1)
   A  B  C
0  2  1  3
>>> df.to_dict('int')[0]
{'A': 2, 'B': 1, 'C': 3}
>>> 

См .:

Документы этого

Документация по всем пандам

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

Это ваш словарь

d = {2:3, 1:89, 4:5, 3:0}

Создайте новый словарь d1, отсортировав этот d с помощью лямбда-функции

d1 = dict(sorted(d.items(), key = lambda x:x[0]))

d1 должен быть {1: 89, 2: 3, 3: 0, 4: 5}, отсортированный по ключам в d.

Словарь Python был неупорядочен до версии Python 3.6. В реализации Python 3.6 в CPython словарь сохраняет порядок вставки. Начиная с Python 3.7, это станет функцией языка.

В журнале изменений Python 3.6 (https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-compactdict):

Рассматривается аспект сохранения порядка этой новой реализации. деталь реализации, на которую не следует полагаться (это может изменения в будущем, но желательно, чтобы этот новый диктат реализация на языке для нескольких выпусков перед изменением спецификация языка для предписания семантики сохранения порядка для всех текущих и будущие реализации Python; это также помогает сохранить обратная совместимость со старыми версиями языка, где случайный порядок итераций все еще действует, например Python 3.5).

В документе Python 3.7 (https://docs.python.org/3.7/tutorial/datastructures.html#icingaries):

Выполнение list (d) в словаре возвращает список всех используемых ключей в словаре в порядке вставки (если вы хотите отсортировать, просто используйте sorted (d) вместо).

Таким образом, в отличие от предыдущих версий, вы можете отсортировать dict после Python 3.6 / 3.7. Если вы хотите отсортировать вложенный dict, включая вложенный внутри, вы можете сделать:

test_dict = {'a': 1, 'c': 3, 'b': {'b2': 2, 'b1': 1}}

def dict_reorder(item):
    return {k: dict_reoder(v) if isinstance(v, dict) else v for k, v in sorted(item.items())}

reordered_dict = dict_reorder(test_dict)

https://gist.github.com/ligyxy/f60f0374defc383aa098d44cfbd318eb

Для CPython / PyPy 3.6 и любого Python 3.7 или выше это легко сделать с помощью:

>>> d = {2:3, 1:89, 4:5, 3:0}
>>> dict(sorted(d.items()))
{1: 89, 2: 3, 3: 0, 4: 5}

dictionary = {1:[2],2:[],5:[4,5],4:[5],3:[1]}

temp=sorted(dictionary)
sorted_dict = dict([(k,dictionary[k]) for i,k in enumerate(temp)])

sorted_dict:
         {1: [2], 2: [], 3: [1], 4: [5], 5: [4, 5]}

Я думаю, что проще всего отсортировать dict по ключу и сохранить отсортированную пару ключ: значение в новом dict.

dict1 = {'renault': 3, 'ford':4, 'volvo': 1, 'toyota': 2} 
dict2 = {}                  # create an empty dict to store the sorted values
for key in sorted(dict1.keys()):
    if not key in dict2:    # Depending on the goal, this line may not be neccessary
        dict2[key] = dict1[key]

Чтобы было понятнее:

dict1 = {'renault': 3, 'ford':4, 'volvo': 1, 'toyota': 2} 
dict2 = {}                  # create an empty dict to store the sorted     values
for key in sorted(dict1.keys()):
    if not key in dict2:    # Depending on the goal, this line may not be  neccessary
        value = dict1[key]
        dict2[key] = value

Сгенерирует именно то, что вы хотите:

 D1 = {2:3, 1:89, 4:5, 3:0}

 sort_dic = {}

 for i in sorted(D1):
     sort_dic.update({i:D1[i]})
 print sort_dic


{1: 89, 2: 3, 3: 0, 4: 5}

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

from collections import OrderedDict
sorted_dict = OrderedDict(sorted(D1.items(), key=lambda t: t[0]))

Самое простое решение состоит в том, что вы должны получить список ключей dict в порядке сортировки, а затем перебрать dict. Например,

a1 = {'a':1, 'b':13, 'd':4, 'c':2, 'e':30}
a1_sorted_keys = sorted(a1, key=a1.get, reverse=True)
for r in a1_sorted_keys:
    print r, a1[r]

Ниже будет вывод (в порядке убывания)

e 30
b 13
d 4
c 2
a 1

Есть простой способ отсортировать словарь.

Согласно вашему вопросу,

Решение:

c={2:3, 1:89, 4:5, 3:0}
y=sorted(c.items())
print y

(где c - имя вашего словаря.)

Эта программа дает следующий вывод:

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

как ты хотел.

Другой пример:

d={"John":36,"Lucy":24,"Albert":32,"Peter":18,"Bill":41}
x=sorted(d.keys())
print x

Дает результат: ['Albert', 'Bill', 'John', 'Lucy', 'Peter']

y=sorted(d.values())
print y

Дает результат: [18, 24, 32, 36, 41]

z=sorted(d.items())
print z

Дает результат:

[('Albert', 32), ('Bill', 41), ('John', 36), ('Lucy', 24), ('Peter', 18)]

Следовательно, изменив его на ключи, значения и элементы, вы можете печатать так, как хотели. Надеюсь, это поможет!

from operator import itemgetter
# if you would like to play with multiple dictionaries then here you go:
# Three dictionaries that are composed of first name and last name.
user = [
    {'fname': 'Mo', 'lname': 'Mahjoub'},
    {'fname': 'Abdo', 'lname': 'Al-hebashi'},
    {'fname': 'Ali', 'lname': 'Muhammad'}
]
#  This loop will sort by the first and the last names.
# notice that in a dictionary order doesn't matter. So it could put the first name first or the last name first. 
for k in sorted (user, key=itemgetter ('fname', 'lname')):
    print (k)

# This one will sort by the first name only.
for x in sorted (user, key=itemgetter ('fname')):
    print (x)

l = dict.keys()
l2 = l
l2.append(0)
l3 = []
for repeater in range(0, len(l)):
    smallnum = float("inf")
    for listitem in l2:
        if listitem < smallnum:
            smallnum = listitem
    l2.remove(smallnum)
    l3.append(smallnum)
l3.remove(0)
l = l3

for listitem in l:
    print(listitem)

Сравнение времени двух методов в 2.7 показывает, что они практически идентичны:

>>> setup_string = "a = sorted(dict({2:3, 1:89, 4:5, 3:0}).items())"
>>> timeit.timeit(stmt="[(k, val) for k, val in a]", setup=setup_string, number=10000)
0.003599141953657181

>>> setup_string = "from collections import OrderedDict\n"
>>> setup_string += "a = OrderedDict({1:89, 2:3, 3:0, 4:5})\n"
>>> setup_string += "b = a.items()"
>>> timeit.timeit(stmt="[(k, val) for k, val in b]", setup=setup_string, number=10000)
0.003581275490432745 

Ребята, вы усложняете ... это действительно просто

from pprint import pprint
Dict={'B':1,'A':2,'C':3}
pprint(Dict)

Вывод:

{'A':2,'B':1,'C':3}

Просто:

d = {2:3, 1:89, 4:5, 3:0}
sd = sorted(d.items())

for k,v in sd:
    print k, v

Вывод:

1 89
2 3
3 0
4 5

Существует ряд модулей Python, которые предоставляют реализации словаря, которые автоматически поддерживают ключи в отсортированном порядке. Рассмотрим модуль sortedcontainers, который является реализациями на чистом Python и fast-as-C. Также существует сравнение производительности с другими популярными опциями, сравниваемыми друг с другом.

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

>>> from sortedcontainers import SortedDict
>>> d = {2:3, 1:89, 4:5, 3:0}
>>> s = SortedDict(d)
>>> s.items()
[(1, 89), (2, 3), (3, 0), (4, 5)]

Тип SortedDict также поддерживает поиск и удаление индексированного местоположения, что невозможно со встроенным типом dict.

>>> s.iloc[-1]
4
>>> del s.iloc[2]
>>> s.keys()
SortedSet([1, 2, 4])

Словари Python неупорядочены. Обычно это не проблема, поскольку наиболее распространенный вариант использования - поиск.

Самый простой способ сделать то, что вы хотите, - создать collections.OrderedDict, вставив элементы в отсортированном порядке.

ordered_dict = collections.OrderedDict([(k, d[k]) for k in sorted(d.keys())])

Если вам нужно выполнить итерацию, как предлагали другие выше, самым простым способом было бы перебрать отсортированные ключи. Примеры-

Распечатать значения, отсортированные по ключам:

# create the dict
d = {k1:v1, k2:v2,...}
# iterate by keys in sorted order
for k in sorted(d.keys()):
    value = d[k]
    # do something with k, value like print
    print k, value

Получить список значений, отсортированных по ключам:

values = [d[k] for k in sorted(d.keys())]

Нашел другой способ:

import json
print json.dumps(d, sort_keys = True)

UPD:
1. это также сортирует вложенные объекты (спасибо @DanielF).
2. Словари python неупорядочены, поэтому их можно сшить для печати или присвоения только str.

Здесь я нашел простейшее решение для сортировки словаря Python по ключу с использованием pprint. например.

>>> x = {'a': 10, 'cd': 20, 'b': 30, 'az': 99} 
>>> print x
{'a': 10, 'b': 30, 'az': 99, 'cd': 20}

, но при использовании pprint он вернет отсортированный dict

>>> import pprint 
>>> pprint.pprint(x)
{'a': 10, 'az': 99, 'b': 30, 'cd': 20}

В Python 3.

>>> D1 = {2:3, 1:89, 4:5, 3:0}
>>> for key in sorted(D1):
    print (key, D1[key])

дает

1 89
2 3
3 0
4 5

Из документации библиотеки Python collections:

>>> from collections import OrderedDict

>>> # regular unsorted dictionary
>>> d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}

>>> # dictionary sorted by key -- OrderedDict(sorted(d.items()) also works
>>> 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)])

>>> # dictionary sorted by length of the key string
>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])

В самих словарях нет заказанных элементов как таковых, если вы захотите распечатать их и т. Д. В определенном порядке, вот несколько примеров:

В Python 2.4 и выше:

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

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

дает:

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

(Python ниже 2.4 :)

keylist = mydict.keys()
keylist.sort()
for key in keylist:
    print "%s: %s" % (key, mydict[key])

Источник: http://www.saltycrane.com/blog/2007/09/how-to-sort-python-dictionary-by-keys/

Как уже упоминалось, словари по своей природе неупорядочены. Однако, если проблема заключается просто в отображении словарей в упорядоченном виде, вы можете переопределить метод __str__ в подклассе словарей и использовать этот класс словаря, а не встроенный dict. Например,

class SortedDisplayDict(dict):
   def __str__(self):
       return "{" + ", ".join("%r: %r" % (key, self[key]) for key in sorted(self)) + "}"


>>> d = SortedDisplayDict({2:3, 1:89, 4:5, 3:0})
>>> d
{1: 89, 2: 3, 3: 0, 4: 5}

Обратите внимание: это ничего не меняет в том, как хранятся ключи, в том порядке, в котором они будут возвращаться, когда вы перебираете их и т. Д., Только в том, как они отображаются с помощью print или в консоли python.