How Do You Sort a Dictionary by Value in Python?

AvatarByBarbara Hernandez Python

Sorting data efficiently is a fundamental skill in programming, and when working with dictionaries in Python, organizing key-value pairs by their values can unlock new ways to analyze and present information. Whether you’re dealing with scores, frequencies, or any numerical data stored in a dictionary, knowing how to sort by value allows you to extract meaningful insights and streamline your code. This technique is not only practical but also enhances the readability and usability of your data structures.

Dictionaries in Python are inherently unordered prior to version 3.7, and even though they maintain insertion order in later versions, sorting them by value requires a deliberate approach. Understanding how to manipulate and reorder dictionaries based on their values can help you tackle a variety of programming challenges, from ranking items to filtering results. This article will guide you through the concepts and methods that make sorting dictionaries by value straightforward and efficient.

By exploring different strategies and Python features, you’ll gain the confidence to handle dictionaries in more dynamic ways. Whether you are a beginner looking to grasp the basics or an experienced developer seeking cleaner solutions, mastering this skill will add a valuable tool to your programming toolkit. Get ready to dive into the world of dictionary sorting and discover how to make your Python code more powerful and intuitive.

Using the sorted() Function with Lambda Expressions

When sorting a dictionary by its values in Python, the `sorted()` function combined with a lambda expression is one of the most straightforward and flexible approaches. The `sorted()` function can sort any iterable, and when applied to a dictionary, it sorts the dictionary’s keys by default. To sort by values instead, you need to specify a custom key function.

The lambda function serves as this key, extracting the dictionary’s values for comparison during sorting. The syntax for sorting a dictionary `d` by its values looks like this:

“`python
sorted_items = sorted(d.items(), key=lambda item: item[1])
“`

Here, `d.items()` returns a view object containing `(key, value)` pairs. The lambda function takes each pair (`item`) and returns the value part (`item[1]`), guiding the sorting process.

The `sorted()` function returns a list of tuples sorted by the value. If you want to convert the result back to a dictionary, you can use the `dict()` constructor:

“`python
sorted_dict = dict(sorted(d.items(), key=lambda item: item[1]))
“`

This method preserves the sorted order in Python 3.7+ where dictionaries maintain insertion order.

Sorting in Descending Order

To sort the dictionary by values in descending order, you simply pass the `reverse=True` argument to `sorted()`:

“`python
sorted_dict_desc = dict(sorted(d.items(), key=lambda item: item[1], reverse=True))
“`

Advantages of Using `sorted()` with Lambda

  • Works with any iterable.
  • Allows sorting by any criteria via the key function.
  • Supports both ascending and descending order.
  • Produces a sorted list or dictionary depending on conversion.

Sorting Dictionaries Using operator.itemgetter

An alternative to lambda expressions for sorting dictionary items by value is the `itemgetter` function from the `operator` module. It can be marginally faster and more readable in some cases, especially when the key index is fixed.

`itemgetter` creates a callable that fetches the specified item(s) from its operand. For sorting dictionary items by the value (which is at index 1 in `(key, value)` tuples), you would use:

“`python
from operator import itemgetter

sorted_items = sorted(d.items(), key=itemgetter(1))
“`

This returns a list of `(key, value)` pairs sorted by value. As with the lambda approach, converting back to a dictionary is straightforward:

“`python
sorted_dict = dict(sorted(d.items(), key=itemgetter(1)))
“`

Comparison Between Lambda and itemgetter

Aspect Lambda Expression operator.itemgetter
Readability Explicit and intuitive More concise, may be less obvious
Performance Slightly slower due to Python function call overhead Slightly faster, implemented in C
Flexibility Highly flexible, can apply complex logic Limited to simple item retrieval
Use Case When sorting by complex criteria When sorting by a fixed index

Both methods are widely accepted; choosing one depends on personal preference and specific use cases.

Sorting by Values with Multiple Criteria

Sometimes, dictionary values are themselves complex data structures like tuples or lists, and sorting by multiple criteria is desired. For example, consider a dictionary where values are `(score, age)` tuples, and you want to sort primarily by score and then by age.

Using `sorted()` with a lambda function, you can specify a tuple as the key, and Python will sort lexicographically:

“`python
d = {
‘Alice’: (90, 25),
‘Bob’: (90, 22),
‘Charlie’: (85, 30)
}

sorted_dict = dict(sorted(d.items(), key=lambda item: (item[1][0], item[1][1])))
“`

This sorts by the first element (`score`) and then by the second element (`age`) if scores are equal.

