Tuple Ordering and Lexicographic Comparison
Sorting dictionaries by value requires reconstructing tuples from (key, value) to (value, key) because Python's tuple sort compares the first element first.
The Field Python Sees First
Suppose a dictionary contains pairs such as alpha mapped to 30, beta mapped to 10, and gamma mapped to 20. If those entries remain in their usual key-value form, each pair begins with a key. Sorting those tuples therefore uses the key as the first sorting field. To sort by the values instead, reconstruct each pair so that the value comes first: 30 paired with alpha, 10 paired with beta, and 20 paired with gamma.
Tuple position controls sorting priority. Put the field you want to sort by first.
Comparing Tuples Left to Right
Tuple ordering is lexicographic: Python compares the first element of one tuple with the first element of the other tuple. If those first elements differ, that comparison determines the order. If they match, comparison proceeds to the next element. This makes the first tuple position the primary sorting field and the second position a later comparison field.
Reading Two Tuples
Determine which tuple comes first when comparing (10, beta) and (20, gamma).
Compare position one: The first elements are 10 and 20.
Stop when they differ: Because the first elements are different, their order determines the tuple order.
Use the second position only when needed: The names beta and gamma do not need to decide this comparison because the first elements already differ.
(10, beta) comes before (20, gamma).
Swapping the Tuple Positions
A dictionary entry naturally appears as a key-value pair. To prepare for value-based sorting, reconstruct that pair in the opposite order. The key remains present, but it moves to the second position. The value moves to the first position, where tuple ordering examines it first.
For the generated example, the reconstructed list is [(30, alpha), (10, beta), (20, gamma)]. A simple sorted operation then compares 30, 10, and 20 first, producing [(10, beta), (20, gamma), (30, alpha)]. The keys are carried along as the second tuple elements, so the association between each value and its key is preserved.
Predicting the Final Order
What do you think happens?
The reconstructed tuples are (40, cedar), (15, birch), and (25, maple). Which tuple comes first when they are ordered?
Reveal answer
Answer: (15, birch)
The first elements are 40, 15, and 25. Since 15 is the smallest first element, (15, birch) comes first. The second elements are not needed for this comparison.
When first elements are different, sort order is determined entirely by those first elements. If two reconstructed tuples have the same value in the first position, tuple comparison continues to the second position, which contains the key. Thus the value is the primary sorting field, while the key can determine the order among tuples whose first elements match.
Using the Second Element After a Tie
Determine the order of (20, zeta) and (20, alpha).
Compare the first elements: Both tuples begin with 20, so the first position does not determine the order.
Compare the second elements: The second elements are zeta and alpha. Tuple comparison proceeds to this position because the first elements match.
Place the smaller second element first: alpha comes before zeta in the second position.
(20, alpha) comes before (20, zeta).
Mistakes with Original Pairs
Passing the original key-value pairs directly to sorted() when the goal is value-based ordering.
The key occupies the first tuple position, so lexicographic comparison uses the key as the primary sorting field.
Fix:
Reconstruct every pair as (value, key) before applying sorted().Assuming that calling .items() alone changes the sorting field.
The tuple still begins with the key, so the first comparison remains key-based.
Fix:
Use the entries as input for a transformation that places the value first.Swapping the positions but then reading the result as though it were still a key-value pair.
The reconstructed tuple intentionally has value first and key second.
Fix:
Keep track of the tuple shape: reconstructed pairs are (value, key), and the second element is the original key.
| Tuple form | First comparison field | Sorting result |
|---|---|---|
| (key, value) | Key | Key-based ordering |
| (value, key) | Value | Value-based ordering |
Practice the Transformation
A dictionary has the entries oak mapped to 12, pine mapped to 5, and birch mapped to 9. Write the reconstructed tuples in value-key form, then state the order produced by sorting those tuples.
Hints
- Move each value into the first position.
- Compare the first elements before comparing any keys.
- The values to order are 12, 5, and 9.
Practice Solution
Order the entries oak mapped to 12, pine mapped to 5, and birch mapped to 9 by value.
Reconstruct the pairs: The value-key tuples are (12, oak), (5, pine), and (9, birch).
Compare the first elements: The first elements are 12, 5, and 9. Their ascending order is 5, 9, and 12.
Carry each key with its value: Each key remains attached as the second element of its tuple.
The sorted order is (5, pine), (9, birch), (12, oak).
The Sorting Pattern
- Tuple comparison examines the first element before later elements.
- Dictionary entries normally have the shape (key, value), so their first sorting field is the key.
- Reconstructing entries as (value, key) places the desired sorting field first.
- After reconstruction, a simple sorted() call produces a value-ordered list while preserving each key with its value.
- If first elements match, lexicographic comparison continues to the second element.
Key Takeaways
- Python orders tuples lexicographically, examining the first element first.
- Sorting original key-value pairs produces key-based ordering because the key is first.
- Reconstructing each entry as a value-key tuple makes the value the primary sorting field.
- The key remains available as the second element and can resolve comparisons when values match.