How To Sort Dict By Its Keys

How to Sort Dict by Its Keys: A Complete Guide

Dictionaries are one of the most versatile and widely used data structures in Python. They allow you to store data in key-value pairs, making retrieval fast and intuitive. That said, unlike lists or tuples, dictionaries do not maintain a guaranteed order in older versions of Python. Even though modern Python (3.7 and above) preserves insertion order, there are many situations where you need to sort a dictionary by its keys to make your data more readable, organized, or ready for further processing. Whether you are preparing data for display, performing comparisons, or feeding information into another system, knowing how to sort a dictionary by its keys is an essential skill for any Python developer.

This guide will walk you through every major method available for sorting a dictionary by its keys. You will learn the theory behind each approach, see practical code examples, and understand when to use each technique. By the end of this article, you will have a thorough understanding of dictionary sorting that you can apply to your own projects with confidence Nothing fancy..

Honestly, this part trips people up more than it should.

Understanding Dictionaries and Key Sorting

Don't overlook before diving into the methods, it. It carries more weight than people think. A dictionary is an unordered collection of items. Each item has a key and a value. Still, in Python 3. 7 and later, dictionaries remember the order in which items were inserted, but this does not mean they are sorted alphabetically or numerically by default Worth keeping that in mind..

When we talk about sorting a dictionary by its keys, we are essentially rearranging the items so that the keys appear in a specific order — typically alphabetical for strings or numerical for integers. The important thing to remember is that dictionaries themselves cannot be "sorted in place" the way a list can. Instead, you create a new ordered dictionary or a list of tuples that reflects the sorted order.

Honestly, this part trips people up more than it should.

Method 1: Using the sorted() Function

The most straightforward and commonly used approach to sort a dictionary by its keys is the built-in sorted() function. This function returns a list of the dictionary's keys in sorted order. You can then use this list to build a new dictionary or iterate over the items in the desired order Not complicated — just consistent. Still holds up..

my_dict = {"banana": 3, "apple": 4, "pear": 1, "orange": 2}
sorted_keys = sorted(my_dict.keys())
print(sorted_keys)

The output will be ['apple', 'banana', 'orange', 'pear']. That's why this gives you the keys in alphabetical order. You can then use these sorted keys to access the dictionary values in order.

If you want to create a new dictionary from the sorted keys, you can use a dictionary comprehension:

sorted_dict = {key: my_dict[key] for key in sorted_keys}
print(sorted_dict)

The result will be {'apple': 4, 'banana': 3, 'orange': 2, 'pear': 1}. This method is clean, readable, and works well for most everyday use cases.

Method 2: Using dict() with sorted()

A more concise way to achieve the same result is to combine the dict() constructor directly with sorted(). Since Python 3.7, dictionaries maintain insertion order, so passing sorted keys into the dict() constructor will give you a dictionary with keys in sorted order.

my_dict = {"banana": 3, "apple": 4, "pear": 1, "orange": 2}
sorted_dict = dict(sorted(my_dict.items()))
print(sorted_dict)

This single line of code does everything: it sorts the dictionary items by keys and creates a new dictionary. In real terms, items(), returns a list of tuples sorted by the first element of each tuple, which is the key. The sorted()function, when applied tomy_dict.The dict() constructor then converts this sorted list back into a dictionary.

Method 3: Using operator.itemgetter

For more complex sorting scenarios, you might want to use the operator.itemgetter function from the operator module. While this is more commonly used for sorting lists of dictionaries or tuples, it can also be applied when sorting dictionary items.

import operator

my_dict = {"banana": 3, "apple": 4, "pear": 1, "orange": 2}
sorted_items = sorted(my_dict.items(), key=operator.itemgetter(0))
sorted_dict = dict(sorted_items)
print(sorted_dict)

The operator.itemgetter(0) tells the sorted() function to sort based on the first element of each tuple, which is the key. This approach is functionally equivalent to the previous methods but can be useful when you are already working with the operator module or when you want to make the sorting logic more explicit.

You'll probably want to bookmark this section Worth keeping that in mind..

Method 4: Using lambda Functions as the Key Argument

Another powerful technique is to use a lambda function as the key argument in the sorted() function. This is especially useful when you want to customize the sorting behavior beyond simple alphabetical or numerical order.

my_dict = {"banana": 3, "apple": 4, "pear": 1, "orange": 2}
sorted_dict = dict(sorted(my_dict.items(), key=lambda item: item[0]))
print(sorted_dict)

Here, lambda item: item[0] extracts the key from each dictionary item tuple. This approach gives you the flexibility to sort by keys in reverse order, by the length of the key, or by any other derived property Practical, not theoretical..

To sort in reverse order, simply add the reverse=True parameter:

sorted_dict_desc = dict(sorted(my_dict.items(), key=lambda item: item[0], reverse=True))
print(sorted_dict_desc)

