sorted(), list.sort(), and key Functions

## Two entry points, one sorting algorithm Python exposes its sort twice. `sorted(iterable, /, *, key=None, reverse=False)` is a builtin function that consumes **any iterable** and returns a brand-new `list`. `list.sort(*, key=None, reverse=False)` is a method that exists only on `list` objects; it rearranges the elements of that list **in place** and returns `None`. Underneath, they are the same machinery: `sorted()` is essentially "copy the iterable into a list, then call that list's `sort`". So neither is faster in comparison count, neither is more stable, and any behaviour you learn about one applies to the other. ## Why `list.sort()` returns None This surprises newcomers, and interviewers ask about it because the answer reveals whether a candidate understands a language-wide convention: **in-place mutators in Python return `None`**. `list.append`, `list.extend`, `list.reverse`, `dict.update`, `set.add` and `random.shuffle` all do it. The convention is deliberate — it stops you writing `data.sort().pop()`, a chain that reads like it produced a new value when it actually mutated the object you already had. The cost is the single most common sorting bug in Python: ```python ranked = scores.sort() # ranked is None; scores was mutated for s in scores.sort(): # TypeError: 'NoneType' object is not iterable ``` When you want a sorted copy, `sorted(scores)` is the answer, not `scores.sort()`. ## What each one accepts and returns `sorted()` accepts anything iterable and always returns a `list`, regardless of the input type: ```python sorted({3, 1, 2}) # [1, 2, 3] from a set sorted({"b": 1, "a": 2}) # ['a', 'b'] iterates the keys sorted("banana") # ['a','a','a','b','n','n'] a list, not a str sorted(x * x for x in r) # consumes a generator ``` That last row is a frequent gotcha: sorting a string gives you a list of characters, so you need `"".join(sorted(text))` to get a string back. `list.sort()` has no such flexibility — a set or a generator has no `.sort()` method, so you must materialize a list first, at which point you may as well have called `sorted()`. ## Memory and mutation The practical difference is one extra list of `n` pointers. On a list of ten million items in a memory-tight process, `data.sort()` reorders the existing array while `sorted(data)` transiently holds both the old and the new list. When you are the owner of the data and nobody else holds a reference to it, in-place sorting is the cheaper call. Mutation is the flip side. If a function receives a list from a caller and sorts it in place, it has silently changed the caller's object — a real source of bugs in shared-state code. A library function that must not surprise its caller should return `sorted(items)` rather than mutate the argument, or document loudly that it reorders in place. ## Shared behaviour worth naming Both take `key` and `reverse` as **keyword-only** arguments, so `sorted(words, len)` is a `TypeError` — it must be `sorted(words, key=len)`. Both are **stable**: elements that compare equal keep their relative input order. And in CPython both refuse to be re-entered — while a sort is running the list is temporarily made to look empty, so a `key` function that peeks at the list being sorted sees `[]`, and mutating that list mid-sort raises `ValueError: list modified during sort`. That safeguard exists precisely because in-place sorting hands the algorithm an object user code can still reach. Finally, do not confuse `sorted(data, reverse=True)` with `reversed(data)`. The first sorts and then presents the order from largest to smallest; the second does no sorting at all, it just walks the existing sequence backwards and returns a lazy iterator. ## Choosing in review Use `list.sort()` when you own a list, the copy would be wasteful, and the statement stands alone. Use `sorted()` when the source is not a list, when the original order still matters to somebody, or when you need the result as an expression — inside a comprehension, a `return`, or an f-string. Reaching for `sorted()` by default and switching to in-place sorting when profiling says the copy hurts is a defensible habit.