{"title":"Indexing & Slicing","description":"","content":"Slicing is how Python lets you grab a chunk of a list without writing a loop. Pulling the first five reviews on a product page, paginating a search result, taking the top three items by price, reversing a wishlist: all of it uses the same compact `[start:stop:step]` syntax. This lesson covers what slices return, how the bounds and step interact, the rules around negative indices, and how slice assignment lets you replace, grow, shrink, or delete chunks of a list in one shot.\n\n---\n\n# The Basic Slice\n\nA slice has the shape `cart[start:stop]`. Python returns a new list containing the elements from index `start` up to, but not including, index `stop`.\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\", \"Charger\"]\n\nfirst_two = cart[0:2]\nprint(first_two)\n```\n\n\n`cart[0:2]` gives you the items at index `0` and `1`. Index `2` is the stop value, and it's exclusive, so `HDMI` is not in the result. This is the same half-open convention that `range()` uses: a range or slice with `stop` produces exactly `stop - start` items, which makes the math easy to reason about.\n\nThe clearest way to picture this is to imagine the indices as positions *between* the elements, not on top of them. A list of five items has six slot positions: `0` before the first item, `5` after the last.\n\n\n```mermaid\nflowchart LR\n P0([0]):::pos --> E1[Mouse]:::cyan --> P1([1]):::pos --> E2[Cable]:::orange --> P2([2]):::pos --> E3[HDMI]:::green --> P3([3]):::pos --> E4[Webcam]:::teal --> P4([4]):::pos --> E5[Charger]:::red --> P5([5]):::pos\n\n classDef pos fill:#ffd43b,stroke:#000,color:#000\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 classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\n`cart[1:4]` cuts at slot position `1` and slot position `4`, taking everything between those two cuts: `Cable`, `HDMI`, `Webcam`. The number of items is always `stop - start`, which here is `4 - 1 = 3`.\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\", \"Charger\"]\n\nmiddle = cart[1:4]\nprint(middle)\nprint(len(middle))\n```\n\n\n\n> **INFO**\n>\n> **Cost:** A slice allocates a new list and copies `stop - start` references into it. For a five-item slice, the work is invisible. For a million-item slice, you're paying O(k) in both time and memory, where `k` is the slice length. The list contents are not deep-copied; only the references are.\n\n\n---\n\n# Omitting the Bounds\n\nYou can leave out `start`, `stop`, or both. Python fills in sensible defaults: `start` defaults to `0`, and `stop` defaults to the length of the list. That gives you four readable patterns for everyday slicing.\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\", \"Charger\"]\n\nprint(cart[:3])\nprint(cart[2:])\nprint(cart[:])\n```\n\n\n`cart[:3]` reads as \"everything up to index 3\". `cart[2:]` reads as \"from index 2 to the end\". `cart[:]` reads as \"from start to end\", which gives you a full copy of the list.\n\nA real e-commerce example: paginating a product list. Suppose each page shows ten products and the customer is on page three.\n\n\n```python\nproducts = [f\"Product-{i:03d}\" for i in range(1, 51)]\n\npage_size = 10\npage_number = 3\n\nstart = (page_number - 1) * page_size\nend = start + page_size\npage = products[start:end]\n\nprint(f\"Page {page_number}:\")\nfor product in page:\n print(f\" {product}\")\n```\n\n\nThe math is clean: page `n` starts at `(n - 1) * page_size` and ends at `n * page_size`. Because the stop is exclusive, no overlap or gap between pages.\n\n---\n\n# Out-of-Bounds Slices Are Safe\n\nSlicing has one trait that surprises people coming from other habits: it never raises `IndexError`, even when the bounds are wildly outside the list.\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\"]\n\nprint(cart[0:100])\nprint(cart[5:10])\nprint(cart[2:1])\n```\n\n\nThree different \"wrong\" slices, three quiet answers. `cart[0:100]` clamps the stop to the actual list length and returns whatever's there. `cart[5:10]` starts past the end, so there's nothing to take, and you get an empty list. `cart[2:1]` has a stop before the start, which is also empty.\n\nCompare that to indexing, which is strict:\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\"]\n\nprint(cart[100])\n```\n\n\nThe lenient behavior of slices is intentional. It lets you write code like \"give me the first ten products\" without checking how many actually exist. If the catalog has only three, you get those three back instead of a crash.\n\n\n```python\nproducts = [\"Mouse\", \"Cable\", \"HDMI\"]\n\ntop_ten = products[:10]\nprint(top_ten)\n```\n\n\nNo length check needed. The slice silently does the right thing.\n\n---\n\n# Negative Indices\n\nSlices accept negative indices the same way indexing does: `-1` is the last element, `-2` the second-to-last, and so on. This is useful when you want \"the last N items\" without computing the length yourself.\n\n\n```python\nprices = [29.99, 14.99, 49.99, 9.99, 19.99, 39.99]\n\nlast_three = prices[-3:]\nprint(last_three)\n```\n\n\n`prices[-3:]` reads as \"from three positions before the end to the end\". The omitted stop defaults to the list length, so you get the last three items.\n\nNegative values work for the stop too. `cart[:-1]` is \"everything except the last item\":\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\"]\n\nwithout_last = cart[:-1]\nprint(without_last)\n```\n\n\nYou can mix positive and negative bounds freely. `cart[1:-1]` skips the first and last items:\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\"]\n\nmiddle = cart[1:-1]\nprint(middle)\n```\n\n\nA small reference for the common shapes:\n\n\n| Slice | Meaning |\n| --- | --- |\n| `cart[:n]` | First `n` items |\n| `cart[-n:]` | Last `n` items |\n| `cart[n:]` | Everything from index `n` onward |\n| `cart[:-n]` | Everything except the last `n` items |\n| `cart[1:-1]` | Everything except the first and last items |\n| `cart[:]` | Full copy of the list |\n\n\n---\n\n# The Step Argument\n\nA slice can take a third value: a step, written as `cart[start:stop:step]`. The step controls how far the slice jumps between values. The default step is `1`, which is what every example so far has used implicitly.\n\n\n```python\nproducts = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\", \"Charger\", \"Keyboard\"]\n\nevery_other = products[::2]\nprint(every_other)\n```\n\n\n`products[::2]` starts at index `0`, runs to the end, and takes every second element. You'd reach for this when you need to sample a list, alternate between groups, or pick every Nth row.\n\nCombining a step with explicit bounds works as you'd expect:\n\n\n```python\nnumbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n\nprint(numbers[1:8:2])\n```\n\n\nStart at `1`, jump by `2`, stop before `8`. So the slice produces `1`, `3`, `5`, `7`. The next value would be `9`, which is past the stop, so the slice ends.\n\n\n> **INFO**\n>\n> **Cost:** A larger step doesn't make slicing cheaper. The slice still walks the positions internally; it just skips most of them. `huge_list[::1000]` is no faster than `huge_list[::1]` per element scanned, though it allocates a much smaller result list.\n\n\nA step of `0` is not allowed. Python raises `ValueError` because a step of zero would mean \"don't move\", which can't produce a finite sequence.\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\"]\n\nprint(cart[::0])\n```\n\n\nThat's the one slicing operation that raises. Every other out-of-range or backwards combination quietly returns an empty list.\n\n---\n\n# Negative Step and the Reversal Idiom\n\nThe step can be negative, which makes the slice walk the list backwards. When the step is negative, the default `start` becomes the last index and the default `stop` becomes \"before the first index\". So `cart[::-1]` walks from end to start.\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\"]\n\nreversed_cart = cart[::-1]\nprint(reversed_cart)\n```\n\n\n`cart[::-1]` is the idiomatic Python way to get a reversed copy of a list. It's short, fast, and every Python developer recognizes it on sight. The original list is untouched; you get a new list back.\n\nIf you only want every second element in reverse, combine the step with the direction:\n\n\n```python\nproducts = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\", \"Charger\", \"Keyboard\"]\n\nprint(products[::-2])\n```\n\n\nStart at the last item (`Keyboard`), step by `-2` (two positions backwards each time), stop before the beginning. So you visit indices `5`, `3`, `1`.\n\nWith a negative step, the bounds also flip in meaning: `start` is the higher position and `stop` is the lower one. If you write `cart[0:4:-1]`, you get an empty list, because going forward from `0` to `4` with a negative step makes no sense.\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\"]\n\nprint(cart[0:4:-1])\nprint(cart[4:0:-1])\n```\n\n\nThe first call returns empty because the direction doesn't match the bounds. The second call walks from index `4` down to (but not including) index `0`, which gives the last three items.\n\n---\n\n# Slice Returns a New List\n\nEvery slice produces a fresh list. The new list holds references to the same objects the original list held, but the list container itself is independent. Mutating the slice does not change the original.\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\"]\n\nfirst_two = cart[:2]\nfirst_two.append(\"Webcam\")\n\nprint(first_two)\nprint(cart)\n```\n\n\n`first_two` is a separate list. Appending to it doesn't touch `cart`. This is different from plain assignment (`first_two = cart`), which would have made both names point to the same list.\n\nThe `cart[:]` form is the most direct way to copy a list. It's used wherever you want to walk a list while modifying the original safely, or hand a list to a function without letting that function mutate yours.\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\"]\n\nsnapshot = cart[:]\ncart.append(\"Webcam\")\n\nprint(snapshot)\nprint(cart)\n```\n\n\n`snapshot` keeps the original three items because it was a copy of the list at that moment. The slice did the copying work.\n\nThere's a wrinkle to be aware of: `cart[:]` is a **shallow copy**. The new list is independent, but if the items inside are themselves mutable (other lists, dicts, custom objects), both lists share those inner objects. Modifying an inner object through one list shows up in the other.\n\n\n> **INFO**\n>\n> **Cost:** `cart[:]` allocates a new list and copies all references. For a list of N items, that's O(N) in time and memory. It's the right tool for \"I need a separate list\", but don't reach for it when you just want to read.\n\n\n---\n\n# Slice Assignment\n\nSlicing can also appear on the left side of an assignment, which lets you replace a chunk of a list in one expression. The right-hand side has to be an iterable, and Python overwrites the targeted slice with the iterable's contents.\n\nThe simplest case is replacing the same number of items.\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\"]\n\ncart[1:3] = [\"Keyboard\", \"Speaker\"]\nprint(cart)\n```\n\n\nThe slice `cart[1:3]` covers two items (`Cable` and `HDMI`), and the right-hand side has two items, so it's a clean swap. Nothing about the surrounding list changes.\n\nThe replacement doesn't have to be the same size. You can shove more items into a slice than the slice originally had, and the list grows:\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\"]\n\ncart[1:3] = [\"A\", \"B\", \"C\"]\nprint(cart)\n```\n\n\nThe two-item slice gets replaced by three items, so the list now has five elements. Or you can replace with fewer items, and the list shrinks:\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\", \"Charger\"]\n\ncart[1:4] = [\"Keyboard\"]\nprint(cart)\n```\n\n\nThree items vanish and one takes their place.\n\nThe most extreme version of \"shrink\" is replacing with an empty list, which deletes the slice outright:\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\"]\n\ncart[1:3] = []\nprint(cart)\n```\n\n\nThe same effect is more directly expressed with `del`:\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\"]\n\ndel cart[1:3]\nprint(cart)\n```\n\n\n`del cart[a:b]` and `cart[a:b] = []` do the same work. Prefer `del` when your intent is to remove; it reads better and signals the operation clearly.\n\nSlice assignment can also insert without removing anything, by targeting an empty slice. `cart[2:2]` is an empty slice at position 2, and assigning to it splices new items in:\n\n\n```python\ncart = [\"Mouse\", \"Cable\", \"Webcam\"]\n\ncart[2:2] = [\"HDMI\", \"Charger\"]\nprint(cart)\n```\n\n\nThat's how you insert a batch of items at a specific position without using `insert()` in a loop.\n\n\n> **INFO**\n>\n> **Cost:** Slice assignment that changes the list's length forces the items after the slice to shift in memory. For a list of N items where you replace at index `i`, that's roughly O(N - i) work to do the shift. Appending at the very end (`cart[len(cart):] = [...]`) avoids the shift and is cheap.\n\n\nA real e-commerce scenario: replacing a contiguous range of products in a catalog with new ones.\n\n\n```python\ncatalog = [\"Mouse\", \"Cable\", \"HDMI\", \"Webcam\", \"Charger\"]\n\ndiscontinued = catalog[1:4]\nreplacement = [\"UltraCable\", \"ProHDMI\", \"HD-Webcam\", \"USB-C Charger\"]\ncatalog[1:4] = replacement\n\nprint(f\"Removed: {discontinued}\")\nprint(f\"Catalog: {catalog}\")\n```\n\n\nThree items leave, four items take their place, and the surrounding list is preserved. One assignment, no loop.\n\n---\n\n# What's Wrong With This Code\n\nA slice looks like an assignable thing on any sequence, so people try to mutate strings or tuples through it. Both fail, and the error is worth recognizing.\n\n**What's wrong with this code?**\n\n\n```python\norder_id = \"ORD-1023\"\norder_id[4:] = \"9999\"\nprint(order_id)\n```\n\n\nStrings are immutable. You can read a slice from a string (`order_id[4:]` gives `\"1023\"`), but you can't assign to it. Slice assignment only works on mutable sequences, which in everyday Python means lists, `bytearray`, and a few others. Tuples have the same restriction:\n\n\n```python\norder = (\"ORD-1023\", \"Mouse\", 29.99)\norder[1:2] = (\"Cable\",)\n```\n\n\nThe fix for both cases is to build a new value with the change you want. For a string, slice the parts you want to keep and concatenate:\n\n**Fix:**\n\n\n```python\norder_id = \"ORD-1023\"\norder_id = order_id[:4] + \"9999\"\nprint(order_id)\n```\n\n\nThe other trap is using a step of `0`, which we covered earlier. The error there is `ValueError`, not `TypeError`, so it's distinguishable from the immutable-sequence problem at a glance.\n\n---\n\n# Putting It Together: Top N by Price\n\nA small composition exercise. Take a product list with prices, sort it, then slice off the top three. This combines slicing with `sorted()` to show how slicing fits into common workflows.\n\n\n```python\nproducts = [\n (\"Mouse\", 29.99),\n (\"Cable\", 4.99),\n (\"HDMI\", 14.99),\n (\"Webcam\", 79.99),\n (\"Charger\", 19.99),\n (\"Keyboard\", 59.99),\n]\n\nby_price = sorted(products, key=lambda item: item[1], reverse=True)\ntop_three = by_price[:3]\n\nprint(\"Top 3 by price:\")\nfor name, price in top_three:\n print(f\" {name}: ${price:.2f}\")\n```\n\n\n`sorted()` returns a new list sorted by the second element of each tuple (the price), in descending order. The slice `by_price[:3]` then keeps the first three. Two operations, no loops, one readable expression for \"top 3 by price\". This is the kind of place slicing earns its keep.","pageType":"python"}

Indexing & Slicing

Get Premium