{"title":"sorted & reversed","description":"","content":"Sorting and reversing show up everywhere in an online store: products by price, customers by name, orders by date, recent activity at the top of a feed. Python ships two built-ins for this, `sorted()` and `reversed()`, and both work on more than just lists. This lesson covers what each one does, how to control the order with `key` and `reverse`, why Python's sort is stable and why that matters, and the small but real difference between `reversed(seq)` and slicing with `[::-1]`.\n\n---\n\n# sorted Works on Any Iterable\n\nThe `sorted()` built-in takes any iterable and returns a brand new list with the items in order. The original is untouched.\n\n\n```python\nprices = (29.99, 14.99, 9.99, 49.99, 19.99)\nordered = sorted(prices)\n\nprint(ordered)\nprint(prices)\n```\n\n\nThe input was a tuple, the output is a list. That holds for any iterable: sets, dict keys, generators, file objects, ranges. If you can loop over it, you can sort it.\n\n\n```python\nratings = {4.5, 3.2, 5.0, 2.8, 4.9, 3.7}\nprint(sorted(ratings))\n\nproduct_stock = {\"Mouse\": 12, \"Cable\": 50, \"Webcam\": 3, \"Charger\": 27}\nprint(sorted(product_stock))\nprint(sorted(product_stock.values()))\n```\n\n\nSorting a dict sorts the keys, same as iterating a dict. To sort by value, pass a key function (more on that in a moment).\n\nStrings sort character by character using Unicode code points. Uppercase letters come before lowercase ones because their code points are smaller.\n\n\n```python\ncustomers = [\"alice\", \"Bob\", \"charlie\", \"Diana\"]\nprint(sorted(customers))\n```\n\n\nThat's almost never what you want for human-readable names. The fix is a `key` function, which the next section covers.\n\n\n> **INFO**\n>\n> **Cost:** `sorted()` is O(n log n) for n items and uses O(n) extra memory because it builds a new list. For very large lists where you don't need the original order preserved, `list.sort()` sorts in place and avoids the allocation.\n\n\n---\n\n# reverse Flips the Order\n\nPass `reverse=True` to flip the result from smallest-first to largest-first.\n\n\n```python\nprices = [29.99, 14.99, 9.99, 49.99, 19.99]\n\ncheap_first = sorted(prices)\nexpensive_first = sorted(prices, reverse=True)\n\nprint(cheap_first)\nprint(expensive_first)\n```\n\n\n`reverse=True` is exactly the same result you'd get from `sorted(prices)[::-1]`, but it does it in one pass instead of two and reads more cleanly. Use the keyword argument.\n\n---\n\n# The key Argument\n\nBy default `sorted()` compares items directly. That works when the items are numbers or simple strings, but the moment you have richer data (dicts, tuples, objects), you need to tell `sorted()` which piece of each item to compare. That's what `key` does.\n\n`key` is a function that takes one item and returns the value to sort on. Python calls this function on every item, then sorts by the returned values.\n\n\n```python\nproducts = [\n {\"name\": \"Wireless Mouse\", \"price\": 29.99, \"rating\": 4.5},\n {\"name\": \"USB Cable\", \"price\": 9.99, \"rating\": 4.2},\n {\"name\": \"Webcam\", \"price\": 49.99, \"rating\": 4.8},\n {\"name\": \"HDMI Cable\", \"price\": 14.99, \"rating\": 3.9},\n]\n\nby_price = sorted(products, key=lambda p: p[\"price\"])\n\nfor product in by_price:\n print(f\"{product['name']:<16} ${product['price']}\")\n```\n\n\nThe lambda pulls `p[\"price\"]` out of each dict, and `sorted()` orders the list by those prices. The dicts themselves are never compared directly.\n\nCombine `key` and `reverse` to get \"highest rated first\":\n\n\n```python\ntop_rated = sorted(products, key=lambda p: p[\"rating\"], reverse=True)\n\nfor product in top_rated:\n print(f\"{product['name']:<16} {product['rating']}\")\n```\n\n\nThe earlier case-insensitive name problem fixes the same way:\n\n\n```python\ncustomers = [\"alice\", \"Bob\", \"charlie\", \"Diana\"]\nprint(sorted(customers, key=str.lower))\n```\n\n\n`str.lower` is a function (technically an unbound method). Python calls it on each name to get the value used for comparison. The original strings stay in their original case, only the comparison sees the lowercase version.\n\n---\n\n# itemgetter and attrgetter\n\nLambdas are flexible, but for the common case of \"pull this key out of a dict\" or \"pull this attribute off an object\", the `operator` module has two helpers that are both faster and easier to read.\n\n`operator.itemgetter(\"price\")` returns a function that takes a dict (or any subscriptable object) and returns `dict[\"price\"]`. It does the same thing as `lambda p: p[\"price\"]`, but it's implemented in C and runs noticeably faster in tight loops.\n\n\n```python\nfrom operator import itemgetter\n\nproducts = [\n {\"name\": \"Wireless Mouse\", \"price\": 29.99, \"rating\": 4.5},\n {\"name\": \"USB Cable\", \"price\": 9.99, \"rating\": 4.2},\n {\"name\": \"Webcam\", \"price\": 49.99, \"rating\": 4.8},\n]\n\nby_price = sorted(products, key=itemgetter(\"price\"))\nprint([p[\"name\"] for p in by_price])\n```\n\n\nFor objects (instances of a class), use `attrgetter`:\n\n\n```python\nfrom operator import attrgetter\n\nclass Product:\n def __init__(self, name, price, rating):\n self.name = name\n self.price = price\n self.rating = rating\n\n def __repr__(self):\n return f\"{self.name} (${self.price})\"\n\ncatalog = [\n Product(\"Wireless Mouse\", 29.99, 4.5),\n Product(\"USB Cable\", 9.99, 4.2),\n Product(\"Webcam\", 49.99, 4.8),\n]\n\nprint(sorted(catalog, key=attrgetter(\"price\")))\n```\n\n\n`itemgetter` and `attrgetter` both accept multiple names, which gives you multi-key sorting for free.\n\n---\n\n# Multi-Key Sorting with Tuples\n\nTo sort by more than one field (rating first, then price as a tiebreaker), return a tuple from the key function. Python compares tuples element by element, so `(4.5, 29.99) < (4.5, 49.99)` because the first elements tie and the second one decides.\n\n\n```python\nproducts = [\n {\"name\": \"Wireless Mouse\", \"price\": 29.99, \"rating\": 4.5},\n {\"name\": \"USB Cable\", \"price\": 9.99, \"rating\": 4.2},\n {\"name\": \"Webcam\", \"price\": 49.99, \"rating\": 4.8},\n {\"name\": \"HDMI Cable\", \"price\": 14.99, \"rating\": 4.5},\n {\"name\": \"Charger\", \"price\": 24.99, \"rating\": 4.2},\n]\n\n# Highest rating first, cheapest first within a rating\nordered = sorted(products, key=lambda p: (-p[\"rating\"], p[\"price\"]))\n\nfor product in ordered:\n print(f\"{product['rating']} ${product['price']:<6} {product['name']}\")\n```\n\n\nTwo things in that tuple are worth pointing out. First, `-p[\"rating\"]` flips the rating sort to descending without using `reverse=True` (which would flip both fields). Second, the price stays ascending because the second element is `p[\"price\"]` (positive). That mixed-direction trick is one of the most common multi-key patterns.\n\n`itemgetter` handles the same case when both directions are the same:\n\n\n```python\nfrom operator import itemgetter\n\n# Cheapest first, then alphabetical name as a tiebreaker\nordered = sorted(products, key=itemgetter(\"price\", \"name\"))\nprint([p[\"name\"] for p in ordered])\n```\n\n\nWhen you need mixed directions and the values aren't numeric (so you can't negate them), the trick is to sort twice and rely on stability, which is the next topic.\n\n---\n\n# Stability of Timsort\n\nPython's sort algorithm is called **Timsort**, named after Tim Peters who designed it for CPython in 2002. It's a hybrid of merge sort and insertion sort, tuned for real-world data. One of its guarantees matters every day: it's **stable**.\n\nA stable sort preserves the original order of items that compare equal. If two products have the same rating, the one that came first in the input list stays first in the output.\n\n\n```python\nproducts = [\n {\"name\": \"Wireless Mouse\", \"rating\": 4.5},\n {\"name\": \"Webcam\", \"rating\": 4.8},\n {\"name\": \"HDMI Cable\", \"rating\": 4.5},\n {\"name\": \"USB Cable\", \"rating\": 4.2},\n]\n\nby_rating = sorted(products, key=lambda p: p[\"rating\"])\nfor product in by_rating:\n print(product)\n```\n\n\n`Wireless Mouse` and `HDMI Cable` both have rating 4.5. Wireless Mouse came first in the input, so it comes first in the output. That ordering is guaranteed, not a coincidence.\n\nStability unlocks a powerful technique: **sort multiple times, from least important key to most important**. Each sort keeps the order of the previous one for equal items.\n\n\n```python\nproducts = [\n {\"name\": \"Wireless Mouse\", \"price\": 29.99, \"rating\": 4.5},\n {\"name\": \"USB Cable\", \"price\": 9.99, \"rating\": 4.2},\n {\"name\": \"Webcam\", \"price\": 49.99, \"rating\": 4.8},\n {\"name\": \"HDMI Cable\", \"price\": 14.99, \"rating\": 4.5},\n {\"name\": \"Charger\", \"price\": 24.99, \"rating\": 4.2},\n]\n\n# Step 1: sort by price ascending (the tiebreaker)\nby_price = sorted(products, key=lambda p: p[\"price\"])\n\n# Step 2: sort by rating descending (the primary key)\nfinal = sorted(by_price, key=lambda p: p[\"rating\"], reverse=True)\n\nfor product in final:\n print(f\"{product['rating']} ${product['price']:<6} {product['name']}\")\n```\n\n\nSame result as the tuple-key version, but each sort step uses its own `reverse` argument. That's useful when one key is a string and the other is a number, or anything else that can't be negated cleanly.\n\n\n```mermaid\nflowchart LR\n A[Original list]:::cyan --> B[Sort by price
ascending]:::orange\n B --> C[Sort by rating
descending]:::green\n C --> D[Final: rating desc,
price asc within tie]:::teal\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe diagram shows the two-pass sort. The first sort groups items by price. The second sort groups them by rating, and Timsort's stability guarantees that items with the same rating keep their price order from step one.\n\n\n> **INFO**\n>\n> **Cost:** Each sort pass is O(n log n). Two passes is 2x the work of one pass, but it's still O(n log n) overall. For most lists this difference is irrelevant. The tuple-key approach is usually faster because it sorts once, but the multi-pass approach is more readable for complex mixed-direction sorts.\n\n\n---\n\n# reversed Returns an Iterator\n\n`reversed()` takes a sequence and gives you back an iterator that yields the items in reverse order. It does not return a list, and it does not modify the original.\n\n\n```python\norder_history = [\"order-101\", \"order-102\", \"order-103\", \"order-104\"]\n\nfor order in reversed(order_history):\n print(order)\n```\n\n\nTwo things to watch. First, `reversed()` returns an iterator, so you can only walk it once. After the `for` loop above, the iterator is exhausted. Second, it works on sequences (anything with a length and integer indexing): lists, tuples, strings, ranges. It doesn't work on plain sets or generators, because those don't support indexed access.\n\n\n```python\nprint(reversed([1, 2, 3]))\nprint(list(reversed([1, 2, 3])))\nprint(list(reversed(\"Mouse\")))\nprint(list(reversed(range(5))))\n```\n\n\nIf you need the reversed result as a list, wrap the call with `list()`. If you just want to loop over the items in reverse, the iterator is enough and avoids the allocation.\n\nFor your own classes, define `__reversed__` and `reversed()` will pick it up:\n\n\n```python\nclass OrderHistory:\n def __init__(self, orders):\n self.orders = orders\n\n def __reversed__(self):\n return reversed(self.orders)\n\nhistory = OrderHistory([\"order-101\", \"order-102\", \"order-103\"])\nfor order in reversed(history):\n print(order)\n```\n\n\nThis is rare in everyday code, but it's how `collections.deque` and similar containers make `reversed()` work efficiently.\n\n---\n\n# reversed vs Slicing with [::-1]\n\nYou can also reverse a sequence with the slice `seq[::-1]`. It looks shorter, but it's not quite the same thing.\n\n\n```python\norder_history = [\"order-101\", \"order-102\", \"order-103\", \"order-104\"]\n\n# Slice: builds a new list right away\nsliced = order_history[::-1]\nprint(type(sliced), sliced)\n\n# reversed: returns an iterator, lazy\niterator = reversed(order_history)\nprint(type(iterator), iterator)\nprint(list(iterator))\n```\n\n\nThe slice runs immediately and allocates a new list of the same size as the input. `reversed()` builds an iterator object that holds a reference to the original sequence and walks it backwards on demand. For a million-item list, the slice copies a million references; `reversed()` allocates a tiny iterator object regardless of size.\n\n\n> **INFO**\n>\n> **Cost:** `reversed(seq)` is O(1) and uses constant memory (it's lazy). `seq[::-1]` is O(n) time and O(n) extra memory because it builds a full reversed copy. For just iterating once in reverse, `reversed()` is always cheaper. For \"give me a reversed list to pass somewhere else\", use the slice (or `list(reversed(seq))`, which has the same cost).\n\n\n\n| Operation | Returns | Time | Memory | Use when |\n| --- | --- | --- | --- | --- |\n| `reversed(seq)` | Iterator | O(1) to build, O(n) to consume | O(1) | You're looping once in reverse |\n| `seq[::-1]` | New list (or new string/tuple) | O(n) | O(n) | You need a reversed copy to index, pass, or reuse |\n\n\nThe slice has one quiet bonus: it works on more than sequences in a generic way for any object that supports slicing, including strings (where `reversed()` works fine too) and bytes. The big practical difference is the laziness.\n\n\n```python\n# Common idiom: enumerate in reverse without allocating\nitems = [\"Mouse\", \"Cable\", \"Webcam\", \"Charger\", \"HDMI\"]\n\nfor index, item in enumerate(reversed(items)):\n print(index, item)\n```\n\n\nActually, the indices restart at 0 because `enumerate` doesn't know about the original positions. If you want the original index alongside the reversed item, you have to be careful:\n\n\n```python\nitems = [\"Mouse\", \"Cable\", \"Webcam\", \"Charger\", \"HDMI\"]\n\nfor index in reversed(range(len(items))):\n print(index, items[index])\n```\n\n\n`reversed(range(len(items)))` is O(1) and gives you the original indices in reverse. The slice version `range(len(items))[::-1]` would build a new range object too, but `reversed(range(...))` is the more idiomatic Python here.\n\n---\n\n# sorted vs list.sort\n\nLists have their own `.sort()` method. The two look almost identical, but they have one important difference, and a few smaller ones.\n\n\n| Feature | `sorted(iterable)` | `list.sort()` |\n| --- | --- | --- |\n| Returns | New list | `None` |\n| Modifies original | No | Yes (in place) |\n| Works on | Any iterable | Lists only |\n| Memory | O(n) extra | O(1) extra (in place) |\n| Accepts `key` and `reverse` | Yes | Yes |\n\n\nUse `sorted()` when:\n\n- The input isn't a list (a tuple, set, dict, generator).\n- You want to keep the original order around.\n- You're chaining: `sorted(...)` returns a list you can pass to another function.\n\nUse `list.sort()` when:\n\n- You have a list and don't need the original order.\n- The list is large and you want to avoid the extra O(n) allocation.\n\nThe single most common bug with `list.sort()` is forgetting it returns `None`:\n\n\n```python\nprices = [29.99, 14.99, 9.99]\nsorted_prices = prices.sort() # WRONG: returns None\nprint(sorted_prices)\n```\n\n\nThe fix is either to use `sorted()` if you want a returned value, or to sort in place and use the original variable:\n\n\n```python\nprices = [29.99, 14.99, 9.99]\nprices.sort()\nprint(prices)\n```\n","pageType":"python"}

sorted & reversed

Get Premium