{"title":"zip & enumerate","description":"","content":"`zip` pairs up items from two or more sequences so you can walk them together, and `enumerate` glues an index counter onto any iterable so you don't have to keep one yourself. They show up constantly in real Python code because so much of programming is \"process these two lists side by side\" or \"number these items as I go\". This lesson covers how both work, their lazy iterator nature, the edge cases that bite people (mismatched lengths, the `strict=True` flag added in 3.10), and a few patterns like transposing and dict-building.\n\n---\n\n# Walking Two Lists Together with `zip`\n\nImagine you have one list of product names and another list of their prices. You want to print each name next to its price. A common first instinct is to loop with an index, but Python has a cleaner option.\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"Charger\"]\nprices = [29.99, 9.99, 19.99]\n\nfor product, price in zip(products, prices):\n print(f\"{product}: ${price:.2f}\")\n```\n\n\n`zip` takes two or more iterables and yields tuples that pair up their elements: first with first, second with second, and so on. The for-loop unpacks each tuple directly into `product, price`, so the loop body reads like English.\n\nYou're not limited to two iterables. Pass three, four, however many you need:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"Charger\"]\nprices = [29.99, 9.99, 19.99]\nstock = [12, 50, 8]\n\nfor product, price, count in zip(products, prices, stock):\n print(f\"{product}: ${price:.2f} ({count} in stock)\")\n```\n\n\nEach tuple `zip` produces has one element per iterable, in the order you passed them.\n\n---\n\n# `zip` Returns an Iterator, Not a List\n\nThis trips people up. In Python 3, `zip` doesn't build a list of tuples up front. It returns a lazy iterator that produces tuples one at a time as you ask for them.\n\n\n```python\n>>> zip([1, 2, 3], [\"a\", \"b\", \"c\"])\n\n```\n\n\nYou see a `zip object`, not a list. To actually look at the contents, you either iterate over it (with a for-loop, a comprehension, etc.) or convert it with `list()`:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"Charger\"]\nprices = [29.99, 9.99, 19.99]\n\npairs = list(zip(products, prices))\nprint(pairs)\n```\n\n\nThe lazy behavior matters in two ways. First, `zip` uses constant memory regardless of input size, because it only holds one tuple at a time. That's a real win when you're zipping huge files or generators.\n\nSecond, a `zip` object is single-pass. Once you've iterated through it, it's exhausted. A second loop sees nothing.\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\"]\nprices = [29.99, 9.99]\n\npairs = zip(products, prices)\n\nfor item in pairs:\n print(item)\n\nprint(\"Second loop:\")\nfor item in pairs:\n print(item) # never runs\n```\n\n\nIf you need to walk the pairs more than once, store them: `pairs = list(zip(...))`.\n\n\n> **INFO**\n>\n> **Cost:** `list(zip(a, b))` allocates a new list of tuples, so memory scales with input length. For one-shot loops, skip the `list()` call and iterate the zip object directly to keep memory flat.\n\n\n---\n\n# Mismatched Lengths and `strict=True`\n\nWhat happens if the inputs aren't the same length? By default, `zip` stops as soon as the shortest one runs out:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"Charger\", \"HDMI Cable\"]\nprices = [29.99, 9.99, 19.99] # only three prices\n\nfor product, price in zip(products, prices):\n print(f\"{product}: ${price:.2f}\")\n```\n\n\n\"HDMI Cable\" is silently dropped. No warning, no error. That's convenient when you know the lengths match, but dangerous when you don't, because a bug in your data (a missing price, an extra product) goes unnoticed.\n\nPython 3.10 added a `strict=True` keyword argument that raises `ValueError` if the iterables don't all have the same length:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"Charger\", \"HDMI Cable\"]\nprices = [29.99, 9.99, 19.99]\n\nfor product, price in zip(products, prices, strict=True):\n print(f\"{product}: ${price:.2f}\")\n```\n\n\nThe error surfaces the moment `zip` discovers the mismatch, which is partway through the loop in this example. Most production code that uses `zip` should pass `strict=True` whenever you expect the inputs to be the same length. It turns a silent data bug into a loud one.\n\nIf you actually want to fill in missing values instead of stopping or erroring, that's what `itertools.zip_longest` is for. Here's a one-line preview:\n\n\n```python\nfrom itertools import zip_longest\n\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"Charger\", \"HDMI Cable\"]\nprices = [29.99, 9.99, 19.99]\n\nfor product, price in zip_longest(products, prices, fillvalue=0.00):\n print(f\"{product}: ${price:.2f}\")\n```\n\n\nThe three modes give you a clean menu of choices: truncate (default), fill (`zip_longest`), or raise (`strict=True`).\n\n\n| Behavior on length mismatch | How to get it | Use when |\n| -------------------------- | ------------- | -------- |\n| Stop at shortest, silently | `zip(a, b)` (default) | You explicitly want truncation |\n| Raise `ValueError` | `zip(a, b, strict=True)` | Lengths should always match; mismatch is a bug |\n| Fill missing with a default | `zip_longest(a, b, fillvalue=...)` | You want to pad the short side |\n\n\n---\n\n# Visualizing `zip`\n\nThe diagram below shows what `zip(products, prices)` produces. Each step pulls one element from each input and packages them into a tuple.\n\n\n```mermaid\nflowchart LR\n subgraph IN[Inputs]\n P1[Wireless Mouse]:::cyan\n P2[USB Cable]:::cyan\n P3[Charger]:::cyan\n R1[29.99]:::orange\n R2[9.99]:::orange\n R3[19.99]:::orange\n end\n\n Z[zip iterator]:::teal\n\n subgraph OUT[Tuples yielded]\n T1[Wireless Mouse, 29.99]:::green\n T2[USB Cable, 9.99]:::green\n T3[Charger, 19.99]:::green\n end\n\n P1 --> Z\n R1 --> Z\n P2 --> Z\n R2 --> Z\n P3 --> Z\n R3 --> Z\n\n Z --> T1\n Z --> T2\n Z --> T3\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe `zip` iterator (in the middle) pulls one item from each input on demand, packages them as a tuple, hands it out, and then waits to be asked for the next one. Nothing is precomputed.\n\n---\n\n# Building a Dict from Two Lists\n\nA common use of `zip` is turning two parallel lists into a dictionary. Pass the zip object to `dict()`:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"Charger\"]\nprices = [29.99, 9.99, 19.99]\n\nprice_lookup = dict(zip(products, prices))\nprint(price_lookup)\nprint(price_lookup[\"USB Cable\"])\n```\n\n\n`dict()` accepts any iterable of two-element pairs, and zip produces exactly that shape. The first list becomes keys, the second becomes values. If keys are duplicated, the later value wins (same rule as any dict construction). For longer pipelines you'd reach for a dict comprehension, but `dict(zip(...))` is hard to beat for readability when you have two clean parallel lists.\n\n---\n\n# The Unzip Idiom: `zip(*pairs)`\n\n`zip` can also undo itself. If you have a list of pairs and you want to split them back into separate lists, the idiom is `zip(*pairs)`:\n\n\n```python\norders = [\n (\"Alice\", 3),\n (\"Bob\", 1),\n (\"Carol\", 5),\n]\n\nnames, counts = zip(*orders)\nprint(names)\nprint(counts)\n```\n\n\nThe `*` unpacks the list into separate arguments. So `zip(*orders)` is the same as `zip((\"Alice\", 3), (\"Bob\", 1), (\"Carol\", 5))`. Now zip is pairing up the first elements (the names) and the second elements (the counts), giving you two tuples.\n\nThis trick works for any rectangular data. Here's how to transpose a table of order totals where rows are customers and columns are months:\n\n\n```python\ntotals = [\n [100, 120, 150], # Alice\n [50, 60, 70], # Bob\n [200, 180, 220], # Carol\n]\n\nby_month = list(zip(*totals))\nprint(by_month)\n```\n\n\nEach tuple is now one month's totals across all three customers, exactly what you'd want to plot a \"sales per month\" chart. The same expression also works on tuples of tuples, generator output, or anything else iterable.\n\n\n> **INFO**\n>\n> **Cost:** `zip(*matrix)` materializes one row at a time but has to consume the outer iterable up front (because `*` needs to unpack it). For very wide tables (millions of columns), each yielded tuple is still O(rows) in size. Memory scales with the number of rows, not columns.\n\n\n---\n\n# Numbering Items with `enumerate`\n\n`enumerate` solves a different but related problem: you want to loop through a sequence and also know the position of each item. The naive approach is to maintain your own counter:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"Charger\"]\n\ni = 0\nfor product in products:\n print(f\"{i}: {product}\")\n i += 1\n```\n\n\nThat works, but the counter is bookkeeping noise. `enumerate` does the same thing without the manual counter:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"Charger\"]\n\nfor i, product in enumerate(products):\n print(f\"{i}: {product}\")\n```\n\n\n`enumerate` wraps any iterable and yields `(index, value)` pairs. The for-loop unpacks each pair into two variables. Cleaner, less error-prone, and idiomatic.\n\nWhy is this better than `range(len(products))`? Two reasons. First, `enumerate` works on any iterable, including generators and files, where `len()` isn't even defined. Second, you get the value directly instead of indexing back in:\n\n\n```python\n# Awkward\nfor i in range(len(products)):\n print(f\"{i}: {products[i]}\")\n\n# Clean\nfor i, product in enumerate(products):\n print(f\"{i}: {product}\")\n```\n\n\nWhen reviewers see `range(len(...))` in Python code, they reach for `enumerate` reflexively. It's that common.\n\n---\n\n# Changing Where the Counter Starts\n\n`enumerate` takes an optional second argument, `start`, that sets the initial value of the counter. The default is 0, but you can use whatever makes sense for the context:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"Charger\"]\n\nfor rank, product in enumerate(products, start=1):\n print(f\"#{rank}: {product}\")\n```\n\n\nSetting `start=1` is great for anything customer-facing: order positions, leaderboard rankings, line numbers. The default `start=0` is right when you're using the index for actual list lookups, where Python is 0-indexed.\n\nThe `start` value doesn't have to be small or even positive. `enumerate(items, start=100)` numbers from 100 upward.\n\n\n```python\nnew_arrivals = [\"Wireless Earbuds\", \"Smart Bulb\", \"Power Strip\"]\n\nfor sku, product in enumerate(new_arrivals, start=5000):\n print(f\"SKU-{sku}: {product}\")\n```\n\n\nThe counter is just an integer that gets incremented by 1 each step, starting from `start`.\n\n---\n\n# `enumerate` Is Also a Lazy Iterator\n\nLike `zip`, `enumerate` returns an iterator, not a list. It only produces one `(index, value)` pair at a time and is exhausted after a single pass.\n\n\n```python\n>>> enumerate([\"a\", \"b\", \"c\"])\n\n```\n\n\nThat means `enumerate` is safe to use on very large or infinite sequences without preloading them into memory. It also means you should convert with `list()` if you need to look at the contents twice.\n\n\n```python\nindexed = list(enumerate([\"Wireless Mouse\", \"USB Cable\", \"Charger\"]))\nprint(indexed)\n```\n\n\nYou can also combine `enumerate` with `zip` when you need both an index and parallel data:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"Charger\"]\nprices = [29.99, 9.99, 19.99]\n\nfor i, (product, price) in enumerate(zip(products, prices), start=1):\n print(f\"{i}. {product}: ${price:.2f}\")\n```\n\n\nThe inner `zip` pairs each product with its price. The outer `enumerate` then numbers those pairs. The parentheses around `(product, price)` in the for-loop target are required because Python is unpacking a nested tuple: the outer pair `(index, inner_tuple)` and then the inner tuple `(product, price)`.\n\n\n> **INFO**\n>\n> **Cost:** Nesting `enumerate(zip(...))` adds one extra iterator wrapper but no real overhead. Each `next()` call walks both iterators once. There's no list construction unless you explicitly call `list()`.\n\n\n---\n\n# A Compact Comparison\n\nThe table below sums up where each function fits.\n\n\n| Function | Produces | Stops when | Common use |\n| -------- | -------- | ---------- | ---------- |\n| `zip(a, b)` | Tuples of paired elements | Shortest input exhausts | Iterating two parallel sequences |\n| `zip(a, b, strict=True)` | Same as above | Either input exhausts (errors if unequal) | Length mismatch is a bug |\n| `zip(*pairs)` | Transposed tuples | Shortest column exhausts | Splitting pairs back into columns |\n| `enumerate(iterable)` | `(index, value)` pairs | Iterable exhausts | Indexed iteration without `range(len(...))` |\n| `enumerate(iterable, start=N)` | Same, starting at `N` | Same | 1-based numbering, custom counters |\n","pageType":"python"}

zip & enumerate

Get Premium