Skip to content

Effortlessly Sort Python Dict


Sorting a Python Dictionary: Values, Keys, and More

You’ve got a dictionary, but you’d like to sort the key-value pairs. Perhaps you’ve tried passing a dictionary to the sorted() function but haven’t gotten the results you expected. In this tutorial, you’ll go over everything you need to know if you want to sort dictionaries in Python.

Rediscovering Dictionary Order in Python

Before Python 3.6, dictionaries were inherently unordered. A Python dictionary is an implementation of the hash table, which is traditionally an unordered data structure.

As a side effect of the compact dictionary implementation in Python 3.6, dictionaries started to conserve insertion order. From Python 3.7 onwards, the insertion order of dictionaries is guaranteed.

Understanding What Sorting A Dictionary Really Means

Sorting a dictionary means arranging its key-value pairs based on specific criteria such as the values, the keys, or even nested attributes. The sorted() function in Python allows you to achieve this.

Sorting Dictionaries in Python

Using the sorted() Function

To sort a dictionary in Python, you can use the sorted() function along with the key parameter. The key parameter specifies a function of one argument that is used to extract a comparison key from each dictionary item.

Here’s an example of using the sorted() function to sort a dictionary based on its values in ascending order:

my_dict = {'c': 2, 'a': 1, 'b': 3}
sorted_dict = sorted(my_dict.items(), key=lambda x: x[1])

In this example, the key parameter uses a lambda function to extract the second element (value) of each dictionary item. The resulting sorted_dict will be a list of tuples sorted by the values in ascending order.

Getting Keys, Values, or Both From a Dictionary

If you want to sort a dictionary based on its keys or values, you can use the keys() or values() methods respectively. These methods return dictionary views that can be used with the sorted() function.

Here’s an example of sorting a dictionary based on its keys:

my_dict = {'c': 2, 'a': 1, 'b': 3}
sorted_keys = sorted(my_dict.keys())

In this example, the sorted_keys variable will contain a list of the keys of the dictionary sorted in ascending order.

Understanding How Python Sorts Tuples

When sorting dictionaries, Python compares the items based on their comparison keys. By default, when comparing two tuples (which are the items of the dictionary), Python compares the first element and then the second element and so on until a difference is found.

Using the key Parameter and Lambda Functions

The key parameter of the sorted() function allows you to specify a function that extracts a comparison key from each item of the dictionary. This function can be defined using a lambda function, which is a convenient way to create small anonymous functions.

Here’s an example of sorting a dictionary based on its keys in descending order:

my_dict = {'c': 2, 'a': 1, 'b': 3}
sorted_keys_desc = sorted(my_dict.keys(), key=lambda x: x, reverse=True)

In this example, the key parameter uses a lambda function that simply returns the key itself. The reverse=True argument is used to sort the keys in descending order.

Selecting a Nested Value With a Sort Key

If your dictionary contains nested values and you want to sort based on a specific nested attribute, you can use a more complex lambda function as the key parameter.

Here’s an example of sorting a dictionary based on a specific nested attribute:

my_dict = {'a': {'score': 2}, 'b': {'score': 1}, 'c': {'score': 3}}
sorted_dict_nested = sorted(my_dict.items(), key=lambda x: x[1]['score'])

In this example, the lambda function extracts the 'score' value from each nested dictionary, allowing the sorted() function to sort the items based on this attribute.

Converting Back to a Dictionary

After sorting a dictionary, you might want to convert it back to its original format. You can do this using a dictionary comprehension or by passing the sorted list of items to the dict() constructor.

Here’s an example of converting a sorted list of items back to a dictionary:

my_dict = {'c': 2, 'a': 1, 'b': 3}
sorted_dict = sorted(my_dict.items(), key=lambda x: x[1])
sorted_dict = dict(sorted_dict)

In this example, the items() method is used to convert the dictionary to a list of tuples. After sorting the list of tuples, the dict() constructor is used to convert it back to a dictionary.

Considering Strategic and Performance Issues

Sorting dictionaries can have strategic and performance implications. In some cases, alternative data structures or getter functions can provide better performance and readability.

Using Special Getter Functions to Increase Performance and Readability

Instead of using lambda functions as the key parameter, you can use special getter functions such as the itemgetter() function from the operator module. These getter functions can provide better performance compared to lambda functions.

Measuring Performance When Using itemgetter()

To compare the performance of different sorting options, you can use the timeit module to time your code and get tangible results.

Judging Whether You Want to Use a Sorted Dictionary

While sorting a dictionary can be useful in some cases, it’s important to consider whether a sorted dictionary is the best option for your specific use case. There might be alternative data structures or sorting mechanisms that are more suitable.

Comparing the Performance of Different Data Structures

In addition to sorting dictionaries, you may want to consider alternative data structures such as lists or sets, depending on your specific requirements. These data structures may offer better performance for certain operations.

Comparing the Performance of Sorting

Sorting dictionaries can have performance implications, especially when dealing with large datasets. It’s important to understand the time complexity of different sorting algorithms and consider their performance characteristics.

Comparing the Performance of Lookups

In addition to sorting, you should also consider the performance of lookups in your data structure. Depending on your use case, alternative data structures such as sets or hashmaps may offer better lookup performance.


In this tutorial, you learned how to sort dictionaries in Python using the sorted() function and the key parameter. You also explored different ways to extract keys, values, or both from a dictionary and how to specify a sort key using lambda functions. Additionally, you considered strategic and performance issues related to sorting dictionaries and explored alternative data structures for key-value data.

By applying the techniques and concepts covered in this tutorial, you’ll be able to effectively sort dictionaries in Python and optimize your code for better performance and readability.