Sorting — Python's sorted() with key

By the end of this lesson you can:

• Pick between sorted() (returns new list) and list.sort() (in-place).
• Use the key= parameter with a lambda or a named function.
• Sort by multiple criteria with a tuple key — ascending and descending mixed.
• Recognise Timsort's name and why Python uses it.

nums = [3, 1, 4, 1, 5, 9, 2, 6]

# sorted() — returns a NEW list. Original untouched.
result = sorted(nums)
print(result)     # [1, 1, 2, 3, 4, 5, 6, 9]
print(nums)       # [3, 1, 4, 1, 5, 9, 2, 6]  — unchanged

# list.sort() — sorts IN PLACE. Original mutated.
nums.sort()
print(nums)       # [1, 1, 2, 3, 4, 5, 6, 9]  — now sorted
# (sort returns None, so don't write x = nums.sort())

sorted for "give me a new sorted version". .sort for "sort this list in place".

Basic sort

# Plain ascending
print(sorted([5, 2, 8, 1]))           # [1, 2, 5, 8]
print(sorted(["banana", "apple", "cherry"]))   # alphabetical

# Descending
print(sorted([5, 2, 8, 1], reverse=True))      # [8, 5, 2, 1]

Sort by attribute or field — key=

students = [
    {"name": "Aisyah", "score": 92},
    {"name": "Wei Jie", "score": 87},
    {"name": "Priya", "score": 95},
]

# By score ascending
sorted(students, key=lambda s: s["score"])

# By score descending
sorted(students, key=lambda s: s["score"], reverse=True)

# By name alphabetically
sorted(students, key=lambda s: s["name"])

You met this pattern back in PY-L2-04 and again in PY-L3-20. Today we put it on a pedestal: every Python sort uses key=.

Multi-key sort with tuples

# Sort by score desc, then by name asc as tie-breaker
sorted(students, key=lambda s: (-s["score"], s["name"]))

Tuples compare element-by-element. (-score, name) sorts first by negated score (so higher = lower number = first), then by name. Mixed direction in one tuple — use the negation trick.

What if you can't negate?

For strings or other non-numeric keys, do two sorts — first the secondary, then the primary. Python's sort is stable, so equal-primary items keep the secondary's order.

# Sort by department asc, then name desc within department
sorted_by_name_desc = sorted(staff, key=lambda s: s["name"], reverse=True)
result = sorted(sorted_by_name_desc, key=lambda s: s["department"])

Two passes; Timsort is fast enough that this is fine.

The operator.itemgetter / attrgetter shortcut

For simple key functions, operator module is slightly faster than a lambda:

from operator import itemgetter, attrgetter

# Same as key=lambda s: s["score"]
sorted(students, key=itemgetter("score"))

# Same as key=lambda h: h.hp
sorted(heroes, key=attrgetter("hp"))

# Multi-key
sorted(students, key=itemgetter("score", "name"))    # tuple key

Reads slightly cleaner, runs slightly faster. Common in code-review style guides.

Sort strings as numbers

prices = ["12.50", "3.00", "100.25", "7.99"]
sorted(prices)                                # ['100.25', '12.50', '3.00', '7.99']  -- LEX!
sorted(prices, key=float)                     # ['3.00', '7.99', '12.50', '100.25']

Strings compare lexicographically by default. key=float converts each to a number for comparison.

Why Timsort?

Timsort:

• Finds existing "runs" (already-sorted sub-sequences) in the data.
• For each run, uses insertion sort (the "small-list winner" from PY-L3-40).
• Merges runs using mergesort.
• Worst case O(n log n). Best case (already sorted) O(n).
• Stable.

Designed for real-world data — which is usually somewhat sorted. Python adopted it in 2002; Java did in 2009. It's arguably the most-used sorting algorithm in the world.

Save as sort_showcase.py:

# sort_showcase.py — every common sort use case

from operator import itemgetter

people = [
    {"name": "Aisyah",  "age": 13, "score": 92},
    {"name": "Wei Jie", "age": 12, "score": 87},
    {"name": "Priya",   "age": 13, "score": 95},
    {"name": "Iman",    "age": 12, "score": 92},   # ties with Aisyah on score
    {"name": "Aizat",   "age": 12, "score": 78},
]


# 1 — plain alpha by name
for p in sorted(people, key=itemgetter("name")):
    print(f"  {p['name']:<10} age {p['age']}  score {p['score']}")

print()

# 2 — score descending
for p in sorted(people, key=itemgetter("score"), reverse=True):
    print(f"  {p['score']}  {p['name']}")

print()

# 3 — multi-key: score desc, then name asc as tiebreaker
for p in sorted(people, key=lambda p: (-p["score"], p["name"])):
    print(f"  {p['score']}  {p['name']}")

print()

# 4 — group by age, sort each group by score
groups = {}
for p in people:
    groups.setdefault(p["age"], []).append(p)
for age in sorted(groups):
    print(f"Age {age}:")
    for p in sorted(groups[age], key=lambda p: -p["score"]):
        print(f"    {p['name']:<10} {p['score']}")

Output (showcasing each shape)

# By name
  Aisyah     age 13  score 92
  Aizat      age 12  score 78
  Iman       age 12  score 92
  Priya      age 13  score 95
  Wei Jie    age 12  score 87

# By score desc
  95  Priya
  92  Aisyah
  92  Iman
  87  Wei Jie
  78  Aizat

# Multi-key
  95  Priya
  92  Aisyah       # comes before Iman because name alphabetises first
  92  Iman
  87  Wei Jie
  78  Aizat

# Grouped by age
Age 12:
    Iman       92
    Wei Jie    87
    Aizat      78
Age 13:
    Priya      95
    Aisyah     92

Read the diff

Four sorts, four different criteria. The multi-key version handles the tie between Aisyah and Iman by falling through to name. The grouped version uses the group-by recipe from PY-L2-12 plus a per-group sort. All built on the same sorted + key=.

sorted(lst, key=, reverse=) for new sorted list; lst.sort() for in-place. The key argument extracts what to compare. Tuple keys + negation trick = multi-key sort with mixed directions. operator.itemgetter/attrgetter are slightly faster than lambdas for simple keys. Python uses Timsort — adaptive, stable, O(n log n). You will not beat it. Don't try.