How to sort a dict by value.
sorted() + a key function.

Why item[1] for value:

d.items() yields tuples:
  ('Alice', 85)
  ('Bob', 72)
  ('Charlie', 95)

Index 0 is the key.
Index 1 is the value.

sorted(..., key=lambda item: item[1])
  → sorts by index 1 of each tuple
  → value-based sort

sorted(..., key=lambda item: item[0])
  → sorts by index 0
  → key-based sort

sorted(d.items())
  → default: compares tuples element by element
  → by key first, then by value for equal keys
  → equivalent to sort by key, then value

reverse=True
  → sorts descending
  → applies to whatever the key returns
  → works for strings, numbers, tuples

For dicts with mixed types:
  sorted(d.items(), key=lambda x: str(x[0]))
  → converts key to string for comparison
  → rarely needed; usually dict keys are uniform

For case-insensitive key sort:
  sorted(d.items(), key=lambda x: x[0].lower())
  → sort by lowercase key
  → useful for dictionaries with user names

For descending by value, ascending by key:
  Can't do this with a single reverse.
  Use a custom key:
  sorted(d.items(), key=lambda x: (-x[1], x[0]))
  → negative value for descending
  → key for ascending tiebreaker

  Only works for numeric values (can't negate strings).

For general mixed sorting:
  use two passes with sort stability:
  items = sorted(d.items(), key=lambda x: x[0])       # key asc
  items = sorted(items, key=lambda x: x[1], reverse=True)  # value desc
  Stable sort preserves the first order for ties.

The reason sorted() returns a list:

sorted() works on any iterable.
For a dict, the natural iteration is over keys.
For d.items(), it's over tuples.
sorted() returns whatever type it produced —
and that's always a list.

The chain:

  dict → iterable (via .items()) → sorted list
       → optionally back to dict

  Or:

  dict → list of (k, v) tuples → sorted list
       → optionally dict(...) to convert

The conversion step matters:

✅ sorted(d.items(), key=...) — a list of tuples
   You can:
   - Iterate it
   - Slice it (top 5: sorted(...)[:5])
   - Convert to dict: dict(sorted(...))
   - Filter it with a comprehension
   - Pass it to another function

✅ dict(sorted(...)) — a dict
   You can:
   - Look up by key (O(1))
   - Iterate in insertion order (which is sorted)
   - Convert back to a list

The list is more useful for intermediate steps.
The dict is more useful for lookups.

Real-world sorting patterns:

1. Top-N by value:
   top_5 = sorted(d.items(), key=lambda x: x[1], reverse=True)[:5]
   → Keep it as a list. No need to convert back.

2. Full sorted dict:
   d = dict(sorted(d.items(), key=lambda x: x[1]))
   → The dict preserves the order.

3. Convert to string for display:
   for name, score in sorted(d.items(), key=lambda x: -x[1]):
       print(f'{name}: {score}')
   → Iterate the sorted list directly.

4. Sort and keep the rest:
   first, *rest = sorted(d.items(), key=lambda x: x[1])
   → Tuple unpacking on the sorted list.

The common mistake:

❌ d.sort(key=...)  # AttributeError
   Dicts don't have .sort().

❌ sorted(d, key=lambda x: x[1])  # IndexError
   sorted(d) yields keys (strings), not tuples.
   x[1] on a string is indexing.

✅ sorted(d.items(), key=lambda x: x[1])
   Sort the (key, value) tuples.

✅ sorted(d.items())
   Default sort by key, then value.

Pattern 1: Top N
  sorted(items, key=...)[:N]
  → slice the sorted list
  → no need to convert to dict
  → O(n log n) for the sort, then O(N) for the slice
  → for very large N, use heapq.nlargest (O(n log N))

Pattern 2: Iterate in order
  for k, v in sorted(items, key=...):
      ...
  → most common
  → the list is temporary
  → no dict conversion needed

Pattern 3: Two-level sort
  key=lambda x: (-x[1], x[0])
  → descending by value, ascending by key
  → works for numeric values (negation)
  → for strings or mixed, use two-pass stable sort

Pattern 4: Sort by custom property
  key=lambda x: len(x[0])  # key length
  key=lambda x: x[1].score  # if value is an object
  → any function works as a key
  → return anything sortable

Pattern 5: Category sort
  key=lambda x: category(x[1])
  → group by category
  → stable sort preserves order within category
  → sort by category, then by value for ties:
    key=lambda x: (category(x[1]), x[1])

Pattern 6: Filter then sort
  sorted((x for x in items if cond(x)), key=...)
  → filter first (fewer items to sort)
  → sort the filtered list
  → or sort then filter, but filter-first is faster
  → the generator expression avoids a temporary list

Pattern 7: Keys only
  sorted(d)  # sorted keys
  → works because iterating a dict yields keys
  → useful when you only need order, not values

The stable sort guarantee:

  Python's sort is stable.
  Equal elements preserve their relative order.
  This is why two-pass sorting works:
    sorted(d, key=lambda x: x[1])       # by value
    sorted(d, key=lambda x: x[0])       # then by key
  → first pass by value, second pass by key
  → result: sorted by key, ties broken by value
  → equivalently: sorted(d, key=lambda x: (x[0], x[1]))

The tuple key is the idiomatic way to do
multi-level sorting. The two-pass is equivalent
but more verbose. Use the tuple key.

For simple sorts, use a lambda.
For complex sorts, use a named function.
For performance-critical sorts, use itemgetter.

The pattern you'll write most often:

  dict(sorted(d.items(), key=lambda x: x[1], reverse=True))
  
  → sort by value descending
  → convert back to dict
  → the dict preserves the sorted order
  → iterate as many times as you want