Jak mogę posortować słownik według klucza?

Same słowniki nie mają zamówionych pozycji jako takich, jeśli chcesz je wydrukować itp. w jakiejś kolejności, oto kilka przykładów:

W Pythonie 2.4 i wyżej:

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

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

Daje:

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

(Python poniżej 2.4:)

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

Źródło: http://www.saltycrane.com/blog/2007/09/how-to-sort-python-dictionary-by-keys/

Z dokumentacji Biblioteki Pythona 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)])

Dla CPython / PyPy 3.6 i dowolnego Pythona 3.7 lub wyższego, można to łatwo zrobić za pomocą:

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

Istnieje wiele modułów Pythona, które zapewniają implementacje słownikowe, które automatycznie utrzymują klucze w posortowanej kolejności. Rozważmy moduł sortedcontainers , który jest implementacją pure-Python i fast-as-C. Istnieje również porównanie wydajności z innymi popularnymi opcjami porównywanymi ze sobą.

Użycie uporządkowanego dict jest nieodpowiednim rozwiązaniem, jeśli trzeba stale dodawać i usuwać pary klucz / wartość, a także iteracja.

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

Typ SortedDict obsługuje również wyszukiwanie i usuwanie zindeksowanych lokalizacji, co nie jest możliwe przy wbudowanym typie dict.

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

Po Prostu:

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

for k,v in sd:
    print k, v

Wyjście:

1 89
2 3
3 0
4 5

Jak już wspominali inni, słowniki są z natury nieuporządkowane. Jednakże, jeśli problem polega jedynie na wyświetlaniu słowników w uporządkowany sposób, możesz nadpisać metodę __str__ w podklasie słownika i użyć tej klasy słownika zamiast wbudowanej dict. Np.

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}

Uwaga, to nie zmienia nic o tym, jak klucze są przechowywane, kolejności, w jakiej będą one zwracane, gdy będziesz je powtarzał itp., tylko jak są wyświetlane z print lub w konsoli Pythona.

W Pythonie 3.

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

Daje

1 89
2 3
3 0
4 5

Znaleziono inny sposób:

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

Upd:
1. sortuje również zagnieżdżone obiekty(dzięki @ DanielF).
2. słowniki Pythona nie są uporządkowane, dlatego jest to możliwe do wydrukowania lub przypisania tylko do str.

Słownik Pythona nie był uporządkowany przed Pythonem 3.6. W implementacji Pythona 3.6, dictionary zachowuje kolejność wstawiania. Od wersji Python 3.7 będzie to funkcja języka.

W changelog Pythona 3.6 (https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-compactdict):

Aspekt zachowania porządku w tej nowej implementacji jest brany pod uwagę szczegółowej realizacji i nie należy się na niej powoływać (może to zmiany w przyszłości, ale to chce mieć ten nowy dict implementacja w języku na kilka wydań przed zmianą Spec języka na zlecenie-zachowanie semantyki dla wszystkich obecnych i przyszłych implementacji Pythona; pomaga to również zachować wsteczna-kompatybilność ze starszymi wersjami języka, gdzie losowa kolejność iteracji nadal obowiązuje, np. Python 3.5).

W dokumencie Pythona 3.7 ( https://docs.python.org/3.7/tutorial/datastructures.html#dictionaries):

Performing list (d) w słowniku zwraca listę wszystkich używanych kluczy w słowniku w kolejności wstawiania (Jeśli chcesz go posortować, po prostu użyj posortowane(D) zamiast).

Więc w przeciwieństwie do poprzednich wersji, można sortować dict po Pythonie 3.6/3.7. Jeśli chcesz posortować zagnieżdżony dict, w tym sub-dict wewnątrz, możesz do:

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

def dict_reorder(item):
    return {k: sort_dict(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

Tutaj znalazłem najprostsze rozwiązanie do sortowania dict Pythona według klucza za pomocą pprint. np.

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

Ale podczas korzystania z pprint zwróci sortowane dict

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

Istnieje łatwy sposób sortowania słownika.

Zgodnie z twoim pytaniem,

Rozwiązaniem jest:

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

(gdzie c, to nazwa Twojego słownika.)

Ten program daje następujące wyjście:

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

Jak u wanted.

Inny przykład to:

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

Daje wyjście: ['Albert', 'Bill', 'John', 'Lucy', 'Peter']

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

Daje wyjście: [18, 24, 32, 36, 41]

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

Daje wyjście:

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

Dlatego zmieniając go na klucze, wartości i elementy, można wydrukować tak jak chciałeś.Mam nadzieję, że to pomoże!

Łatwy sposób na to:

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} 

Możesz utworzyć nowy słownik, sortując bieżący słownik według klucza zgodnie z twoim pytaniem.

To jest Twój Słownik

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

Utwórz nowy słownik d1 sortując ten d przy użyciu funkcji lambda

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

D1 powinno być {1: 89, 2: 3, 3: 0, 4: 5}, sortowane na podstawie kluczy w d.

Wygeneruje dokładnie to, co chcesz:

 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}

Ale nie jest to poprawny sposób, aby to zrobić, ponieważ, może to pokazać wyraźne zachowanie z różnych słowników, których nauczyłem się ostatnio. Stąd perfect way został zasugerowany przez Tim w odpowiedzi na moje pytanie, które dzielę się tutaj.

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

Myślę, że najprostszą rzeczą jest posortowanie dict według klucza i zapisanie posortowanej pary klucz: wartość w nowym 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]