This will give you the keys in reverse alphabetical order And that's really what it comes down to. Turns out it matters..

Method 5: Using collections.OrderedDict

Although modern Python dictionaries maintain insertion order, there are situations where you might want to use the OrderedDict class from the collections module. This is particularly relevant if you are working with older versions of Python or if you need to guarantee order-sensitive behavior in your code Nothing fancy..

from collections import OrderedDict

my_dict = {"banana": 3, "apple": 4, "pear": 1, "orange": 2}
sorted_dict = OrderedDict(sorted(my_dict.items()))
print(sorted_dict)

The OrderedDict explicitly preserves the order of insertion, which can be helpful when the order of keys matters for downstream processing or when you need to serialize the dictionary to a format like JSON Easy to understand, harder to ignore..

Sorting Dictionaries with Non-String Keys

One of the advantages of Python's sorted() function is that it can handle various types of keys, not just strings. If your dictionary uses integer keys, the sorting will work numerically.

my_dict = {3: "three", 1: "one", 4: "four", 2: "two"}
sorted_dict = dict(sorted(my_dict.items()))
print(sorted_dict)

The output will be {1: 'one', 2: 'two', 3: 'three', 4: 'four'}. The keys are sorted in ascending numerical order Most people skip this — try not to..

If your dictionary has mixed-type keys, you need to be careful because Python cannot compare different types directly. In such cases, you may need to convert the keys to a common type or use a custom sorting function

that can be applied to achieve the desired result.

Handling Mixed-Type Keys

When dealing with dictionaries that contain mixed-type keys, one common strategy is to convert all keys to strings before sorting. This ensures that Python can compare them without raising a TypeError Worth keeping that in mind. Still holds up..

my_dict = {3: "three", "1": "one", 4: "four", "2": "two"}
sorted_dict = dict(sorted(my_dict.items(), key=lambda item: str(item[0])))
print(sorted_dict)

By converting each key to a string with str(item[0]), the sorting is performed lexicographically, allowing both integers and strings to coexist in the comparison. Still, be aware that this changes the sort order — for example, "10" would come before "2" because string comparison is character-by-character.

If you need to maintain numerical order while still accommodating mixed types, you can use a more sophisticated key function:

my_dict = {3: "three", "1": "one", 4: "four", "2": "two"}
sorted_dict = dict(sorted(my_dict.items(), key=lambda item: int(item[0])))
print(sorted_dict)

Here, int(item[0]) forces each key to be treated as an integer, producing the correct numerical order regardless of whether the original key was an int or a str.

Sorting by Values Instead of Keys

While much of this article has focused on sorting by keys, you can equally easily sort by values. This is accomplished by changing the index used in the key function from item[0] (the key) to item[1] (the value).

my_dict = {"banana": 3, "apple": 4, "pear": 1, "orange": 2}
sorted_by_value = dict(sorted(my_dict.items(), key=lambda item: item[1]))
print(sorted_by_value)

This will output {'pear': 1, 'orange': 2, 'banana': 3, 'apple': 4}, sorting the dictionary from the smallest value to the largest. To sort in descending order by value, simply add reverse=True:

sorted_by_value_desc = dict(sorted(my_dict.items(), key=lambda item: item[1], reverse=True))
print(sorted_by_value_desc)

This technique is especially handy when working with frequency counts, scores, or any scenario where the magnitude of the value determines the priority.

Practical Considerations and Best Practices

When choosing a sorting method, keep the following tips in mind:

• Performance: For large dictionaries, the sorted() function combined with dict() is generally the fastest and most Pythonic approach. The operator.itemgetter method offers a slight edge in readability and sometimes in speed when the key function is called millions of times.
• Readability: If your sorting logic is simple — such as sorting by key or value — a plain lambda is perfectly clear. For more complex logic, consider defining a named function instead, which makes debugging and maintenance easier.
• Immutability: Remember that sorted() returns a new dictionary. The original dictionary remains unchanged. If you need to sort in place, you will need to reassign the result back to your variable.
• Version Compatibility: If your code must run on Python 3.6 or earlier, consider using OrderedDict to make sure the sorted order is preserved reliably across all operations.

Conclusion

Sorting dictionaries in Python is a fundamental skill that unlocks cleaner data processing, more readable output, and more predictable behavior in your programs. Whether you choose the built-in sorted() function with a lambda, the operator.In real terms, itemgetter approach, or the OrderedDict class, each method has its strengths and ideal use cases. That's why for most modern Python codebases, the sorted() function paired with a lambda or itemgetter as the key argument strikes the best balance between simplicity, performance, and flexibility. By mastering these techniques, you will be well-equipped to handle any dictionary-sorting challenge that comes your way Not complicated — just consistent. That alone is useful..

Easier said than done, but still worth knowing.