{"title":"for Loop","description":"","content":"A `for` loop is how you tell Python \"do this work once for every item in a collection\". Iterating over a list of products, walking through the characters in a customer's email, generating a sequence of numbers, processing every order in a batch: all of it goes through the same simple syntax. This lesson covers what `for` actually does, the helpers Python gives you to make iteration cleaner (`range`, `enumerate`, `zip`), and the few sharp edges that catch beginners.\n\n---\n\n# The Basic Syntax\n\nA `for` loop has three parts: the keyword `for`, a variable that will hold each item in turn, and an iterable to pull items from.\n\n\n```python\ncart = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\"]\n\nfor item in cart:\n print(item)\n```\n\n\nPython takes the cart, hands you one element at a time, binds it to the name `item`, runs the indented block, then moves on. When the cart runs out, the loop stops.\n\nThe variable name is yours to choose. `item`, `product`, `name`, `x`, all of them work. Pick a name that says what each value means, the same way you'd name any other variable.\n\n\n```python\nprices = [29.99, 14.99, 9.99]\n\ntotal = 0\nfor price in prices:\n total += price\n\nprint(f\"Cart total: ${total:.2f}\")\n```\n\n\n`total` starts at zero, and each pass through the loop adds one price. After the loop ends, `total` holds the sum.\n\nTwo details about that `price` variable that surprise people. First, it survives after the loop: once the loop finishes, `price` still holds the last value it was bound to (`9.99` here). Python doesn't scope loop variables to the loop body the way some other languages do.\n\n\n```python\nprices = [29.99, 14.99, 9.99]\n\nfor price in prices:\n pass\n\nprint(price)\n```\n\n\nSecond, if the iterable is empty, the loop body never runs and the loop variable never gets bound at all. Trying to use it after an empty loop raises `NameError`:\n\n\n```python\nempty_cart = []\n\nfor item in empty_cart:\n print(item)\n\nprint(\"Loop finished\")\n```\n\n\nNothing was printed inside the loop. Python checked the cart, found it empty, and skipped the body entirely.\n\n---\n\n# What Counts as an Iterable\n\nAn **iterable** is any object Python knows how to walk through one item at a time. Lists are the most common, but plenty of other types qualify: tuples, strings, dictionaries, sets, files, ranges, and others. For now, the intuition is enough: if you can ask \"what's the next thing\", it's iterable.\n\nA `for` loop works the same way for every iterable type. The syntax doesn't change. Here's a string:\n\n\n```python\nemail = \"alice@shop.com\"\n\nfor character in email:\n print(character)\n```\n\n\nEach character of the string comes out in order. A string is iterable, so `for` works on it.\n\nA tuple iterates the same way. Think of a tuple as a fixed-size list you can't change:\n\n\n```python\norder_summary = (\"ORD-1023\", \"Wireless Mouse\", 29.99, \"shipped\")\n\nfor value in order_summary:\n print(value)\n```\n\n\nThe same `for x in y` shape handles all of these. Once you learn one form, you've learned them all.\n\n\n```mermaid\nflowchart LR\n START[for item in cart]:::cyan --> ASK{Iterable
has more?}:::orange\n ASK -->|Yes| BIND[Bind next value
to item]:::teal\n BIND --> BODY[Run loop body]:::green\n BODY --> ASK\n ASK -->|No| DONE[Exit loop]:::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 what every `for` loop is doing under the hood: ask the iterable for the next value, bind it to the loop variable, run the body, repeat. When the iterable says \"no more\", the loop ends.\n\n---\n\n# Looping Over a Range of Numbers\n\nSometimes you don't have a list to iterate over; you just want to do something a specific number of times, or step through a range of numbers. That's what `range()` is for.\n\n`range()` produces a sequence of integers on demand. The simplest form takes a single argument: a stop value. The sequence starts at `0` and goes up to (but not including) the stop value.\n\n\n```python\nfor i in range(5):\n print(i)\n```\n\n\nFive values: `0` through `4`. The stop value is exclusive, which is the convention you'll see throughout Python (slicing follows the same rule). It feels off at first if you're used to inclusive ranges, but it makes the math cleaner: `range(5)` produces exactly `5` values, and `range(len(items))` walks every valid index of `items`.\n\nA two-argument call lets you specify both the start and the stop:\n\n\n```python\nfor i in range(1, 6):\n print(i)\n```\n\n\n`range(1, 6)` starts at `1`, stops before `6`. Useful when you want to count from one instead of zero (for displaying order numbers to a customer, for example).\n\nA three-argument call adds a step size:\n\n\n```python\nfor i in range(0, 20, 5):\n print(i)\n```\n\n\n`range(0, 20, 5)` starts at `0`, stops before `20`, and jumps by `5` each time. The step can be negative, which lets you count down:\n\n\n```python\nfor i in range(5, 0, -1):\n print(i)\n```\n\n\n`range(5, 0, -1)` starts at `5`, stops before `0`, and decrements by `1`. With a negative step, the start should be larger than the stop, otherwise the range is empty.\n\nA small reference for the three forms:\n\n\n| Call | Produces |\n| --- | --- |\n| `range(stop)` | `0, 1, 2, ..., stop - 1` |\n| `range(start, stop)` | `start, start + 1, ..., stop - 1` |\n| `range(start, stop, step)` | `start, start + step, start + 2 * step, ...` (stops before passing `stop`) |\n\n\nA common e-commerce use is generating a sequence of order numbers or processing a fixed batch of items:\n\n\n```python\nbatch_size = 3\n\nfor order_number in range(1, batch_size + 1):\n print(f\"Processing order #{order_number}\")\n```\n\n\nNote the `+ 1` on the stop value. Because `range()` is exclusive on the stop, you write `range(1, 4)` to get `1, 2, 3`. Forgetting that is one of the most common off-by-one bugs in Python.\n\n\n> **INFO**\n>\n> **Cost:** `range()` doesn't build a list of numbers up front. It generates each value on demand. `range(1_000_000_000)` uses a tiny fixed amount of memory regardless of size, which is why it's safe to write `for i in range(huge_number)`.\n\n\nYou will sometimes see code that loops over indices using `range(len(some_list))`:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\"]\n\nfor i in range(len(products)):\n print(i, products[i])\n```\n\n\nThis works, but it's not the Pythonic way. When you want both the index and the value, the right tool is `enumerate()`, which we'll meet next. Save `range(len(...))` for the rare cases where you genuinely only need the index, like when you want to mutate the list at specific positions.\n\n---\n\n# Getting the Index With enumerate\n\nWhen you need both the position of an item and the item itself, `enumerate()` is the clean way to get both at once. It wraps any iterable and yields `(index, value)` pairs.\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\"]\n\nfor index, product in enumerate(products):\n print(f\"{index}: {product}\")\n```\n\n\nThe `for index, product in ...` part unpacks each `(index, value)` pair into two names in one step. You can call them whatever you want; `i, item` and `index, product` and `position, name` all work.\n\nBy default `enumerate()` starts counting at `0`, which lines up with list indices. If you want the count to start somewhere else, pass a `start` argument:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\"]\n\nfor line_number, product in enumerate(products, start=1):\n print(f\"Item {line_number}: {product}\")\n```\n\n\n`start=1` is the obvious choice when you're showing positions to a human (line numbers in a receipt, ranking in a search result, step numbers in a process). The underlying list still has the same indices; you're only changing what the counter prints.\n\nCompare this to the `range(len(...))` version from the previous section:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\"]\n\nfor i in range(len(products)):\n print(f\"{i}: {products[i]}\")\n```\n\n\nThe output is identical, but the `enumerate` version reads better. There's no `len()` call, no `[i]` indexing, and the intent (\"I want index and value\") is right in the syntax. If you find yourself writing `range(len(...))` and then indexing back into the list, replace it with `enumerate()`.\n\n\n> **INFO**\n>\n> **Cost:** `enumerate()` is lazy, like `range()`. It doesn't build a list of pairs up front; it produces each pair only when the loop asks for one. So `enumerate(huge_list)` is free until you start iterating.\n\n\nA small e-commerce example: numbering items in a printed receipt.\n\n\n```python\ncart = [\n (\"Wireless Mouse\", 29.99),\n (\"USB Cable\", 4.99),\n (\"HDMI Cable\", 14.99),\n]\n\nfor line_number, (name, price) in enumerate(cart, start=1):\n print(f\"{line_number}. {name:<20} ${price:.2f}\")\n```\n\n\nTwo layers of unpacking happen on the `for` line. `enumerate()` gives back `(line_number, item)` pairs, and the `item` itself is a `(name, price)` tuple from the cart. Wrapping the inner pair in parentheses tells Python to unpack it too. The result is three named values you can use directly in the format string.\n\n---\n\n# Iterating Over Two Iterables With zip\n\nWhen you have two collections that line up by position, `zip()` walks them together. It pairs the first element of each, then the second, then the third, and so on.\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\"]\nprices = [29.99, 4.99, 14.99]\n\nfor name, price in zip(products, prices):\n print(f\"{name}: ${price:.2f}\")\n```\n\n\n`zip(products, prices)` produces `(\"Wireless Mouse\", 29.99)`, `(\"USB Cable\", 4.99)`, `(\"HDMI Cable\", 14.99)`. The `for name, price in ...` unpacks each pair. No index math, no `[i]` lookups, just the two values you actually want.\n\n`zip()` accepts more than two iterables. Pass three and you get triples:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\"]\nprices = [29.99, 4.99, 14.99]\nstocks = [12, 30, 0]\n\nfor name, price, stock in zip(products, prices, stocks):\n status = \"in stock\" if stock > 0 else \"out of stock\"\n print(f\"{name}: ${price:.2f} ({status})\")\n```\n\n\nThe catch with `zip()` is what happens when the iterables have different lengths. By default, `zip()` stops at the shortest one and silently drops the extras:\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\"]\nprices = [29.99, 4.99]\n\nfor name, price in zip(products, prices):\n print(f\"{name}: ${price:.2f}\")\n```\n\n\n`HDMI Cable` is missing from the output because there's no third price. Whether that's a bug or a feature depends on the situation. If your data should always line up, you probably want to be told when it doesn't. Python 3.10 added `zip(..., strict=True)`, which raises `ValueError` if the iterables have different lengths.\n\n\n```python\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\"]\nprices = [29.99, 4.99]\n\nfor name, price in zip(products, prices, strict=True):\n print(f\"{name}: ${price:.2f}\")\n```\n\n\nFor data that's supposed to be aligned (one price per product, one stock count per product), use `strict=True`. It turns silent data loss into a loud error.\n\nThis lesson covers `zip()` at the level you need to use it in `for` loops.\n\n---\n\n# Iterating Over Dictionaries\n\nDictionaries are iterable too. The trick is knowing what you get when you iterate one. By default, `for x in some_dict` walks the **keys**, not the values, not the pairs.\n\n\n```python\nstock = {\"Wireless Mouse\": 12, \"USB Cable\": 30, \"HDMI Cable\": 0}\n\nfor product in stock:\n print(product)\n```\n\n\nIf you want the values, the keys plus values, or just the values, use the matching dict method:\n\n\n```python\nstock = {\"Wireless Mouse\": 12, \"USB Cable\": 30, \"HDMI Cable\": 0}\n\nfor product, count in stock.items():\n print(f\"{product}: {count} in stock\")\n```\n\n\n`stock.items()` yields `(key, value)` pairs that you unpack into two names. This is the most common pattern for \"do something with both the product name and its count\".\n\nFor values only, use `.values()`:\n\n\n```python\nstock = {\"Wireless Mouse\": 12, \"USB Cable\": 30, \"HDMI Cable\": 0}\n\ntotal_units = 0\nfor count in stock.values():\n total_units += count\n\nprint(f\"Total units: {total_units}\")\n```\n\n\nA small thing that matters: writing `for product in stock.keys():` is the same as `for product in stock:`. Both walk the keys. Calling `.keys()` is unnecessary in the loop header, and the shorter form is the one Python developers write. Save `.keys()` for when you need the keys view as a separate object (for set operations, for example).\n\n\n```python\nstock = {\"Wireless Mouse\": 12, \"USB Cable\": 30}\n\n# These are equivalent. Prefer the second form.\nfor product in stock.keys():\n print(product)\n\nfor product in stock:\n print(product)\n```\n\n\nTreat what you've seen here as the basics that get you through everyday loops.\n\n---\n\n# Modifying While Iterating: Don't\n\nA trap that catches every Python beginner: changing a list or dictionary while you're iterating over it. The rule is simple: don't.\n\n\n```python\nprices = [10, 25, 8, 50, 14, 30]\n\nfor price in prices:\n if price < 20:\n prices.remove(price)\n\nprint(prices)\n```\n\n\nYou probably expected `[25, 50, 30]`: every price under 20 removed. Instead `14` survived. The reason is that the loop walks the list by index internally. After it processes index 0 (`10`), it removes that element, which shifts every other element down by one. The next iteration looks at index 1, but index 1 is now `8` (which used to be at index 2). The original `8` gets processed, but the loop has now skipped over `25`. Removing items shifts the goalposts under the loop.\n\nThis bug is even worse for dictionaries: changing the size of a dict during iteration raises `RuntimeError` outright in modern Python.\n\n\n```python\nstock = {\"Wireless Mouse\": 12, \"USB Cable\": 0, \"HDMI Cable\": 0}\n\nfor product, count in stock.items():\n if count == 0:\n del stock[product]\n```\n\n\nThe fix is to iterate over a **copy**, or build a **new** collection from scratch. Both approaches work; pick the one that fits.\n\nThe copy approach uses a slice (`prices[:]`) or `list(...)` to make a snapshot the loop reads from, leaving the original safe to modify:\n\n\n```python\nprices = [10, 25, 8, 50, 14, 30]\n\nfor price in prices[:]:\n if price < 20:\n prices.remove(price)\n\nprint(prices)\n```\n\n\nNow the loop walks a separate snapshot, so removing items from `prices` doesn't change what the loop sees next.\n\nThe build-a-new-list approach skips the mutation entirely:\n\n\n```python\nprices = [10, 25, 8, 50, 14, 30]\n\nfiltered = []\nfor price in prices:\n if price >= 20:\n filtered.append(price)\n\nprices = filtered\nprint(prices)\n```\n\n\nSame result, no in-place removal, no surprises. This pattern (filter into a new list) is so common that Python has a more concise form for it called a list comprehension.\n\nFor the dictionary case, the same copy-or-rebuild trick works:\n\n\n```python\nstock = {\"Wireless Mouse\": 12, \"USB Cable\": 0, \"HDMI Cable\": 0}\n\nfor product in list(stock):\n if stock[product] == 0:\n del stock[product]\n\nprint(stock)\n```\n\n\n`list(stock)` builds a snapshot of the keys before the loop starts. The loop walks the snapshot, and `del stock[product]` modifies the original dict without breaking the iteration.\n\n\n> **INFO**\n>\n> **Cost:** Copying with `prices[:]` allocates a new list of references. For small to medium lists this is invisible. For huge lists where you only need to remove a few items, building a new list with the kept items is usually cheaper than copying everything and then mutating in place.\n\n\n---\n\n# Nested for Loops\n\nA `for` loop's body can contain another `for` loop. The inner loop runs from start to finish for every single pass of the outer loop. This is how you walk pairs, grids, or any combination of two collections.\n\nA simple e-commerce example: an order has multiple items, and you need to iterate every item in every order.\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 list of orders. For each order, the inner loop walks the items in that order. Indentation is what tells Python where each loop body starts and ends, so be careful with it.\n\nAnother common pattern: building a price grid, where every row in one collection pairs with every column in another. Suppose you want to compute the total cost for every quantity of every product.\n\n\n```python\nproducts = [\n (\"Wireless Mouse\", 29.99),\n (\"USB Cable\", 4.99),\n (\"HDMI Cable\", 14.99),\n]\nquantities = [1, 2, 5]\n\nfor name, unit_price in products:\n for quantity in quantities:\n total = unit_price * quantity\n print(f\"{name} x {quantity} = ${total:.2f}\")\n print()\n```\n\n\nThree products and three quantities give nine combinations. The empty `print()` after the inner loop adds a blank line between groups, which is purely cosmetic.\n\nNested loops are powerful, but they multiply work. Two nested loops over collections of size N do N x N iterations. Three nested loops do N x N x N. For a small product catalog, this is fine. For ten thousand products and ten thousand quantities, you're looking at a hundred million iterations, which gets slow fast.\n\n\n> **INFO**\n>\n> **Cost:** A nested loop over two collections of size N runs N x N times. If both are 1,000 items, that's a million iterations. Watch the sizes when you nest. There's almost always a better data structure (a set for membership, a dict for lookup) that turns one of the loops into an O(1) check.\n\n\nA real e-commerce case: checking which wishlist items are also in stock. The naive nested-loop version:\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 works, but it's O(wishlist x in_stock). Converting `in_stock` to a `set` makes the inner check O(1):\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 if wanted in in_stock:\n available.append(wanted)\n\nprint(available)\n```\n\n\nSame answer, but the inner loop is gone. The trade-off is the cost of building the set up front, which is a one-time O(n). For repeated lookups, that cost pays for itself many times over.\n\nThe lesson isn't \"never nest loops\". It's \"when you find yourself nesting, ask whether one of the loops is really doing a lookup that a set or dict could handle in one step\".\n\n---\n\n# Looping Without an Index Variable\n\nSometimes you want to repeat work a fixed number of times and don't actually care about the loop counter. The Python convention is to use `_` (underscore) as the variable name to signal \"I don't care about this value\":\n\n\n```python\nfor _ in range(3):\n print(\"Welcome to the shop!\")\n```\n\n\n`_` is a regular variable in Python; it's just convention, not syntax. Using it tells the reader \"this name is intentionally unused\". Linters and other tools also recognize the convention and won't warn about an unused variable.\n\nThe same convention applies inside unpacking. If you want only the value from `enumerate()` and not the index (which is rare, since at that point you'd just iterate the iterable directly), you can write:\n\n\n```python\nproducts = [\"Mouse\", \"Cable\", \"Speaker\"]\n\nfor _, name in enumerate(products):\n print(name)\n```\n\n\nThat's a contrived example because you could just loop over `products` directly. The convention is more useful with `zip()` or with tuples that have data you don't need.","pageType":"python"}

for Loop

Get Premium