Żeby było jaśniej:

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

Dyski Pythona nie są uporządkowane. Zazwyczaj nie jest to problem, ponieważ najczęstszym przypadkiem użycia jest wykonanie wyszukiwania.

Najprostszym sposobem zrobienia tego, co chcesz, byłoby utworzenie collections.OrderedDict wstawiania elementów w porządku posortowanym.

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

Jeśli potrzebujesz iteracji, jak sugerują inni powyżej, najprostszym sposobem byłoby iteracja nad sortowanymi kluczami. Przykłady -

Wypisuje wartości posortowane według kluczy:

# 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

Lista wartości posortowanych według kluczy:

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

Ta funkcja posortuje każdy słownik rekurencyjnie według swojego klucza. Oznacza to, że jeśli jakakolwiek wartość w słowniku jest również słownikiem, to również będzie posortowana według klucza. Jeśli używasz CPython 3.6 lub nowszego, można wprowadzić prostą zmianę w używaniu dict zamiast 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)

Wymyślam jednolinijkowe sortowanie dict.

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

Komplikujecie sprawy... to naprawdę proste

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

Wyjście To:

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

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)

Najprostszym rozwiązaniem jest to, że należy uzyskać listę dict klucz jest posortowane porządku, a następnie iterate nad dict. Na przykład

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]

Poniżej będzie wyjście (desending order)

e 30
b 13
d 4
c 2
a 1

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

Porównanie czasu dwóch metod w 2.7 pokazuje, że są praktycznie identyczne:

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

Lub użyć pandas,

Demo:

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

Zobacz:

Docs of this

Dokumentacja całych pand

Ze względu na sposób sformułowania pytania, większość odpowiedzi tutaj odpowiada poprawnie.

Jednak biorąc pod uwagę, jak rzeczy powinny być naprawdę zrobione, biorąc pod uwagę dziesiątki i dekady informatyki, przychodzi do mojego całkowitego zdziwienia, że istnieje tak naprawdę tylko {10]}jedna odpowiedź tutaj (od GrantJ {11]} user) sugerująca użycie sortowanych kontenerów asocjacyjnych (sortedcontainers), które sortują elementy na podstawie klucza w punkcie ich wstawiania.

Że uniknie ogromnego wpływu wydajności na każde wywołanie sort(...) (minimum O(N*log(N)), Gdzie N jest liczbą elementów (logicznie, dotyczy to wszystkich takich rozwiązań, które sugerują użycie sort(...)). Należy wziąć pod uwagę, że dla wszystkich takich rozwiązań, sort(...) będzie musiał być wywołany za każdym razem, gdy colletion musi być dostępny jako sortowane po został zmodyfikowany przez dodanie / usunięcie elementów ...

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)

Moja sugestia jest taka, ponieważ pozwala sortować dict lub utrzymywać dict sortowane podczas dodawania przedmiotów i może być konieczne dodanie przedmiotów w przyszłości:

Zbuduj dict od podstaw, jak idziesz dalej. Miej drugą strukturę danych, listę, z listą kluczy. Pakiet bisect posiada funkcję insort, która pozwala wstawić do posortowanej listy lub posortować listę po całkowitym wypełnieniu dict. Teraz, kiedy powtarzasz swój dict, zamiast tego powtarzasz listę, aby uzyskać dostęp do każdego z nich klucz w sposób uporządkowany, nie martwiąc się o reprezentację struktury dict (która nie została stworzona do sortowania).