PyPython example

How to sort a dictionary by value in Python

◷ 5 min read▶ Runs in an isolated hosted runtimeUpdated Jul 2026

Quick answer

Sort the items, then rebuild the dict: dict(sorted(d.items(), key=lambda kv: kv[1])). Since Python 3.7 dicts keep insertion order, so the result really is a dictionary in value order.

There is no dict.sort() — sorted() works on any iterable and always returns a list, so the trick is to sort d.items() (a sequence of (key, value) pairs) with a key= function that picks the value, then feed that list back to dict(). Every example below runs on this page — hit Run, then edit and run it again.

1sorted() on .items() with a lambdaRecommended

d.items() yields (key, value) tuples, so key=lambda kv: kv[1] tells sorted() to compare on the value and ignore the key. Wrapping the result in dict() gives you a real dict back — insertion-ordered since 3.7, so the ordering sticks.

sort_by_value.py

scores = {"python": 92, "go": 78, "rust": 85, "java": 64}

ranked = dict(sorted(scores.items(), key=lambda kv: kv[1]))
print(ranked)
print(list(ranked))

Output

Prints {'java': 64, 'go': 78, 'rust': 85, 'python': 92} then ['java', 'go', 'rust', 'python']. If you only need the keys in value order, skip the rebuild entirely: sorted(scores, key=scores.get) returns that same list.

2operator.itemgetter(1)

itemgetter(1) does exactly what the lambda does, but it's a C-level callable rather than a Python function call per element, so it's measurably faster on large dicts — and many people find it reads cleaner once you know it.

itemgetter.py

from operator import itemgetter

scores = {"python": 92, "go": 78, "rust": 85, "java": 64}

ranked = dict(sorted(scores.items(), key=itemgetter(1)))
print(ranked)

Output

Same output as the lambda version. The cost is one import — worth it in hot loops or on big dicts, noise anywhere else.

3Descending order and tie-breaks

reverse=True flips the order. But Python's sort is stable, and reversing does not reverse tied elements — equal values keep their original insertion order, which is rarely what you want in a leaderboard. Sort on a tuple key instead: negate the value to sort it descending, then add the key as an explicit tie-breaker.

descending.py

scores = {"python": 92, "go": 78, "rust": 85, "java": 64}
print(dict(sorted(scores.items(), key=lambda kv: kv[1], reverse=True)))

votes = {"ana": 3, "raj": 5, "bea": 3, "kim": 5}
# reverse=True is stable, so tied keys keep their insertion order.
print(dict(sorted(votes.items(), key=lambda kv: kv[1], reverse=True)))
# A tuple key breaks the tie on purpose: value descending, then key A-Z.
print(dict(sorted(votes.items(), key=lambda kv: (-kv[1], kv[0]))))

Output

The tied dicts print as {'raj': 5, 'kim': 5, 'ana': 3, 'bea': 3} and {'kim': 5, 'raj': 5, 'ana': 3, 'bea': 3} — same values, different order. -kv[1] only works for numbers; for strings or dates, sort twice (by the tie-breaker first, then by the value with reverse=True) and let stability do the work.

4Counter.most_common() when the values are counts

If the dict is a frequency table, collections.Counter already sorts for you. most_common() returns the pairs highest-first, and most_common(n) takes just the top n using a heap — cheaper than sorting everything when n is small.

counter.py

from collections import Counter

words = "code run code ship run code".split()
counts = Counter(words)

print(counts.most_common())
print(counts.most_common(2))
print(dict(counts.most_common()))

Output

most_common() hands back a list of tuples, not a dict — wrap it in dict() if you need dict access, as the third line does. Counts that tie are returned in first-encountered order.

5Which should you use?

Method	Returns	Speed	Best for
dict(sorted(d.items(), key=lambda kv: kv[1]))	dict	Fast	Almost everything
key=itemgetter(1)	dict	Fastest	Big dicts, hot loops
key=lambda kv: (-kv[1], kv[0])	dict	Fast	Ties broken predictably
sorted(d, key=d.get)	list of keys	Fast	When you only need keys
Counter(...).most_common(n)	list of tuples	Fastest for top-N	Frequency tables

6Common variation: sort a dict of dicts by an inner field

The key= function receives the whole (key, value) pair, so it can reach as deep as you like — kv[1]["rating"] sorts records by a nested field. Slice the sorted list before rebuilding to get just the top N.

sort_nested.py

books = {
    "dune": {"year": 1965, "rating": 4.6},
    "neuromancer": {"year": 1984, "rating": 4.1},
    "snow-crash": {"year": 1992, "rating": 4.3},
}

by_rating = dict(sorted(books.items(), key=lambda kv: kv[1]["rating"], reverse=True))
for slug, meta in by_rating.items():
    print(slug, meta["rating"])

top_2 = [slug for slug, _ in sorted(books.items(), key=lambda kv: kv[1]["rating"], reverse=True)[:2]]
print(top_2)

Output

Prints the three books highest-rated first, then ['dune', 'snow-crash']. Change the field name to sort by anything else — lambda kv: kv[1]["year"] — and note that itemgetter can't reach into the nested dict here, so the lambda stays.

Frequently asked questions

Can you sort a dictionary in place in Python?

No — there is no dict.sort(). sorted() always returns a new list, so you sort d.items() and rebuild with dict(...). Since Python 3.7 dicts preserve insertion order, so the rebuilt dict genuinely stays in sorted order.

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

Add reverse=True: dict(sorted(d.items(), key=lambda kv: kv[1], reverse=True)). For numeric values you can also negate the value in the key — key=lambda kv: -kv[1] — which leaves room for a tie-breaker in a tuple key.

What happens when two values are equal?

Python’s sort is stable, so tied entries keep their original insertion order — and reverse=True does not reverse ties either. To control it, sort on a tuple: key=lambda kv: (-kv[1], kv[0]) orders by value descending, then by key alphabetically.

Is itemgetter faster than a lambda?

Yes. operator.itemgetter(1) is implemented in C and avoids a Python-level call per element, so it wins on large dicts. For small dicts the difference is irrelevant, so pick whichever reads better.