Skip to content

Sorting a Python Dictionary by Value


Sorting a Python Dictionary: Values, Keys, and More

Sorting dictionaries in Python can be a useful way to organize and manipulate key-value pairs. In this tutorial, we will explore different methods to sort dictionaries, using detailed step-by-step sample codes.

Rediscovering Dictionary Order in Python

Before Python 3.6, dictionaries in Python were inherently unordered. However, starting from Python 3.6, dictionaries conserve insertion order. From Python 3.7 onwards, the insertion order in dictionaries is guaranteed.

Understanding What Sorting A Dictionary Really Means

Sorting a dictionary typically involves rearranging the key-value pairs based on specific criteria such as values, keys, or nested attributes. It is important to understand the different sorting methods available in Python to achieve the desired results effectively.

Sorting Dictionaries in Python

Using the sorted() Function

One of the simplest ways to sort a dictionary is by using the sorted() function. This function takes in the dictionary as an argument and returns a new list containing the sorted key-value pairs.

my_dict = {'apple': 4, 'banana': 2, 'orange': 5}
sorted_dict = sorted(my_dict.items(), key=lambda x: x[1])

Getting Keys, Values, or Both From a Dictionary

To sort dictionaries based on keys or values, you can use the items() method to retrieve the key-value pairs. By specifying a sort key, you can control the sorting behavior.

my_dict = {'apple': 4, 'banana': 2, 'orange': 5}
sorted_keys = sorted(my_dict.keys())
sorted_values = sorted(my_dict.values())
sorted_items = sorted(my_dict.items(), key=lambda x: x[1])

Understanding How Python Sorts Tuples

When sorting dictionaries, it is important to understand how Python sorts tuples. By default, Python sorts tuples based on their first element, then the second, and so on. You can use this knowledge to sort dictionaries based on multiple criteria.

Using the key Parameter and Lambda Functions

The key parameter of the sorted() function allows you to specify a custom sorting criteria. You can use lambda functions to create one-liner sorting functions that target specific attributes of the dictionary.

my_dict = {'apple': {'quantity': 4}, 'banana': {'quantity': 2}, 'orange': {'quantity': 5}}
sorted_dict = sorted(my_dict.items(), key=lambda x: x[1]['quantity'])

Selecting a Nested Value With a Sort Key

In some cases, you may want to sort dictionaries based on values nested within the key-value pairs. You can achieve this by using the itemgetter() function from the operator module.

from operator import itemgetter
my_dict = {'apple': {'quantity': 4}, 'banana': {'quantity': 2}, 'orange': {'quantity': 5}}
sorted_dict = sorted(my_dict.items(), key=itemgetter(1, 'quantity'))

Converting Back to a Dictionary

After sorting a dictionary, you might need to convert it back to its original form. This can be done using dictionary comprehensions or the dict() constructor.

sorted_items = [('banana', 2), ('apple', 4), ('orange', 5)]
sorted_dict = {k: v for k, v in sorted_items}

Considering Strategic and Performance Issues

When sorting dictionaries, it is important to consider strategic and performance issues. Depending on your use case, you may need to optimize your sorting methods to increase performance and overall readability.

Using Special Getter Functions to Increase Performance and Readability

The itemgetter() function can significantly improve performance and readability when sorting dictionaries. By specifying the desired sort attributes, you can avoid excessive function calls and achieve faster sorting.

Measuring Performance When Using itemgetter()

To measure the performance of sorting dictionaries using the itemgetter() function, you can utilize the timeit module. This module allows you to time your code and compare the performance of different sorting methods.

Judging Whether You Want to Use a Sorted Dictionary

While sorting dictionaries can be useful in certain scenarios, it is essential to consider whether using a sorted dictionary is the best approach for your specific needs. Depending on the data structure and usage pattern, alternative data structures might offer better performance.

Comparing the Performance of Different Data Structures

To evaluate the performance of different data structures, you can utilize the timeit module. By comparing the execution times of various operations, you can identify the most efficient data structure for your specific requirements.

Comparing the Performance of Sorting

Sorting can have a significant impact on the performance of your code. By comparing the execution times of different sorting methods, you can choose the most efficient approach for your particular use case.

Comparing the Performance of Lookups

Lookups are an essential aspect of working with dictionaries. By comparing the performance of lookups in different data structures, you can optimize your code for faster operations.


Sorting dictionaries in Python can be an effective way to organize and manipulate key-value pairs. This tutorial provided detailed, step-by-step sample codes and explanations of various sorting methods available in Python. By considering strategic and performance issues, you can optimize your sorting methods and achieve faster execution times.