To reverse the sorting order on the primary criterion while keeping secondary ascending:

“`python
sorted_dict = dict(sorted(d.items(), key=lambda item: (-item[1][0], item[1][1])))
“`

Important Points for Multi-Criteria Sorting

  • Use tuples in the key function to specify multiple sorting criteria.
  • Negate numeric values to achieve descending order on specific criteria.
  • For strings or non-numeric types, use `reverse=True` or other transformations carefully.

Sorting Dictionaries Using Dictionary Comprehensions

After obtaining a sorted sequence of dictionary items, reconstructing the dictionary while maintaining the order can be done elegantly with dictionary comprehensions. This approach is concise and readable:

“`python
sorted_items = sorted(d.items(), key=lambda item: item[1])
sorted_dict = {k: v for k, v in sorted_items}
“`

This method is especially useful when you want to apply additional filtering or transformations during the reconstruction step.

Benefits of Dictionary Comprehensions

  • Clear syntax for rebuilding dictionaries.
  • Supports inline transformations.
  • Maintains insertion order in Python 3.7+.

Practical Example: Sorting a Dictionary of Products by Price

Consider a dictionary representing products and their prices:

“`python
products = {
‘Laptop’: 999.99,
‘Smartphone’: 499.99,
‘Tablet’: 299.99,
‘Monitor’: 199.99,
‘Keyboard’: 49.99
}
“`

Using `sorted()` with `itemgetter` to sort by price ascending:

“`python
from operator import itemgetter

sorted_products = dict(sorted(products.items(), key=itemgetter(1)))
“`

Product Price (USD)
Keyboard 49.99
Monitor 199.99
Tablet 299.99
Smartphone 499.99
Laptop 999.99

To sort descending:

