The Python dictionary is a powerful data structure of key-value pairs indexed by a non-mutable data type. They are inherently unordered though will preserve the order by which items are added. There is no way to sort a python dictionary directly, however, and one must get a little creative.<\/p>\n
Fortunately, one can sort a Python dictionary by converting it to a sortable type such as a list. This involves an intermediary step, or a bold one-liner, but is relatively straightforward. I’ll walk you through some basic gotchas, considerations, and notable options. For those here from Google for a quick answer, check out the TL;DR below:<\/p>\n
TL;DR<\/strong> – Use the built-in sorted function with a lambda expression as the key.<\/p>\n The Python dictionary is a data structure much like the traditional hash table. It pairs a collection of immutable objects such as an integer, string, or float with paired values that can<\/em> be mutable or even collections of values.<\/p>\n Python dictionaries are efficient and come packed with tons of useful built-in methods to help with common tasks. Dictionaries are a bit<\/em> like enums in other languages like Java<\/a> but have some notable differences.<\/p>\n Much like the initial TL;DR example, we’re going to start by creating a randomly ordered dictionary. With that, we’ll be able to look at some approaches that work\u2014and some that don’t. Before we dive in, I’ll take a moment and be that guy\u00a0<\/em>by advising you to read the official Python dictionary documentation<\/a>. It does well to lay out many of the methods made available by the Python dictionary structure that we won’t cover here.<\/p>\n Whoa! That\u00a0almost<\/em> looks like it worked. In this scenario, Python represents dictionaries as keys since (version number citation needed.) Also worth noting is that since PEP448<\/a> one can use unpacking directives to produce a list as such:\u00a0 Additionally, Python allows one to use the Here we see the dictionary has been sorted, using the numeric values as the sorting key. The data is returned as a list of We could also sort the same item based on the Here we can see an order by Python list comprehension<\/a> is one of the reasons I fell in love with this programming language<\/a>. It lets one achieve an impressive workload using one-line logic in a highly optimized fashion. For me, it wasn’t immediately clear that Python also accommodated\u00a0dictionary comprehension<\/em> out-of-the-box. It does, and we’ll showcase how it can be used to sort dictionaries in Python also!<\/p>\n Here we’ve not only\u00a0sorted<\/em> the dictionary by converting it into a list via the sorted(d.items()) approach but we’ve also converted it back to a dictionary. All in one line! Note<\/strong>: we\u00a0technically<\/em> converted it into an intermediary generator object, not a list.<\/p>\n This is looking pretty sweet, but let’s take things a step further and introduce a custom key by which our dictionary will be sorted. For example, let’s say we wanted the dictionary sorted by absolute value from the average value of keys.<\/p>\n Let’s see if we can get a one-liner that is up to the task! For this, I’ll use a slightly longer set of values referencing the ASCII lowercase letters<\/a> made available via the string module:<\/p>\n As you can see, the combination of the key argument, a Python lambda function, and dictionary comprehension can do a lot of work. In this case, I’ve sorted a dictionary of the alphabet by proximity to the average position. Why<\/em> do you ask? Because Python makes it so easy!<\/p>\n Note<\/strong>: Python’s OrderedDict class<\/a> from the collections module was an often-used alternative to Python dictionaries can use a tuple as a key — but that tuple cannot contain a mutable object. For example, tuples are\u00a0themselves\u00a0<\/em>immutable but may contain a structure like a list or an object.<\/p>\n Python’s dictionary structure is an incredible tool for hash-mapping and I use them all the time. I use them commonly when I’m storing credentials locally or in the cloud, working with collections where query times are more important than order, and especially<\/em> when serializing data. Translating between Python dictionaries and JSON-formatted strings is phenomenally easy (here’s looking at\u00a0you<\/em> Java.)<\/p>\n Even when the use-case for dictionaries is strong, I find a need to get a sorted version of a collection or, at the very least, derive some value from the sorted order of keys. Using the methods outlined in this article I find that tasks can be accomplished effectively\u2014often in a one-liner. I hope this article has been helpful and urge everyone to recognize we’ve only covered a fraction of the use cases, implications of use, and methods of the Python dictionary data type. There is\u00a0much\u00a0<\/em>more to know about them<\/a>!<\/p>\n","protected":false},"excerpt":{"rendered":" The Python dictionary is a powerful data structure of key-value pairs indexed by a non-mutable data type. They are inherently unordered though will preserve the order by which items are added. There is no way to sort a python dictionary directly, however, and one must get a little creative. Fortunately, one can sort a Python […]<\/p>\n","protected":false},"author":2,"featured_media":850,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[655,10],"tags":[123,59,351,355,357,352,353,356,354,143,358],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/847"}],"collection":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/comments?post=847"}],"version-history":[{"count":6,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/847\/revisions"}],"predecessor-version":[{"id":3467,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/847\/revisions\/3467"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/850"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=847"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=847"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=847"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}# Create a dictionary with randomly ordered keys\r\n>>> d = {5: 'f', 3: 'd', 0: 'a', 2: 'c', 6: 'g', 1: 'b'}\r\n\r\n# Sort the convert back to dict\r\n>>> d = dict(sorted(d.items()))\r\n\r\n>>> print(d)\r\n{0: 'a', 1: 'b', 2: 'c', 3: 'd', 5: 'f', 6: 'g'}\r\n\r\n>>> type(d)\r\n<class 'dict'><\/pre>\nQuick Introduction<\/h2>\n
Sorting A Python Dictionary<\/h2>\n
# Create a randomly-ordered dictionary\r\nd = {5: 'f', 3: 'd', 0: 'a', 2: 'c', 6: 'g', 1: 'b'}\r\n\r\n# Sort the dictionary\r\nsorted(d)\r\n\r\n>>> [0, 1, 2, 3, 5, 6]<\/pre>\n l = [*d]<\/code> which would result in a list, though not sorted: [5, 3, 0, 2, 6, 1]<\/code>.<\/p>\nitems<\/code> method of the dictionary<\/code> class to return a list of the objects sorted (using the key by default). This is shown in the following code:<\/p>\n# creates the dictionary\r\nd = {5: 'f', 3: 'd', 0: 'a', 2: 'c', 6: 'g', 1: 'b'}\r\n\r\n# sorts the dictionary\r\nd = sorted(d.items())\r\n\r\n[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (5, 'f'), (6, 'g')]\r\n\r\n<\/pre>\ntuple<\/code> objects representing the key-value pairs. Converting this back to a dictionary is as easy as using the built-in dict(d)<\/code> syntax as follows:<\/p>\n# convert to a dictionary\r\nd = dict(d)\r\n\r\n{0: 'a', 1: 'b', 2: 'c', 3: 'd', 5: 'f', 6: 'g'}\r\n<\/pre>\nvalues<\/code> rather than keys<\/code> by using a lambda function as our key<\/code> for the sorted<\/code> function as follows (mixing up the numerical values a bit for a more contrasting example):<\/p>\n# creates the dictionary\r\nd = {10: 'f', 6: 'd', 4: 'a', 2: 'c', 1: 'g', 0: 'b'}\r\n\r\n# sorts the dictionary, converts back to dict in 1 line\r\nd = dict(sorted(d.items(), key=lambda x: x[1]))\r\n\r\n{4: 'a', 0: 'b', 2: 'c', 6: 'd', 10: 'f', 1: 'g'}<\/pre>\nvalues<\/code> such that a->b->c->d->e->f<\/code> even though the corresponding numeric keys are\u00a0wildly<\/em> out-of-order. Note that Python uses the ordinal value of the characters<\/a> to determine the sort order.<\/p>\nSorting with Comprehensions<\/h2>\n
# Create a randomly-ordered dictionary\r\nd = {5: 'f', 3: 'd', 0: 'a', 2: 'c', 6: 'g', 1: 'b'}\r\n\r\n# Sort using dictionary comprehension\r\nd = {k: v for k, v in sorted(d.items())}\r\n\r\n>>> {0: 'a', 1: 'b', 2: 'c', 3: 'd', 5: 'f', 6: 'g'}<\/pre>\n# Create a randomly-ordered dictionary\r\nalpha = {k: v for k, v in zip(range(len(string.ascii_lowercase)), list(string.ascii_lowercase))}\r\n\r\n>>> {0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f', 6: 'g', 7: 'h', 8: 'i', 9: 'j', 10: 'k', 11: 'l', 12: 'm', 13: 'n', 14: 'o', 15: 'p', 16: 'q', 17: 'r', 18: 's', 19: 't', 20: 'u', 21: 'v', 22: 'w', 23: 'x', 24: 'y', 25: 'z'}\r\n\r\n# Order by distance from an calculated value\r\ns = {k: v for k, v in sorted(alpha .items(), key=lambda x: abs(sum(alpha) \/ len(alpha) - x[0]))}\r\n\r\n>>> {12: 'm', 13: 'n', 11: 'l', 14: 'o', 10: 'k', 15: 'p', 9: 'j', 16: 'q', 8: 'i', 17: 'r', 7: 'h', 18: 's', 6: 'g', 19: 't', 5: 'f', 20: 'u', 4: 'e', 21: 'v', 3: 'd', 22: 'w', 2: 'c', 23: 'x', 1: 'b', 24: 'y', 0: 'a', 25: 'z'}\r\n\r\n<\/pre>\ndict<\/code> objects since it preserved insertion order. Since 3.7 the standard dict<\/code> object has provided this functionality and has replaced the need for OrderedDict<\/code> in many cases. OrderedDict<\/code> still has some performance benefits in some cases and shouldn’t be discounted entirely in my opinion.<\/p>\nGotchas<\/h2>\n
Final Thoughts<\/h2>\n