{"title":"Nested Loops","description":"","content":"A loop whose body contains another loop is called a **nested loop**. Walking every cell in a grid, comparing every pair of items in a wishlist, generating a price table across products and quantities, all of these need iteration inside iteration. The shape is simple, but the cost grows fast, and mutation and early exit have specific pitfalls. This lesson covers when nesting is the right shape, how to control it, and the cases where a different data structure replaces one of the loops entirely.\n\n---\n\n# The Basic Shape\n\nA nested loop is exactly what the name says: a `for` (or `while`) loop sitting inside another `for` (or `while`) loop. The inner loop runs from start to finish for every single pass of the outer loop.\n\n\n```python\nfor x in range(3):\n for y in range(2):\n print(x, y)\n```\n\n\nThe outer loop binds `x` to `0`, then `1`, then `2`. Each time `x` changes, the inner loop runs fully from `y = 0` to `y = 1`. Three outer values times two inner values gives six lines of output, and the order is \"outer first, inner fast\".\n\nIndentation tells Python which body belongs to which loop. The inner `for` and its `print` are both indented one level deeper than the outer `for`. Misaligning them by even one space changes the meaning of the program (and often produces an `IndentationError`).\n\nAn e-commerce example: an order is a list of items, and a list of orders contains many of these. Walking every item in every order is a two-level iteration.\n\n\n```python\norders = [\n [\"Wireless Mouse\", \"USB Cable\"],\n [\"HDMI Cable\"],\n [\"Bluetooth Speaker\", \"Webcam\", \"Charger\"],\n]\n\nfor order_index, order in enumerate(orders, start=1):\n print(f\"Order #{order_index}:\")\n for item in order:\n print(f\" - {item}\")\n```\n\n\nThe outer loop walks the three orders. For each order, the inner loop walks the items inside that order. The body of the outer loop has two statements: the `print` of the order header, and the inner `for` loop. Both run in order for every outer iteration.\n\n\n```mermaid\nflowchart LR\n OS[Start outer loop]:::cyan --> OA{Outer
has more?}:::orange\n OA -->|Yes| OB[Bind next outer
value]:::teal\n OB --> IS[Start inner loop]:::cyan\n IS --> IA{Inner
has more?}:::orange\n IA -->|Yes| IB[Bind next inner
value]:::teal\n IB --> BODY[Run inner body]:::green\n BODY --> IA\n IA -->|No| OA\n OA -->|No| DONE[Exit]:::red\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 classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe diagram shows the control flow. The inner loop fully drains for each outer value, then the outer loop advances and the inner loop starts over from the beginning. Two nested loops over collections of size N do N times N iterations.\n\n---\n\n# When To Use Nested Loops\n\nNesting isn't an end in itself. Use it when the problem genuinely involves two layers of structure. Four cases come up often.\n\n### Walking a 2D Grid\n\nA grid is a list of lists, where each inner list is one row. To touch every cell, walk rows in the outer loop and columns in the inner loop.\n\n\n```python\nstock_grid = [\n [\"Mouse\", \"Cable\", \"HDMI\"],\n [\"Speaker\", \"Webcam\", \"Charger\"],\n [\"Keyboard\", \"Monitor\", \"Stand\"],\n]\n\nfor row in stock_grid:\n for product in row:\n print(product, end=\" \")\n print()\n```\n\n\nThe outer loop pulls one row at a time. The inner loop walks the products in that row and prints them on the same line, separated by spaces. The `print()` after the inner loop adds a newline at the end of each row.\n\nFor the position of each cell (row index and column index), `enumerate` works on both layers:\n\n\n```python\nstock_grid = [\n [\"Mouse\", \"Cable\", \"HDMI\"],\n [\"Speaker\", \"Webcam\", \"Charger\"],\n]\n\nfor row_index, row in enumerate(stock_grid):\n for col_index, product in enumerate(row):\n print(f\"({row_index}, {col_index}): {product}\")\n```\n\n\nEach cell gets its row-column pair printed alongside its value. This is the standard pattern for matrix-style work: image pixels, spreadsheet cells, board positions in a game.\n\n### Building a 2D Structure\n\nThe reverse of walking a grid is building one. A double loop creates rows and fills each row with values.\n\n\n```python\nproducts = [\"Mouse\", \"Cable\", \"Speaker\"]\nquantities = [1, 2, 5]\n\nprice_table = []\nfor name in products:\n row = []\n for q in quantities:\n row.append(f\"{name} x {q}\")\n price_table.append(row)\n\nfor row in price_table:\n print(row)\n```\n\n\nThe outer loop builds one row per product. The inner loop fills that row with one entry per quantity. The result is a `list of lists` with shape three by three, ready to be iterated, indexed, or formatted as a table.\n\n### Pair Generation\n\nSome tasks require every pairing of items from two collections (or from one collection paired with itself). A nested loop over `products` and `quantities` produces every `(product, quantity)` combination.\n\n\n```python\nproducts = [\n (\"Wireless Mouse\", 29.99),\n (\"USB Cable\", 4.99),\n]\nquantities = [1, 2, 5]\n\nfor name, unit_price in products:\n for q in quantities:\n total = unit_price * q\n print(f\"{name} x {q} = ${total:.2f}\")\n print()\n```\n\n\nTwo products and three quantities give six combinations. The blank `print()` after the inner loop adds a separator between groups.\n\n### Brute-Force Pair Search\n\nTo find pairs of items in one list that satisfy some condition, a double loop checks every pair. A common case: find every pair of products in a catalog whose combined price hits exactly a target value (a bundle deal).\n\n\n```python\nprices = [29.99, 14.99, 9.99, 49.99, 19.99]\ntarget = 44.98\n\nfor i, a in enumerate(prices):\n for j, b in enumerate(prices):\n if i < j and a + b == target:\n print(f\"prices[{i}] + prices[{j}] = {a} + {b}\")\n```\n\n\nThe `i < j` guard avoids checking the same pair twice and skips comparing an item with itself. This is the standard \"two nested loops over the same list\" shape, and it's O(N squared). For five prices, that's 25 iterations, which is fine. For a million prices, it's a trillion, which is not.\n\nTwo nested loops over a collection of size N do roughly N times N iterations. For N = 1,000, that's a million. For N = 1,000,000, that's a trillion. When the inner loop is doing a lookup or a membership check, a `set` or `dict` often collapses it down to one O(1) step, turning O(N squared) into O(N).\n\n---\n\n# Nested `while` Loops\n\nThe same nesting idea works with `while`. The shape comes up when neither loop has a fixed iterable, and both depend on conditions.\n\n\n```python\nrow = 0\nwhile row < 3:\n col = 0\n while col < 3:\n print(f\"({row}, {col})\", end=\" \")\n col += 1\n print()\n row += 1\n```\n\n\nThe outer `while` controls the row counter, the inner `while` controls the column counter. Each counter has to be advanced inside its own loop body, and the inner counter has to be reset before the inner loop starts each time.\n\nThe reset matters. Without `col = 0` before the inner loop, `col` keeps its final value from the previous iteration, and the inner loop won't run again because the condition `col < 3` is already false. The outer loop will run forever after row 0, printing nothing.\n\nLoop types can also be mixed. A `for` outside a `while` is common when the outer iteration is over a collection but the inner step depends on a running condition:\n\n\n```python\norders = [[\"Mouse\", \"Cable\"], [\"HDMI\"], [\"Speaker\", \"Webcam\", \"Charger\"]]\n\nfor order in orders:\n i = 0\n while i < len(order):\n print(order[i])\n i += 1\n print(\"---\")\n```\n\n\nThis is a contrived example because `for item in order` would be cleaner. The nesting shape works the same way regardless of which loop kind is on which level.\n\n---\n\n# Breaking Out of Nested Loops\n\n`break` only exits the **innermost** loop it sits inside. This is the most common source of confusion when both loops should stop at once.\n\n\n```python\ngrid = [[1, 2, 3], [4, 5, 99], [6, 7, 8]]\n\nfor row in grid:\n for value in row:\n if value == 99:\n print(\"Found it!\")\n break\n print(\"Outer loop continues...\")\n```\n\n\nThe `break` exits the inner loop the moment it finds `99`, but the outer loop keeps going. When the intent is \"stop everything\", that's a bug. Python has no labeled break, so the fix uses one of three workarounds.\n\n### Flag Variable\n\nSet a flag inside the inner loop and check it after the inner loop ends.\n\n\n```python\ngrid = [[1, 2, 3], [4, 5, 99], [6, 7, 8]]\n\nfound = False\nfor row in grid:\n for value in row:\n if value == 99:\n print(\"Found it!\")\n found = True\n break\n if found:\n break\n```\n\n\nSimple and explicit. The cost is the two-line check after the inner loop, and the extra variable to manage. For deeply nested loops, the flag-and-check pattern stacks up and becomes clumsy.\n\n### Wrap in a Function and Return\n\nReturning from a function exits every loop inside it at once. This is often the cleanest fix.\n\n\n```python\ndef find_target(grid, target):\n for row in grid:\n for value in row:\n if value == target:\n return value\n return None\n\nresult = find_target([[1, 2, 3], [4, 5, 99], [6, 7, 8]], 99)\nprint(result)\n```\n\n\n`return` acts as a labeled break that also unwinds the call stack. When the loops naturally belong inside a search or filter function, this is the most readable approach.\n\n### Raise an Exception (and Catch It)\n\nAn alternative is to raise a custom exception and catch it after the loops. It's overkill for normal cases but useful when the exit condition is deeply buried inside complex logic.\n\n\n```python\nclass Found(Exception):\n pass\n\ngrid = [[1, 2, 3], [4, 5, 99], [6, 7, 8]]\n\ntry:\n for row in grid:\n for value in row:\n if value == 99:\n raise Found(value)\nexcept Found as f:\n print(f\"Caught: {f}\")\n```\n\n\nMost Python code prefers the function-and-return approach. Exceptions are heavier and harder to read than a flag, but they help when the loops are buried inside helper code where introducing a function would be a bigger refactor.\n\n### Flatten with `itertools.product`\n\nWhen the only reason for nesting is to walk every combination, `itertools.product` flattens both loops into one. A single `break` then exits the whole thing.\n\n\n```python\nfrom itertools import product\n\nproducts = [\"Mouse\", \"Cable\", \"Speaker\"]\nquantities = [1, 2, 5]\n\nfor name, q in product(products, quantities):\n if name == \"Cable\" and q == 5:\n print(f\"Stopping at {name} x {q}\")\n break\n print(name, q)\n```\n\n\n`product(products, quantities)` yields every `(name, q)` pair in the same order the two `for` loops would. Because the outer iteration is now a single flat loop, one `break` exits both. `itertools` is covered properly in the iterators-and-generators section; for now, treat it as a useful one-liner.\n\n---\n\n# Continue in Nested Loops\n\n`continue` also only affects the innermost loop. It skips the rest of the current inner iteration and moves to the next one, without touching the outer loop.\n\n\n```python\norders = [\n [\"Mouse\", \"Cable\", \"HDMI\"],\n [\"Speaker\", None, \"Webcam\"],\n [None, \"Charger\", \"Keyboard\"],\n]\n\nfor order in orders:\n for item in order:\n if item is None:\n continue\n print(item)\n print(\"---\")\n```\n\n\n`continue` skips the `print(item)` line when `item` is `None`, but the inner loop keeps running for the rest of that order. The outer loop sees no change.\n\n---\n\n# Modifying Lists During Nested Iteration\n\nThe same rule from the `for` loop chapter applies, twice as hard for nested loops: don't change a list during iteration. If both loops walk the same list and the inner body mutates, the bugs become hard to spot.\n\n**What's wrong with this code?**\n\n\n```python\nprices = [10, 25, 8, 50, 14, 30]\n\nfor a in prices:\n for b in prices:\n if a + b == 18:\n prices.remove(a)\n print(f\"Removed {a}\")\n```\n\n\nThe outer loop walks `prices`. The inner loop walks the same `prices`. Removing an item shifts every later element down by one, which corrupts both loops' internal indices. The next removal might try to delete a value that's already gone, raising `ValueError`. Even when it doesn't crash, the results are wrong.\n\nThe fix is the same as before: iterate over a copy, or build a new list of the items to keep.\n\n\n```python\nprices = [10, 25, 8, 50, 14, 30]\ntarget = 18\n\nto_remove = []\nfor i, a in enumerate(prices):\n for j, b in enumerate(prices):\n if i < j and a + b == target:\n to_remove.append(a)\n to_remove.append(b)\n\nkept = [p for p in prices if p not in to_remove]\nprint(kept)\n```\n\n\nThe nested loops only read from `prices`. The mutation happens after both loops finish, on a fresh list. The `i < j` guard avoids counting each pair twice.\n\nA nested loop that reads from a list is fine. A nested loop that **mutates** the list it's reading is almost always wrong. To mutate, gather what to change in a separate collection during the loops, then apply the changes once after.\n\n---\n\n# Replacing the Inner Loop With a Set or Dict\n\nThe most useful insight about nested loops is that the inner loop is often doing a lookup. Building a `set` or `dict` once before the outer loop collapses the inner loop into a single O(1) check.\n\nA practical case: checking which wishlist items are in stock. The naive nested-loop version walks the whole stock list for every wishlist item.\n\n\n```python\nwishlist = [\"Wireless Mouse\", \"Webcam\", \"HDMI Cable\", \"Smartwatch\"]\nin_stock = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\", \"Bluetooth Speaker\"]\n\navailable = []\nfor wanted in wishlist:\n for stocked in in_stock:\n if wanted == stocked:\n available.append(wanted)\n break\n\nprint(available)\n```\n\n\nThis is O(wishlist times in_stock). Converting `in_stock` to a `set` makes the inner check O(1) and the inner loop goes away entirely:\n\n\n```python\nwishlist = [\"Wireless Mouse\", \"Webcam\", \"HDMI Cable\", \"Smartwatch\"]\nin_stock_set = {\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\", \"Bluetooth Speaker\"}\n\navailable = []\nfor wanted in wishlist:\n if wanted in in_stock_set:\n available.append(wanted)\n\nprint(available)\n```\n\n\nSame answer, single loop, much faster. Building the set is a one-time O(N) cost that pays itself back many times over with repeated lookups.\n\nA dictionary works the same way when both membership and a value tied to each key are needed. When the inner loop searches for a stock count by product name, a dict from name to count replaces it cleanly:\n\n\n```python\nwishlist = [\"Wireless Mouse\", \"Webcam\", \"HDMI Cable\"]\nstock = {\n \"Wireless Mouse\": 12,\n \"USB Cable\": 30,\n \"HDMI Cable\": 0,\n \"Bluetooth Speaker\": 7,\n}\n\nfor wanted in wishlist:\n count = stock.get(wanted, 0)\n if count > 0:\n print(f\"{wanted}: {count} in stock\")\n else:\n print(f\"{wanted}: unavailable\")\n```\n\n\n`stock.get(wanted, 0)` is one O(1) lookup. The nested-loop version would scan the entire stock list for every wishlist entry. For a thousand products, that's a thousand times less work.\n\nThe rule isn't \"never nest loops\". It's \"when nesting, ask whether one of the loops is doing a lookup that a set or dict could handle in one step\".\n\n---\n\n# Three or More Levels of Nesting\n\nLoops can nest as deep as needed, but the cost grows multiplicatively at every level. Three nested loops over collections of size N do N cubed iterations. Four levels do N to the fourth. Even N = 100 at three levels is a million iterations, which is the upper end of \"still fast enough\".\n\n\n```python\ncategories = [\"Audio\", \"Cables\"]\nproducts = [\"A\", \"B\"]\nquantities = [1, 2]\n\nfor category in categories:\n for product in products:\n for q in quantities:\n print(f\"{category}/{product} x {q}\")\n```\n\n\nEight combinations, all of them legitimate. The shape is fine when the levels represent different dimensions (category, product, quantity).\n\nDeep nesting becomes a smell when the loops are searching, filtering, or matching the same kind of data. Three nested loops looking for a triple that sums to a target value is the classic case, and there's almost always a smarter algorithm (sort first, then use two pointers) that brings it back to a single layer plus a fast lookup.\n\nThree nested loops over collections of size 1,000 do a billion iterations. Even at one nanosecond per iteration, that's a full second of work. Watch the sizes when going past two levels, and use a `set`, a `dict`, or a sort-based technique before accepting the cubed cost.\n\n---\n\n# Inner Loop Variable Survives the Outer Loop\n\nA trap that's easy to miss: the inner loop's variable is still in scope after the inner loop ends, and after the outer loop ends. It holds whatever value it was last bound to.\n\n\n```python\nfor row in [[1, 2], [3, 4]]:\n for value in row:\n pass\n\nprint(row)\nprint(value)\n```\n\n\n`row` is the last list the outer loop visited. `value` is the last element of that last row. This is the same scoping rule as a single `for` loop: variables don't get cleaned up because the loop ended.\n\nIf the inner iterable is ever empty, the inner variable might not exist at all. Using it after that raises `NameError`. This rarely matters in practice, but the variables do stick around.","pageType":"python"}

Nested Loops

Get Premium