“`python
sorted_products_desc = dict(sorted(products.items(), key

Sorting a Dictionary by Value Using the `sorted()` Function

In Python, dictionaries are inherently unordered prior to version 3.7, and even in later versions, they maintain insertion order rather than sorting order. To sort a dictionary by its values, the most common approach is to use the built-in sorted() function combined with a suitable key parameter.

The sorted() function returns a list of tuples, where each tuple is a key-value pair from the dictionary. You can then convert this list back into a dictionary if desired.

Basic Syntax for Sorting by Value

sorted_dict = dict(sorted(your_dict.items(), key=lambda item: item[1]))

Here:

  • your_dict.items() returns a view of the dictionary’s key-value pairs.
  • The key=lambda item: item[1] instructs sorted() to sort based on the dictionary values (the second element of each tuple).
  • Wrapping the result with dict() converts the sorted list of tuples back into a dictionary.

Example of Sorting by Value in Ascending Order

my_dict = {'apple': 10, 'banana': 2, 'orange': 5, 'pear': 7}

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

print(sorted_dict)
Output: {'banana': 2, 'orange': 5, 'pear': 7, 'apple': 10}

Sorting by Value in Descending Order

To sort the dictionary by values in descending order, use the reverse=True argument:

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

print(sorted_dict_desc)
Output: {'apple': 10, 'pear': 7, 'orange': 5, 'banana': 2}

Using `operator.itemgetter` for Improved Readability

Instead of a lambda function, you can use operator.itemgetter to specify the sorting key. This approach can be more readable and is sometimes preferred for clarity and performance.

from operator import itemgetter

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

print(sorted_dict)
Output: {'banana': 2, 'orange': 5, 'pear': 7, 'apple': 10}

The itemgetter(1) fetches the value part of the dictionary items, similar to the lambda function.

Sorting and Maintaining the Result as a List of Tuples

Sometimes, maintaining the sorted result as a list of tuples is preferable, especially when order is important and you want to avoid the overhead of converting back to a dictionary (since prior to Python 3.7, dictionaries do not maintain order).

Method Returns Order Preservation
sorted(dict.items(), key=..., reverse=...) List of tuples Yes, preserves sorted order
dict(sorted(...)) Dictionary (Python 3.7+) Yes, preserves sorted order
collections.OrderedDict(sorted(...)) OrderedDict Yes, preserves sorted order (Python versions <3.7)

Example keeping the sorted output as a list:

sorted_items = sorted(my_dict.items(), key=lambda item: item[1])

for key, value in sorted_items:
    print(f"{key}: {value}")

Using `collections.OrderedDict` to Preserve Order Explicitly

Before Python 3.7, dictionaries did not preserve insertion order. To explicitly maintain the sorted order of a dictionary by value, you can use OrderedDict from the collections module.

from collections import OrderedDict

sorted_odict = OrderedDict(sorted(my_dict.items(), key=lambda item: item[1]))

print(sorted_odict)
Output: OrderedDict([('banana', 2), ('orange', 5), ('pear', 7), ('apple', 10)])

This approach guarantees that iteration over sorted_odict yields items in the sorted order by value, regardless of Python version.

Sorting by Value When Values are Complex Types

When dictionary values are complex types such as tuples, lists, or custom objects, you can customize the sorting behavior by adjusting the key function accordingly.

  • Example: Values are tuples, sort by second element
complex_dict = {'a': (1, 3), 'b': (2, 1), 'c': (0, 2)}


sorted_dict = dict(sorted(complex_dict.items(), key=lambda item: item[1][1]))


print(sorted_dict)

Output


Expert Perspectives on Sorting Dictionaries by Value in Python


Dr. Elena Martinez (Senior Python Developer, Data Solutions Inc.). Sorting a dictionary by value in Python is best achieved using the built-in `sorted()` function combined with a lambda expression. This approach offers both clarity and efficiency, especially when working with large datasets where maintaining readability and performance is crucial.





Michael Chen (Data Scientist, AI Research Lab). When sorting dictionaries by value, I recommend leveraging the `operator.itemgetter` method instead of lambda functions for improved performance. This method is particularly advantageous in production environments where execution speed and code maintainability are essential.





Priya Singh (Software Engineer and Python Instructor, CodeCraft Academy). Understanding the difference between sorting by values and keys is fundamental. Using `dict(sorted(your_dict.items(), key=lambda item: item[1]))` not only sorts the dictionary by values but also returns a new dictionary, which aligns with Python 3.7+ maintaining insertion order, thereby preserving sorted results effectively.





Frequently Asked Questions (FAQs)


What is the most common method to sort a dictionary by value in Python?

The most common method is using the `sorted()` function with a key argument that specifies sorting by dictionary values, such as `sorted_dict = dict(sorted(my_dict.items(), key=lambda item: item[1]))`.


How can I sort a dictionary by value in descending order?

Use the `sorted()` function with the `reverse=True` parameter: `sorted_dict = dict(sorted(my_dict.items(), key=lambda item: item[1], reverse=True))`.


Can I sort a dictionary by value without converting it to a list first?

No, dictionaries themselves are unordered collections. Sorting requires converting dictionary items to a list, sorting that list, and optionally converting back to a dictionary.


How do I maintain the sorted order of a dictionary in Python 3.7 and later?

Since Python 3.7, regular dictionaries preserve insertion order. Sorting the items and creating a new dictionary from them maintains the sorted order.


Is there a way to sort a dictionary by value using the `operator` module?

Yes, you can use `operator.itemgetter(1)` as the key function: `sorted_dict = dict(sorted(my_dict.items(), key=operator.itemgetter(1)))`.


How can I sort a dictionary by value when values are complex data types?

Provide a custom key function that extracts the sortable element from the complex value, for example, `key=lambda item: item[1]['score']` to sort by the 'score' field inside value dictionaries.

Sorting a dictionary by its values in Python is a common and essential task that can be efficiently accomplished using built-in functions such as `sorted()` combined with lambda functions or the `itemgetter` from the `operator` module. By leveraging these tools, developers can easily reorder dictionary items based on their values, either in ascending or descending order, depending on the requirements of their application.


One key insight is that dictionaries themselves are inherently unordered prior to Python 3.7, but from Python 3.7 onwards, they maintain insertion order. However, to obtain a sorted representation by values, it is typical to generate a sorted list of tuples or create a new dictionary from the sorted items. This approach ensures that the data is presented in a meaningful order without altering the original dictionary structure.


Overall, mastering dictionary sorting by values enhances data manipulation capabilities and supports more effective data analysis and presentation. Understanding the nuances of sorting mechanisms in Python empowers developers to write clean, efficient, and readable code tailored to their specific data processing needs.


Author Profile
Avatar



Barbara Hernandez

Barbara Hernandez is the brain behind A Girl Among Geeks a coding blog born from stubborn bugs, midnight learning, and a refusal to quit. With zero formal training and a browser full of error messages, she taught herself everything from loops to Linux. Her mission? Make tech less intimidating, one real answer at a time. 



Barbara writes for the self-taught, the stuck, and the silently frustrated offering code clarity without the condescension. What started as her personal survival guide is now a go-to space for learners who just want to understand what the docs forgot to mention.