Sorting with key functions, and the collections module

sorted(iterable) returns a new list and works on anything iterable. some_list.sort() sorts that list in place and returns None — so names = names.sort() replaces your list with None.

Key functions

Both take key=, a function called once per element; the elements are then ordered by what it returns. reverse=True flips the result.

sorted(words, key=len)              # shortest first
sorted(words, key=str.lower)        # case-insensitive
sorted(rows, key=lambda r: r["age"])

To sort by several things, return a tuple: tuples compare element by element, so key=lambda p: (p.dept, p.name) sorts by department and then by name within it. For mixed directions on numbers, negate one part: key=lambda p: (-p.score, p.name) is "score high to low, then name A to Z".

Python's sort is stable: elements with equal keys keep the order they arrived in. That gives a second way to sort by several keys, which also works when a part cannot be negated (a string you want descending): sort by the least important key first, then by the more important one.

1def run():2    names = ["mia", "Bo", "al"]3    returned = names.sort()4 5    people = [("Nia", 30), ("Al", 25), ("Bo", 30), ("Cy", 25)]6    by_age = sorted(people, key=lambda p: p[1])7    age_desc_name_asc = sorted(people, key=lambda p: (-p[1], p[0]))8    both_reversed = sorted(people, key=lambda p: (p[1], p[0]), reverse=True)9 10    # name descending, then age ascending: two stable passes11    two_pass = sorted(people, key=lambda p: p[0], reverse=True)12    two_pass = sorted(two_pass, key=lambda p: p[1])13    return {14        "sort_returned": returned,15        "names_now": names,16        "by_age_stable": by_age,17        "age_desc_name_asc": age_desc_name_asc,18        "both_reversed": both_reversed,19        "two_pass": two_pass,20    }

The collections module

• Counter(iterable) counts hashable items. most_common(n) returns the n largest counts, and ties come out in the order the items were first seen — not alphabetically. Counters also add and subtract.
• defaultdict(factory) calls factory() to create a missing key's value on first access, which makes grouping a one-liner: groups[key].append(item). Even a plain read of a missing key creates it.
• deque is a double-ended queue: append/appendleft and pop/popleft are O(1) at both ends, where list.pop(0) is O(n). With maxlen, appending to a full deque drops an item from the other end — a ready-made "last N" buffer.
• namedtuple("Point", "x y") is a tuple whose fields also have names.

1from collections import Counter, defaultdict, deque2 3 4def run():5    votes = ["tea", "coffee", "water", "coffee", "tea", "juice"]6    counts = Counter(votes)7 8    groups = defaultdict(list)9    for word in ["apple", "avocado", "banana", "blueberry", "cherry"]:10        groups[word[0]].append(word)11    _ = groups["z"]  # only reading it12 13    window = deque(maxlen=3)14    for reading in [5, 7, 9, 11, 13]:15        window.append(reading)16 17    return {18        "most_common_2": counts.most_common(2),19        "minus": dict(counts - Counter(["tea", "tea"])),20        "groups": dict(groups),21        "last_three": list(window),22    }

Common mistakes

• result = items.sort(): result is None, and items is now sorted in place.
• Sorting descending with reverse=True and a tuple key, when only the first part should be descending. The tie-breaker flips too.
• Using Counter.most_common() for "highest count, ties alphabetically". Its ties follow first appearance.
• Reading a missing key of a defaultdict "just to check". The check itself inserts the key.

What interviewers ask

• sorted() or list.sort()? New list from any iterable against in place on a list, returning None; both stable, both take key and reverse.
• What does "stable sort" mean, and why is it useful? Equal keys keep their input order, so sorting in passes by secondary then primary key gives a correct multi-key sort.
• How would you implement a sliding window or a queue? deque, with maxlen for a fixed window; never list.pop(0) in a loop.