How to create a sorted dictionary in Python by key (alphabetically)

Question

As of Python 3.7, dictionaries are "ordered", where iteration is based on "insertion order".

I would like a dictionary in Python where iteration is based on the alphabetical order of the keys, i.e. the dictionary is sorted alphabetically by key.

That is, the following dictionary:

dictionary = {}
dictionary["b"] = 1
dictionary["a"] = 2

Will result in the following output:

for key in dictionary:
    print(key) # a, b

Is there some built-in Python class for "sorted dictionaries", similar to how we have OrderedDict for insertion order?

Note: I do not believe that this is a duplicate of any existing questions, which seem to only mention:

Ordered dictionaries (dictionaries sorted by insertion-order) -- this is not what I'm looking for.
Dictionaries sorted by value -- I'm looking for dictionaries sorted by key.
Sorting a dictionary after-the-fact rather than automatically (and efficiently) as elements are added/removed.

I have done many Google searches and couldn't find an answer.

I highly doubt there would be a built-in class for an alphabetically sorted dictionary since it would be limited by only having strings as keys. — Sujal Singh, Dec 22 '21 at 13:15
@SujalSingh I would imagine there would be some class for sorted dictionaries that might take in a lambda sort function or something like that. That way it's not necessarily just for strings. — David Callanan, Dec 22 '21 at 13:17
Not builtin - the closest is SortedDict module: http://www.grantjenks.com/docs/sortedcontainers/ — match, Dec 22 '21 at 13:23
@SujalSingh Nah, you just need a dict sorting by keys. Then with string keys it would automatically be alphabetically. — Kelly Bundy, Dec 22 '21 at 13:23
@d.b That's probably somewhat the "after-the-fact" they're not interested in. — Kelly Bundy, Dec 22 '21 at 13:25
@KellyBundy, I think after-the-fact is more efficient than repeatedly reordering elements at each insertion. Maybe I'm missing something... — d.b, Dec 22 '21 at 13:29
might be a stupid question but what if the dictionary has tuples as keys, how would it be sorted then? — Sujal Singh, Dec 22 '21 at 13:34
@DavidCallanan How are you using the sortedness? Do you iterate through the whole dict after every k-th insertion/removal or so? — Kelly Bundy, Dec 22 '21 at 13:35
@KellyBundy That's good to know that there's a module for it, even if it's not built-in. I'll try that. — David Callanan, Dec 22 '21 at 13:37
@d.b Perhaps it is less efficient doing it continuously, especially if the implementation uses hashes. — David Callanan, Dec 22 '21 at 13:39
@SujalSingh If the keys were tuples, you would provide a custom sorting function for that scenario. — David Callanan, Dec 22 '21 at 13:39
@DavidCallanan Unless the default tuple ordering is what you want :-) — Kelly Bundy, Dec 22 '21 at 13:40
@KellyBundy Every few insertions or removals I may need to iterate, and good chance I'll break early as well. — David Callanan, Dec 22 '21 at 13:40
@DavidCallanan how about a custom class that stores the dictionary as is but only when the class is iterated over it returns the elements in the order you desire? — Sujal Singh, Dec 22 '21 at 13:43
Maybe this [post](https://stackoverflow.com/questions/9001509/how-can-i-sort-a-dictionary-by-key) contains the answer to your question. — Code Plus, Dec 22 '21 at 13:53

baskettaz · Answer 1 · 2021-12-22T14:13:39.517

There is actually a solution, which is from Mark Summerfield : Rapid GUI Programming with Python and I would humbly transfer it here. All the respect for Mark :)

import bisect

class CustomOrderedDict(object):
    def __init__(self, dictionary=None):
        self.__keys = {}
        self.__dict = []
        if dictionary is not None:
            if isinstance(dictionary, CustomOrderedDict):
                self.__dict = dictionary.__dict.copy()
                self.__keys = dictionary.__keys[:]
            else:
                self.__dict = dict(dictionary).copy()
                self.__keys = sorted(self.__dict.keys())

    def getAt(self, index):
        return self.__dict[self.__keys[index]]

    def setAt(self, index, value):
        self.__dict[self.__keys[index]] = value
        return self.__dict[self.__keys[index]]

    def __getitem__(self, key):
        return self.__dict[key]

    def __setitem__(self, key, value):
        if key not in self.__dict:
            bisect.insort_left(self.__keys, key)
        self.__dict[key] = value

    def __delitem__(self, key):
        i = bisect.bisect_left(self.__keys, key)
        del self.__keys[i]
        del self.__dict[key]

    def setdefault(self, key, value):
        if key not in self.__dict:
            bisect.insort_left(self.__keys, key)
        return self.__dict.setdefault(key, value)

    def pop(self, key, value=None):
        if key not in self.__dict:
            return value
        i = bisect.bisect_left(self.__keys, key)
        del self.__keys[i]
        return self.__dict.pop(key, value)

    def popitem(self):
        item = self.__dict.popitem()
        i = bisect.bisect_left(self.__keys, item[0])
        del self.keys[i]
        return item

    def has_key(self, key):
        return key in self.__dict

    def __contains__(self, key):
        return key in self.__dict

    def __len__(self):
        return len(self.__dict)

    def keys(self):
        return self.__keys[:]

    def values(self):
        return [self.__dict[key] for key in self.__keys]

    def __iter__(self):
        return iter(self.__keys)

    def iterkeys(self):
        return iter(self.__keys)

    def itervalues(self):
        for key in self.__keys:
            yield self._dict[key]

    def iteritems(self):
        for key in self.__keys:
            yield key, self.__dict[key]

    def copy(self):  # shallow copy
        dictionary = CustomOrderedDict()
        dictionary.__keys = self.__keys[:]
        dictionary.__dict = self.__dict.copy()
        return dictionary

    def clear(self):
        self.__keys = []
        self.__dict = {}

    def __repr__(self):
        pieces = []
        for key in self.__keys:
            pieces.append("%r: %r" % (key, self.__dict[key]))  
        return "CustomOrderedDict({%s})" % ", ".join(pieces)


t = CustomOrderedDict(dict(s=1, a = 2, b =100, c = 200))


print t

RESULT :

CustomOrderedDict({'a': 2, 'b': 100, 'c': 200, 's': 1})

This is a very advanced solution, but I think it is very elegant and does have all the functionality of the normal dictionary. — baskettaz, Dec 22 '21 at 13:53
Hmm, from a "very advanced" solution I'd expect better than linear time insertion/removal. — Kelly Bundy, Dec 22 '21 at 14:10
I see you removed the funny code comments that had made me chuckle. Sad. — Kelly Bundy, Dec 22 '21 at 14:14

How to create a sorted dictionary in Python by key (alphabetically)

1 Answers1