Sort Python Data with key and reverse

Select a timestamp to watch that moment on YouTube.

1. 00:00

   We want an alphabetic list of names. Most people looking at Zoe, ada, and Bo would expect ada, Bo, Zoe. Python can sort the strings, but its default comparison does not treat uppercase and lowercase letters as the same letter. That difference is easy to miss when a short test list happens to contain names with the same capitalization. In this video we will run the default sort, inspect the surprise, and tell Python which comparison value to use. We will also distinguish sorted from list.sort, handle duplicate comparison values, and test that the original list stays in place when we want a new result.

2. 00:40

   The companion lesson gives you a browser console and a checked exercise. Before running each version, predict what it should print. A correct sort depends on the rule we choose. Alphabetical by name, shortest name first, and highest score first are three different rules for the same input. We should make the chosen rule visible in code and in tests. Keep the original spelling in the result even if we compare a normalized form. The output is a valid default string sort, but it is not the human-facing order we wanted. Python compares the strings according to their characters, and uppercase B and Z sort before lowercase a here.

3. 01:21

   Notice a second fact: sorted returned a new list. The original names list still has the same order. That matters when another part of a program uses the input order later. If our task is to display a sorted view, changing the source list would be an unnecessary side effect. The wrong output is useful evidence. It tells us the algorithm sorted something consistently, but the comparison rule was wrong for the product requirement. A tempting patch is to lowercase every name in the input list before sorting. That would lose the capitalization we want to display. We only need a lowercase-like comparison value, not a rewritten name.

4. 02:03

   This is exactly what the key parameter provides. It calls a function once for each item to get the value used for comparison. The resulting list still contains the original items, with their original spelling. Keep that distinction in mind before the fix. Each original name has a comparison key. Zoe becomes zoe, Bo becomes bo, and the two spellings of Ada both become ada. For text that people enter, casefold is a strong default for case-insensitive comparison. It is designed for Unicode case folding and can be more thorough than lower. Here the simple examples look like lowercase text.

5. 02:43

   The keys make the intended comparison rule observable, so we can check it before putting it inside sorted. We have not edited any of the original strings. Also notice what the key cannot decide: ada and ADA have the same key. Python's sorting is stable, which means equal-key items keep their previous relative order. That is useful if our input order has meaning. If we need an explicit second rule, such as sorting equal names by an ID, the key can return a tuple of comparison values. We will keep the stable input order in this first solution. Predict whether lowercase ada or uppercase ADA will appear first after sorting: lowercase ada appeared first in the source, so it stays first among equal keys.

6. 03:30

   First, the names now appear in a human-facing case-insensitive order. The two Ada spellings keep their original relative order because their comparison keys are equal. We kept the original spelling, which was the goal of the opening example. The same key idea now solves the lesson's practical task. Each item is a product dictionary, and the lambda extracts its numeric price for comparison. Pen costs two, Folder five, and Notebook eight, so the printed order matches our price rule. The returned list contains the original records with all their fields. `sorted` gives us a new list; the input order remains Notebook, Pen, Folder.

7. 04:11

   This matters when another part of a program uses the original order. We also accept a `descending` option and pass it to reverse. The default is False, so callers get ascending price unless they explicitly ask for the opposite. Without a key, dictionaries do not have a natural less-than ordering and a nontrivial `sorted(products)` call raises TypeError. Sorting by each product's name would run but answer a different question. A key is a compact expression of the requirement, not merely a syntactic trick. For a larger record, give the key function a descriptive name and test its returned value.

8. 04:51

   Check that prices have comparable numeric types before sorting data imported from outside the lesson. The exercise uses valid numeric prices, allowing us to focus on ordering and input mutation. Pen and Pencil have the same price. They keep their input order in both ascending and descending results, because Python's sort is stable for equal keys. Notebook moves to the front only in descending order. The input products list stays unchanged, and an empty input returns an empty list. These checks distinguish the task function from plausible wrong versions: sorting by name, changing the caller's list, or adding an unwanted name tie-breaker.

9. 05:34

   The last line demonstrates a different API: list.sort changes its list in place and returns None. Assigning its return value is a common error. Choose sorted when you want a new list, and list.sort when you intentionally want to reorder an existing one. Both accept key and reverse. On PythonLessonLab, compare the starter's printed product names with the expected price order, then implement the key and complete the quiz. As an extension, try two products with equal prices and predict which remains first. The useful skill is to separate what you display from what you compare. The key function encodes a real requirement: which property controls order.