{"title":"`while` Loop","description":"","content":"A `while` loop runs a block of code over and over as long as a condition stays true. You reach for it when you don't know up front how many iterations you'll need: keep retrying until something succeeds, keep prompting the customer until they type a valid value, keep draining a queue of orders until it's empty. `for` is the right tool when you already know what you're iterating over. `while` is the right tool when the stopping point depends on something the loop itself discovers.\n\n---\n\n# How `while` Works\n\nThe syntax is small. A `while` keyword, a condition, a colon, and an indented body:\n\n\n```python\nattempts = 0\n\nwhile attempts < 3:\n print(\"Attempt\", attempts + 1)\n attempts += 1\n```\n\n\nPython evaluates the condition before every iteration, including the first one. If the condition is true, the body runs. Then control jumps back to the top, the condition is re-tested, and the cycle repeats. The moment the condition is false, the loop ends and execution continues with the line after the loop body.\n\nA few details worth pinning down:\n\n- The condition is checked **before** the body runs, not after. If the condition is false on the very first check, the body never runs at all.\n- Anything truthy works as a condition, not just comparisons. `while items:` runs as long as `items` is non-empty. `while user:` runs as long as `user` isn't `None` or empty.\n- The body must do something that eventually makes the condition false. If it doesn't, the loop runs forever (more on that below).\n\nHere's the flow Python actually follows:\n\n\n```mermaid\nflowchart LR\n A[Enter loop]:::cyan --> B{Condition
true?}:::orange\n B -->|Yes| C[Run body]:::teal\n C --> D[Update state
inside body]:::teal\n D --> B\n B -->|No| E[Exit loop]:::green\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 loop has three moving parts: the condition, the body, and the state update inside the body that pushes the condition toward false. If any one of these is wrong, the loop misbehaves.\n\nA condition that's false from the very start makes the body skip entirely:\n\n\n```python\nitems_left = 0\n\nwhile items_left > 0:\n print(\"Processing item\")\n items_left -= 1\n\nprint(\"Done\")\n```\n\n\nPython checked `0 > 0`, got `False`, and went straight to the line after the loop. The body never ran. This isn't a bug, it's the natural behavior of \"check first, then run\". If you ever need a loop that runs the body **at least once** before checking, Python doesn't have a built-in `do-while`; you build it with a `while True` loop and an explicit exit, which we'll touch on later.\n\n---\n\n# When to Use `while` Instead of `for`\n\nThe `for` loop iterates over a known sequence: a list, a range, a string, anything you can step through one element at a time. The number of iterations is fixed before the loop even starts. `while` is for the opposite case, where the number of iterations depends on something that happens during the loop.\n\nHere are the situations where `while` is the natural fit:\n\n- **Polling or retrying.** Try an action, and if it fails, try again until it succeeds or you've used up your attempts.\n- **Processing a queue or stack until empty.** You don't know how many items will end up in there, and the loop itself may add more.\n- **Validating user input.** Keep asking until the customer types something that passes your checks.\n- **Consuming a stream.** Read values one at a time until you hit the end of the data.\n- **Simulations and search.** Iterate until a state condition is reached, like \"the cart total exceeds the free-shipping threshold\" or \"we've found a matching product\".\n\nHere's a quick comparison so you can pick the right tool fast:\n\n\n| Situation | Use |\n| --- | --- |\n| Iterate over a known list, string, or `range` | `for` |\n| Repeat a fixed number of times | `for` with `range(n)` |\n| Loop until a condition becomes true | `while` |\n| Drain a collection that may grow during the loop | `while` |\n| Retry until success or attempt limit | `while` |\n| Read input until a sentinel value | `while` |\n\n\nA draining example shows the difference clearly. Imagine a list of pending orders that we process one at a time:\n\n\n```python\npending_orders = [\"ORD-101\", \"ORD-102\", \"ORD-103\", \"ORD-104\"]\n\nwhile pending_orders:\n current = pending_orders.pop(0)\n print(\"Processing\", current)\n\nprint(\"Queue is empty\")\n```\n\n\nYou could have written this with a `for` loop over `pending_orders`, but the moment another part of the system can append new orders into the queue while you're processing it, `for` becomes awkward and `while` reads naturally. The condition `while pending_orders:` is true as long as the list has anything in it, and Python re-checks it after every `pop(0)`.\n\n\n> **INFO**\n>\n> **Cost:** `pending_orders.pop(0)` is O(n) because every remaining element shifts down by one slot. For a long queue, use `collections.deque` and call `popleft()`, which is O(1). The loop structure stays the same.\n\n\nA retry example is the second classic case. We want to attempt a payment up to three times before giving up:\n\n\n```python\nattempt = 0\nmax_attempts = 3\npayment_succeeded = False\n\nwhile attempt < max_attempts and not payment_succeeded:\n attempt += 1\n print(f\"Attempt {attempt} of {max_attempts}\")\n # Pretend the third attempt is the one that works.\n if attempt == 3:\n payment_succeeded = True\n\nif payment_succeeded:\n print(\"Payment confirmed\")\nelse:\n print(\"Payment failed after retries\")\n```\n\n\nTwo things make this a `while` loop and not a `for` loop. First, the stopping condition combines two things: an attempt limit and a success flag. Second, on a successful attempt we want to stop early, not keep going through the remaining tries. A `for attempt in range(max_attempts)` could be made to work, but the boolean condition reads more directly here.\n\n---\n\n# The Loop Variable Idiom\n\nMost `while` loops follow the same shape: a variable is initialized before the loop, the condition checks that variable, and the body updates it. Together, these three pieces are called the loop variable idiom.\n\n\n```python\nstock_remaining = 5\n\nwhile stock_remaining > 0:\n print(f\"Stock left: {stock_remaining}\")\n stock_remaining -= 1\n\nprint(\"Out of stock\")\n```\n\n\nThe three pieces:\n\n1. **Initialization** before the loop: `stock_remaining = 5`. This sets the starting state.\n2. **Condition** at the top: `stock_remaining > 0`. This decides whether to run the body.\n3. **Update** inside the body: `stock_remaining -= 1`. This pushes the state toward making the condition false.\n\nIf you forget any one of these, the loop won't behave the way you expect. Forget the initialization and you get a `NameError`. Forget the condition update inside the body, and you get an infinite loop. Make the update go the wrong way, and the loop also runs forever.\n\nHere's what the missing-update bug looks like:\n\n**What's wrong with this code?**\n\n\n```python\nitems_to_pack = 3\n\nwhile items_to_pack > 0:\n print(\"Packing an item\")\n # Forgot to decrement items_to_pack\n```\n\n\nThis loop never ends. Python prints `Packing an item` forever because `items_to_pack` stays at `3` and `3 > 0` is always true. You'd have to interrupt the program manually (Ctrl+C in a terminal). The fix is to update the variable inside the body:\n\n\n```python\nitems_to_pack = 3\n\nwhile items_to_pack > 0:\n print(\"Packing an item\")\n items_to_pack -= 1\n```\n\n\nThis is the single most common `while`-loop bug. Whenever you write a `while`, immediately ask yourself: \"What inside the body changes the condition?\" If you can't answer, the loop is broken.\n\n\n> **INFO**\n>\n> **Cost:** An infinite loop will pin one CPU core at 100% and produce output (or eat memory) until you stop it. Always confirm the exit path before running.\n\n\nThe loop variable doesn't have to be a counter. It can be any value the condition examines. A list, a string, an object, a flag, anything. As long as the body changes it in a way that eventually makes the condition false, the pattern works.\n\n\n```python\nremaining_review = \"Great product!!!\"\n\nwhile remaining_review.endswith(\"!\"):\n remaining_review = remaining_review[:-1]\n\nprint(remaining_review)\n```\n\n\nThe variable here is a string, the condition checks its last character, and the body trims one character off the end every iteration. After three iterations, the condition is false and the loop stops. This is just the loop variable idiom with a different shape.\n\n---\n\n# Sentinel-Driven Loops\n\nA **sentinel** is a special value that signals \"stop\". Instead of counting iterations or shrinking a collection, you keep going until you encounter the sentinel. This pattern shows up whenever you process items one at a time and the data itself tells you when you're done.\n\nA common case is processing orders until you find one that was cancelled, treating the cancellation as a stopping marker:\n\n\n```python\norders = [\n {\"id\": \"ORD-101\", \"status\": \"placed\"},\n {\"id\": \"ORD-102\", \"status\": \"placed\"},\n {\"id\": \"ORD-103\", \"status\": \"cancelled\"},\n {\"id\": \"ORD-104\", \"status\": \"placed\"},\n]\n\nindex = 0\ncurrent = orders[index]\n\nwhile current[\"status\"] != \"cancelled\":\n print(f\"Processing {current['id']}\")\n index += 1\n current = orders[index]\n\nprint(f\"Stopped at {current['id']}\")\n```\n\n\nThe sentinel here is the string `\"cancelled\"`. The loop keeps going as long as the current order's status isn't the sentinel. Notice the structure: we read the first value before the loop, and we read the next value at the bottom of the body so the condition can check it on the next iteration.\n\nThis shape is sometimes called the \"loop and a half\" because the first read happens outside the loop and the rest happen inside. It's a known awkwardness and one of the reasons Python added the walrus operator, which makes some `while`-loop patterns shorter.\n\nA sentinel can also come from the outside, like user input. Here we keep accepting product names from the customer until they type `\"done\"`:\n\n\n```python\nwishlist = []\nentry = input(\"Add a product (or 'done' to finish): \")\n\nwhile entry != \"done\":\n wishlist.append(entry)\n entry = input(\"Add a product (or 'done' to finish): \")\n\nprint(\"Wishlist:\", wishlist)\n```\n\n\nA possible run might look like:\n\nSame pattern again: read once before the loop so the condition has something to check, and read again at the end of the body to set up the next check. The sentinel `\"done\"` is part of your input contract with the user, not a value you'd ever want to store in the wishlist.\n\nThe choice of sentinel matters. It must be a value that can never legitimately appear in the real data. `\"done\"` works for product names because no real product is called \"done\". An empty string or `None` works for many cases. A negative number works for prices. If your sentinel can collide with real data, you'll silently truncate valid input.\n\n---\n\n# Validating User Input\n\nInput validation is one of the most natural places to use `while`. You don't know how many tries the customer will take, so you keep prompting until the answer is acceptable.\n\nA simple example: ask for a positive quantity to add to the cart.\n\n\n```python\nquantity = -1\n\nwhile quantity <= 0:\n raw = input(\"How many units do you want to add? \")\n if raw.isdigit():\n quantity = int(raw)\n else:\n print(\"Please enter a whole number greater than zero.\")\n\nprint(f\"Adding {quantity} units to your cart\")\n```\n\n\nA possible run:\n\nThe initial value `quantity = -1` is a small trick to make sure the loop runs at least once. Any value that fails the condition would do. The body asks for input, validates it, and only updates `quantity` to a value that passes when the input is good. As long as the input is bad, `quantity` stays at `-1` and the loop tries again.\n\nThere's a more readable alternative using `while True` and an explicit exit using `break`. For now, the version above is enough to handle most validation cases without needing those keywords.\n\nA second validation example handles email format checks:\n\n\n```python\nemail = \"\"\n\nwhile \"@\" not in email or \".\" not in email:\n email = input(\"Enter your email: \").strip()\n if \"@\" not in email or \".\" not in email:\n print(\"That doesn't look like an email. Try again.\")\n\nprint(f\"Confirming order for {email}\")\n```\n\n\nA possible run:\n\nThe condition combines two checks with `or`: the email is bad if it lacks `@` or lacks `.`. The loop keeps going until both characters are present. Real email validation is much harder, but the pattern of \"loop until input passes a check\" is the same.\n\n---\n\n# `while True` with an Explicit Exit\n\nSometimes the most natural place to decide \"we're done\" is in the middle of the body, not at the top. For those cases, you write `while True:` and exit explicitly when the right thing happens.\n\n\n```python\ncart_total = 0\nitem_price = 12.50\n\nwhile True:\n cart_total += item_price\n print(f\"Total so far: ${cart_total:.2f}\")\n if cart_total >= 50:\n print(\"Free shipping unlocked\")\n # We need a way out of the loop here.\n break\n```\n\n\n`while True` makes the condition trivially true forever. The actual stopping logic lives inside the body, with a keyword that breaks out of the loop.\n\nThe reason this pattern is sometimes preferred over a regular `while condition:` is that it avoids the loop-and-a-half awkwardness from the sentinel section. You don't have to read a value before the loop and again inside the body. You read once, decide once, and exit cleanly when the condition is met.\n\n`while True` is also how you'd build a `do-while` loop in Python. There's no built-in keyword for \"run the body once before checking\", but the same effect is easy to get with this pattern.\n\nA summary of when each form makes sense:\n\n\n| Form | Best for |\n| --- | --- |\n| `while condition:` | Standard case where the test naturally lives at the top |\n| `while True:` with an exit | The decision to stop happens in the middle of the body |\n| `while collection:` | Drain a list, set, or dict until empty |\n| `while flag:` | Stop when a boolean signal flips |\n\n\n---\n\n# Common Mistakes\n\nMost `while`-loop bugs fall into a few familiar shapes. Recognizing them early saves a lot of debugging time.\n\n**Forgetting to update the loop variable.** Already covered above, but worth repeating because it's the number-one mistake. Every `while` loop needs something in the body that changes the condition.\n\n\n```python\nattempts = 0\n\nwhile attempts < 3:\n print(\"Trying...\")\n # Forgot: attempts += 1\n```\n\n\nThis runs forever. The fix is one line.\n\n**Off-by-one errors.** Choosing `<` versus `<=` decides whether the boundary value is included. Both are correct in different situations, so think about what you actually want.\n\n\n```python\nn = 0\n\nwhile n < 5:\n print(n)\n n += 1\n```\n\n\nThis prints `0` through `4`, five values. If you wanted `1` through `5`, you'd write `n = 1` and `while n <= 5`. The classic mistake is mixing them up and getting either one too few or one too many iterations.\n\n**Using `while` where `for` is cleaner.** A loop with a counter from `0` to `n-1` is almost always clearer as a `for` loop:\n\n\n```python\n# Awkward\ni = 0\nproducts = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\"]\nwhile i < len(products):\n print(products[i])\n i += 1\n\n# Better\nfor product in products:\n print(product)\n```\n\n\nBoth produce the same output, but the `for` version doesn't need an index variable, doesn't need a manual increment, and can't have an off-by-one error. Reach for `while` when there's a real reason: an unknown number of iterations, a non-numeric stopping condition, a mutating collection. Otherwise prefer `for`.\n\n**Conditions that depend on side effects you didn't expect.** If the body modifies something that the condition reads, it's easy to get a surprise.\n\n\n```python\ncart = [\"Wireless Mouse\", \"USB Cable\", \"HDMI Cable\"]\n\nwhile len(cart) > 1:\n cart.append(\"Bonus Sticker\")\n print(cart)\n```\n\n\nThis loop adds a sticker forever because every iteration grows the cart. The condition `len(cart) > 1` was meant to say \"shrink until almost empty\", but the body grows the list instead. Always trace through the first few iterations on paper to make sure the body actually pushes the condition toward false, not away from it.\n\n**Comparing floats with equality.** Floats accumulate small rounding errors, so a `while x == 0.5:` style check can miss the target completely. Use `<`, `>`, or a tolerance comparison instead:\n\n\n```python\ntotal = 0.0\n\nwhile total < 1.0:\n total += 0.1\n print(total)\n```\n\n\nThe loop runs one more time than you might expect because of how floating-point addition rounds. If you want exactly ten iterations, count with an integer (`while step < 10:`) and compute the float from the counter inside the body. The lesson here is to keep float arithmetic out of loop conditions when integer math would do.","pageType":"python"}

`while` Loop

Get Premium