How to Sort a Dictionary by Value in Python

By the end of this page, you will understand how to sort a Python dictionary by its values, how ascending and descending sorting work, why sorted() is commonly used, and how to turn the result into either a list of key-value pairs or a new ordered dictionary-like result.

In Python, a dictionary stores data as key-value pairs. For example:

prices = {
    "apple": 2.5,
    "banana": 1.2,
    "orange": 3.0
}

Here:

• the keys are "apple", "banana", and "orange"
• the values are 2.5, 1.2, and 3.0

When you want to sort a dictionary by value, you are really sorting its key-value pairs using the value part as the sorting rule.

A key idea is that dictionaries themselves are not sorted by value automatically. Instead, you usually do one of these:

• get a sorted list of (key, value) tuples
• build a new dictionary from that sorted result

The most common tool for this is Python's built-in sorted() function.

Why this matters

Sorting by value is useful when:

• ranking users by score
• ordering products by price
• showing most common words by count

Think of a dictionary like a set of labeled cards:

• the label on the card is the key
• the number written on it is the value

Example:

• alice -> 82
• bob -> 95
• carol -> 78

If you sort by key, you arrange the cards by their labels: alice, bob, carol.

If you sort by value, you arrange the cards by the numbers written on them: 78, 82, 95.

So the dictionary is not being magically rearranged on its own. You are taking all the cards out, sorting them by the numeric part, and then optionally putting them back into a new dictionary in that order.

The most common pattern is:

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

Example: sort by value ascending

scores = {
    "alice": 82,
    "bob": 95,
    "carol": 78
}

sorted_scores = sorted(scores.items(), key=lambda item: item[1])
print(sorted_scores)

Output:

[("carol", 78), ("alice", 82), ("bob", 95)]

This returns a list of tuples, not a dictionary.

Example: sort by value descending

scores = {
    "alice": 82,
    "bob": 95,
    "carol": 78
}

sorted_scores = sorted(scores.items(), key=lambda item: item[1], reverse=)
(sorted_scores)

Consider this code:

scores = {
    "alice": 82,
    "bob": 95,
    "carol": 78
}

result = sorted(scores.items(), key=lambda item: item[1])
print(result)

Step 1: scores.items()

This produces the dictionary's key-value pairs:

dict_items([('alice', 82), ('bob', 95), ('carol', 78)])

Each item is a tuple:

• ('alice', 82)
• ('bob', 95)
• ('carol', 78)

Step 2: sorted(...)

sorted() takes those pairs and sorts them.

Step 3: key=lambda item: item[1]

For each tuple, Python looks at , which is the value:

Sorting a dictionary by value appears in many practical situations.

Ranking users by score

user_scores = {
    "alice": 120,
    "bob": 98,
    "carol": 150
}

ranking = sorted(user_scores.items(), key=lambda item: item[1], reverse=True)

Useful for leaderboards and game stats.

Ordering products by price

product_prices = {
    "keyboard": 49.99,
    "mouse": 19.99,
    "monitor": 199.99
}

cheapest_first = sorted(product_prices.items(), key=lambda item: item[1])

Useful in shopping apps and inventory scripts.

Sorting word frequencies

word_counts = {
    "python": 15,
    "code": 8,
    "data": 22
}

most_common = sorted(word_counts.items(), key=lambda item: item[1], reverse=)

In real projects, developers often sort dictionary data after aggregation or validation.

Pattern: sort computed results

A common flow is:

1. read data from a database or API
2. build a dictionary of totals, counts, or scores
3. sort by value for display or reporting

totals = {
    "apples": 12,
    "bananas": 7,
    "oranges": 19
}

sorted_totals = sorted(totals.items(), key=lambda item: item[1], reverse=True)

Pattern: top N results

Often you do not need everything, only the highest or lowest values.

top_two = sorted(totals.items(), key=lambda item: item[1], reverse=True)[:2]

Pattern: guard clause before sorting

If data may be empty, developers often check first.

if not totals:
    print("No data available")
else:
    print(sorted(totals.items(), key= item: item[]))

Mistake 1: sorting the dictionary directly

Broken code:

scores = {"alice": 82, "bob": 95, "carol": 78}
print(sorted(scores))

This sorts the keys, not the values.

Output:

['alice', 'bob', 'carol']

Use this instead:

print(sorted(scores.items(), key=lambda item: item[1]))

Mistake 2: forgetting .items() when you need key-value pairs

Broken code:

scores = {"alice": 82, "bob": 95, "carol": 78}
print(sorted(scores, key=lambda item: item[1]))

Here, is each key string like , so means the second character of the string, not the dictionary value.

# Sort dictionary by value ascending
sorted(d.items(), key=lambda item: item[1])

# Sort dictionary by value descending
sorted(d.items(), key=lambda item: item[1], reverse=True)

# Convert sorted result back to dictionary
dict(sorted(d.items(), key=lambda item: item[1]))

# Get only keys sorted by value
sorted(d, key=d.get)

# Get only keys sorted by value descending
sorted(d, key=d.get, reverse=True)

Quick rules

• d.items() gives (key, value) pairs
• item[0] is the key
• item[1] is the value
• sorted() returns a new list
• reverse=True gives descending order
• dict(...) can rebuild a dictionary from sorted pairs

Common patterns

How do I sort a Python dictionary by value?

Use:

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

This sorts the key-value pairs by the value.

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

Add reverse=True:

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

Does sorted() change the original dictionary?

No. sorted() returns a new result and leaves the original dictionary unchanged.

Why does sorted(my_dict) sort keys instead of values?

Because iterating over a dictionary directly gives its keys. To sort by values, use .items() or key=my_dict.get.

How can I get only the keys sorted by value?

Use:

sorted(my_dict, key=my_dict.get)

Can I turn the sorted result back into a dictionary?

• Python dictionaries — You need to understand how key-value pairs work before sorting them.
• sorted() function — This is the main tool used to sort iterable data in Python.
• Lambda functions — Commonly used to define the sorting rule inline.
• operator.itemgetter — A cleaner alternative to a lambda for selecting tuple elements.
• Tuples — dict.items() returns key-value pairs as tuples.
• List slicing — Useful for taking top results after sorting, such as the top 5 values.
• Dictionary methods — Methods like .items() and .get() are central to this pattern.
• Sorting lists in Python — Helpful because sorted dictionary items are often handled as lists of tuples.