Sort a dictionary by value in Python

In Python 3.7 and later, dictionaries are ordered by default, which means they remember the order in which you add key-value pairs. When you loop through a dictionary, you will get the items in the same order they were inserted. This order-preserving behavior makes it possible to sort a dictionary in Python. 

In this blog post, I will guide you through different approaches to sorting a dictionary by value in Python. We will cover the following topics:

• Sort a dictionary by values using sorted() and lambda function
• Sort a dictionary by values in descending order
• Sort a dictionary by values using sorted() and itemgetter()
• Error handling
• Conclusion

Sort a dictionary by values using sorted() and lambda function

You can sort a dictionary by its values using the sorted() function along with the lambda function that accesses the value of each key-value pair.

Here’s how you can do it:

my_dict = {"Alice": 90, "John": 50, "Bob": 70}

sorted_dict = dict(sorted(my_dict.items(), key=lambda x: x[1]))

print(sorted_dict)  # Output: {'John': 50, 'Bob': 70, 'Alice': 90}

Let’s understand how the code works:

• my_dict.items() returns a view object containing the key-value pairs of the dictionary as tuples in a list. In our case, it would be ([('Alice', 90), ('John', 50), ('Bob', 70)])
• sorted(my_dict.items(), key=lambda x: x[1] sorts the list of tuples based on the values (the second element of each tuple x[1]). The key=lambda x: x[1] part is a lambda function that tells the sorted() function to use the second element of each tuple (x[1]) as the sorting key. This means that the list will be sorted in ascending order based on the values. The resulting sorted list would be [('John', 50), ('Bob', 70), ('Alice', 90)].
• dict(...) takes an iterable (in our case, the sorted list of tuples) and creates a new dictionary from it. So dict(sorted(my_dict.items(), key=lambda x: x[1])) creates a new dictionary with the key-value pairs from the sorted list.

The new dictionary is assigned to the variable sorted_dict.

So, in summary, the above code takes a dictionary, sorts its key-value pairs based on the values in ascending order, and creates a new dictionary with the sorted key-value pairs. The original dictionary (my_dict) remains unchanged.

Sort a dictionary by values in descending order

You can sort a dictionary by values in descending order by setting the reverse parameter of the sorted() function to True.

Here’s an example:

my_dict = {"Alice": 90, "John": 50, "Bob": 70}

sorted_dict = dict(sorted(my_dict.items(), key=lambda x: x[1], reverse=True))

print(sorted_dict)  # Output: {'Alice': 90, 'Bob': 70, 'John': 50}

Sort a dictionary by values using sorted() and itemgetter() function

The itemgetter() function from the operator module in Python retrieves items from objects (like lists, tuples, or dictionaries) based on their index or key.

The itemgetter() function is a more efficient and readable way to sort dictionaries by values compared to lambda functions.

Here’s an example:

from operator import itemgetter

my_dict = {"Alice": 90, "John": 50, "Bob": 70}

sorted_dict = dict(sorted(my_dict.items(), key=itemgetter(1)))

print(sorted_dict)  # Output: {'John': 50, 'Bob': 70, 'Alice': 90}

In this example, key=itemgetter(1) is used to specify that we want to sort the list of (key, value) pairs based on the second element of each tuple (which is the value, index of the key is 0).

The performance difference between itemgetter() and lambda functions is negligible for small dictionaries. However, itemgetter() is more efficient for larger dictionaries or when sorting needs to be performed repeatedly.

Error Handling

When you try to sort a dictionary by its values in Python, you might run into some errors. One of the most common problems you will face is TypeError.

TypeError:

This error occurs if you try to sort a dictionary by values of different data types that cannot be compared (e.g., integers and strings).

Solution: Check the data type before sorting and convert them if necessary.

Here’s an example that displays an error message if you try to sort a dictionary by values of different data types:

my_dict = {"Alice": 90, "John": "50", "Bob": 70}

try:
    sorted_dict = dict(sorted(my_dict.items(), key=lambda x: x[1], reverse=True))
    print(sorted_dict)  # Output: {'Alice': 90, 'Bob': 70, 'John': 50}
except TypeError:
    print("TypeError: The dictionary contains inappropriate data for sorting")

# Output: TypeError: The dictionary contains inappropriate data for sorting

In this example, the value associated with the key "John" is a string ("50") instead of an integer. When you try to sort the dictionary items using the sorted() function and the lambda function key=lambda x: x[1], it attempts to compare the string "50" with the integers 90 and 70, which leads to a TypeError.

In Python, you cannot directly compare a string and an integer using the default comparison operators (<, >, <=, >=). This is because Python doesn’t implicitly convert data types during comparisons.

Here’s another example that converts all the values of a dictionary to integers, then sorts the dictionary items based on the integer values in ascending order:

my_dict = {"Alice": 90, "John": "50", "Bob": 70}

# Convert values to integers if possible
try:
    my_dict = {k: int(v) for k, v in my_dict.items()}
except ValueError:
    print("ValueError: Unable to convert all values to integers")

try:
    sorted_dict = dict(sorted(my_dict.items(), key=lambda x: x[1]))
    print(sorted_dict)
except TypeError:
    print("TypeError: The dictionary contains inappropriate data for sorting")

# Output: {'Alice': 90, 'Bob': 70, 'John': 50}

Conclusion

In this blog post, we explored various approaches to sorting a dictionary by values in Python. We learned how to use the sorted() function along with the lambda function or itemgetter() function from the operator module to achieve sorting in both ascending and descending order.

We also discussed potential errors that might arise during sorting and how to handle them using try-except blocks.

For larger dictionaries, itemgetter() may provide better performance than lambda functions when sorting frequently.

It is worth noting that while dictionaries in Python 3.7 and later are ordered, they should still be used for key-value storage and retrieval, not as a replacement for ordered data structures like lists or tuples when order is a critical requirement.

By understanding these techniques, you can effectively manipulate and organize dictionaries based on their values in Python. Feel free to choose the method that best suits your specific needs.

Rock the code → 3000