A Python while loop keeps repeating as long as a condition stays true. Learn the three patterns you will actually use (counting, sentinel, and infinite loops) with tested examples, break, the else clause, and the mistake that traps everyone.

“Controlling complexity is the essence of computer programming.”

Brian Kernighan, Software Tools

Last Updated: July 2026 | Tested on: Python 3.14.6 | Difficulty: Beginner | Reading Time: 15 minutes

Think about boiling milk on the stove. You stand there and stir, and you keep stirring as long as it has not boiled over. The moment it rises to the top, you stop. You are not counting stirs. You are watching a condition. A Python while loop is that exact idea written in code: keep doing the thing while the condition stays True, and stop the instant it turns False.

Conditionals (from the if/elif/else tutorial) let your code pick a path once. A loop lets it repeat. The while loop is the simpler of Python’s two loops, and the one that can run forever if you forget to nudge the condition along. Here is the good news: there are only three patterns you will ever really need. Counting, sentinel, and infinite. Learn those three and you have covered almost every while loop you will write in real code.

The Counting Loop

The most basic pattern: count from A to B. It works like doing pushups at the gym. You decide on 5 reps, count each one out loud, and stop the moment you cross your target. The counter variable is you counting, and the condition is the target you set before starting.

Tip: click the diagram to open it full screen, then use the zoom and pan controls for a closer look.

The flowchart shows the rhythm of a Python while loop: check the condition, run the body if it is true, then loop back and check again. When the condition finally turns false, the loop exits. The arrow that loops back is the one to watch. That is where infinite loops are born, because if nothing inside the body changes the condition, the answer is always true and the loop never stops. Every example below follows the same three beats, so keep the “check, run, update” rhythm in your head.

📄 counting.py: a while loop driven by a counter variable

# Count from 1 to 5
count = 1
while count <= 5:
    print(f"Count: {count}")
    count += 1    # critical: without this line, the loop runs forever

print(f"Loop ended. count is now {count}")

# Countdown
countdown = 3
while countdown > 0:
    print(f"T-minus {countdown}...")
    countdown -= 1
print("Launch! 🚀")

▶ Output

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5
Loop ended. count is now 6
T-minus 3...
T-minus 2...
T-minus 1...
Launch! 🚀

What happened here: Before every pass, Python checks count <= 5. While that is true, it prints and then bumps count up by one. When count reaches 6, the check is False, so the loop quietly stops. Look at the last line of output: count is 6 after the loop, not 5. The counter always takes one extra step past the finish line, because it has to fail the test to exit. That off-by-one feeling trips up a lot of beginners, so keep it in mind. For plain counting like this, a for loop with range() is usually the cleaner choice, and that is exactly what the next post covers.

The Sentinel Loop

Sometimes you have no idea how many times the loop will run. You just know what should make it stop. That stop value has a name: a sentinel. Picture a security guard at a gate waving people through one by one. He keeps waving until he sees a particular badge, and then he closes the gate. Your loop keeps reading input until it sees the special “stop” value, like the user typing done or quit.

Python even grew a shortcut for this exact read-and-check pattern, the walrus operator, which reads the value and tests it in a single line. In the example below, someone is building a guest list and enters the names of three friends, Rahul, Anvi, and Aviraj, before typing done.

📄 sentinel.py: keep reading names until the user types “done”

# Process names until user types 'done'
names = []
name = input("Enter a name (or 'done' to finish): ")

while name.lower() != "done":
    names.append(name)
    name = input("Enter a name (or 'done' to finish): ")

print(f"\nCollected {len(names)} names: {names}")

▶ Output (user types “Rahul”, “Anvi”, “Aviraj”, “done”)

Enter a name (or 'done' to finish): Rahul
Enter a name (or 'done' to finish): Anvi
Enter a name (or 'done' to finish): Aviraj
Enter a name (or 'done' to finish): done

Collected 3 names: ['Rahul', 'Anvi', 'Aviraj']

What happened here: Notice the trick. We call input() once before the loop to grab the first name, then call it again at the bottom of the loop body to grab the next one. This is the read-ahead pattern, and it exists for a reason: the while condition needs something to check on the very first pass, so we have to read a value before we can test it. We lowercase the input with name.lower() so that Done, DONE, and done all end the loop. The sentinel value itself never gets added to the list, because the moment we see it, the condition fails and we skip the append.

The Infinite Loop Pattern

Here the condition is literally while True, which never turns false on its own, so the loop runs forever. That sounds like a bug, but it is on purpose. You break out of it from the inside with break. Think of a ceiling fan with a pull chain: it spins and spins until you reach up and yank the chain. The break is your pull chain. This is the cleanest pattern for menus and input validation, because the decision to keep going or stop lives right where you read the user’s choice. In the demo below, imagine a user named Aditi typing her way through a tiny text menu.

📄 infinite_loop.py: while True with break is a feature, not a bug

# Menu-driven program
while True:
    print("\n--- Menu ---")
    print("1. Say hello")
    print("2. Show date")
    print("3. Quit")

    choice = input("Pick an option: ").strip()

    if choice == "1":
        print("Hello, Aditi!")
    elif choice == "2":
        from datetime import date
        print(f"Today: {date.today()}")
    elif choice == "3":
        print("Goodbye!")
        break
    else:
        print("Invalid option. Try 1, 2, or 3.")

▶ Output (user types “1”, “5”, “3”)

--- Menu ---
1. Say hello
2. Show date
3. Quit
Pick an option: 1
Hello, Aditi!

--- Menu ---
1. Say hello
2. Show date
3. Quit
Pick an option: 5
Invalid option. Try 1, 2, or 3.

--- Menu ---
1. Say hello
2. Show date
3. Quit
Pick an option: 3
Goodbye!

What happened here: The menu redraws on every pass because the whole thing lives inside while True. Type 1 and it greets Aditi, then loops back to show the menu again. Type 5 and the else branch scolds you, then loops back. Only when you type 3 does break fire, which jumps straight out of the loop and ends the program. Without that break, there would be no way out, and you really would be stuck pressing Ctrl+C. That is the deal with while True: the loop gives you forever, and break is the one exit you control.

while-else: The Misunderstood Clause

Here is a feature most Python developers never even notice: a while loop can have an else block. It does not mean “otherwise” the way it does in an if statement. It runs only when the loop finishes on its own terms, that is, when the condition turned false and no break ever fired. The clearest way to read it is: else means “the loop ran all the way through without breaking out early.” Think of searching every pocket for your keys: only after checking the last pocket and finding nothing do you announce “the keys are lost.” Find them in pocket two and you stop searching, no announcement needed.

That is exactly what else is for: search-and-report, where you want to do something special when you searched the whole thing and found nothing.

📄 while_else.py: else runs only when the loop finishes without a break

# Search for a value
target = 7
numbers = [2, 4, 6, 8, 10]
i = 0

while i < len(numbers):
    if numbers[i] == target:
        print(f"Found {target} at index {i}")
        break
    i += 1
else:
    print(f"{target} not found in list")

# Try again with a value that exists
target = 6
i = 0
while i < len(numbers):
    if numbers[i] == target:
        print(f"Found {target} at index {i}")
        break
    i += 1
else:
    print(f"{target} not found in list")

▶ Output

7 not found in list
Found 6 at index 2

What happened here: The first search looks for 7. It walks the whole list, never finds it, the condition i < len(numbers) finally fails, and because no break ever ran, the else block prints “7 not found in list”. The second search looks for 6. It finds it at index 2 and hits break, which skips the else entirely. That is the whole point: break means “I found what I wanted, do not run the not-found message.” If you have ever written a found-flag like found = False and checked it after the loop, while-else does that job for you with no extra variable.

Accumulator Pattern

An accumulator is a variable that grows as the loop runs, collecting a result piece by piece. It is exactly like dropping coins into a piggy bank: the bank starts empty, and every coin you add updates the total. You set a starting value before the loop (0 for adding, 1 for multiplying), then update it on every pass. By the time the loop ends, the variable holds the finished answer.

📄 accumulator.py: building up a running total across iterations

# Sum numbers from 1 to 100
total = 0
n = 1
while n <= 100:
    total += n
    n += 1
print(f"Sum of 1 to 100: {total}")

# Factorial
number = 5
factorial = 1
i = 1
while i <= number:
    factorial *= i
    i += 1
print(f"{number}! = {factorial}")

▶ Output

Sum of 1 to 100: 5050
5! = 120

What happened here: The first loop starts total at 0 and adds 1, then 2, then 3, all the way to 100, landing on the famous answer 5050. The second loop starts factorial at 1 (not 0, because anything times 0 stays 0) and multiplies by 1, 2, 3, 4, 5 to get 120. The starting value is the part beginners get wrong most often. Use 0 when you are adding and 1 when you are multiplying, otherwise your running total starts in the wrong place and the final answer is off.

The Catch: Forgetting to Update

This is the one mistake that bites every single person who learns while loops. It is like waiting for a kettle you never switched on: the water is never going to boil, so you will stand there forever. If nothing inside the body changes the variable in the condition, the condition is true forever, and so is the loop. The terminal just sits there spitting out the same line until you stop it. Do not run the broken version below expecting it to end on its own. If you do run it, press Ctrl+C to break out.

🚫 Infinite loop: the counter never changes

count = 1
while count <= 5:
    print(count)
    # forgot count += 1, so this prints 1 forever!
    # Press Ctrl+C to stop

✅ Fixed

count = 1
while count <= 5:
    print(count)
    count += 1   # always update the variable in the condition

What happened here: One line is the whole difference. The fix adds count += 1 inside the loop, so the counter climbs toward 6 and the condition eventually fails. The habit to build is simple: every time you write a while with a condition, immediately ask yourself “what inside this loop moves the condition closer to false?” If you cannot point to that line, you are about to write an infinite loop.

When You Will Use This

• Input validation: The while True + break pattern from the user input tutorial
• Menu systems: Any interactive program with “choose an option” prompts
• Polling: Waiting for a network response, file change, or sensor reading
• Game loops: The beating heart of every game, running frame after frame until the player quits or loses

Common Mistakes

Mistake 1: Off-by-one with the counter

🚫 Prints 1 to 4 instead of 1 to 5

i = 1
while i < 5:     # should be <= 5
    print(i)
    i += 1

✅ Prints 1 to 5

i = 1
while i <= 5:    # <= includes the last number you want
    print(i)
    i += 1

Why: The word “from 1 to 5” includes 5, but < stops one short. When you want the boundary number itself, use <=. This is the single most common while loop bug, so read your condition out loud and ask whether the last value should make it in.

Mistake 2: A condition that can never become False

🚫 Infinite loop: the counter moves the wrong way

x = 10
while x > 0:
    print(x)
    x += 1    # going the wrong direction!

Why: The condition wants x to reach 0 or below, but x += 1 pushes it up to 11, 12, 13, and away from the exit forever. Always check that your update moves the variable toward the value that ends the loop, not away from it. Counting down? Use -=. Counting up to a ceiling? Make sure the ceiling is above where you start.

Conclusion

Three patterns cover nearly every Python while loop you will ever write: counting (drive it with a counter variable), sentinel (loop until a stop value shows up), and infinite (while True with a break as your exit). The else clause runs only when the loop finishes without breaking, which is handy for search-and-not-found situations. And the one rule that saves you every time: make sure something inside the loop pushes the condition toward False, or you will be reaching for Ctrl+C.

Next up: For Loops. range(), enumerate(), zip(), and the loop type you’ll use 90% of the time. And if you want to jump around or see everything this free series covers, head to the Python + AI/ML tutorial series home.

Practice Exercises

1. Exercise 1: Print odd numbers from 1 to 20 with a while loop.
2. Exercise 2: Create a number guessing game with too high/too low hints.
3. Exercise 3: Build an ATM simulator with deposits, withdrawals, and overdraft protection.

Frequently Asked Questions

Interview Questions on Python While Loops

If you can walk through these without peeking, you are ready for this topic in an interview.

Q: A while loop’s condition is False the very first time Python checks it. How many times does the body run?

Zero. A while loop checks its condition before every pass, including the first one, so if the check fails immediately the body is skipped entirely. Python has no do-while loop that guarantees at least one run; if you need that, use while True with the check and a break at the bottom of the body.

Q: You run count = 1 and then while count <= 5: print(count); count += 1. After the loop, what is count?

It is 6, not 5. The body runs while count is 1 through 5, and only when count becomes 6 does the check fail and the loop exit. The counter always ends one step past the last value that passed the condition, because it has to fail the test to get out. This off-by-one detail is a classic interview trap.

Q: Your teammate’s script has been printing the same log line for ten minutes and the Central Processing Unit (CPU) is pinned at 100 percent. What do you check first?

Open the while loop and find the line inside the body that is supposed to change the condition. In most cases nothing updates the condition variable, or the break sits behind an if that never fires, so the condition stays True forever. Also confirm the update moves the variable toward the exit and not away from it, like writing x += 1 when the loop needs x to reach 0.

Q: You add a continue statement to a while loop to skip some values, and now the program hangs. Why?

continue jumps straight back to the condition check and skips everything after it in the body. If your counter update, say i += 1, sits below the continue, it gets skipped too, so the variable never changes and the loop spins on the same value forever. The fix is to update the counter before the continue, or use a plain if block instead of skipping.

Q: How would you keep asking a user for input until they type a valid number?

Use the while True plus break pattern. Loop forever, try converting the input with int() inside a try/except, break on success, and print a short message on ValueError so the loop asks again. This is cleaner than a condition-based loop because the decision to stop lives right next to the validation.

Q: Your script uses while True to poll a server until a job finishes, and the ops team complains you are hammering their Application Programming Interface (API). What is missing?

Two things: a pause and an exit plan. Add time.sleep() inside the loop so you check every few seconds instead of thousands of times per second, and add a maximum attempt count or a timeout so the loop cannot run forever if the job never finishes. Every polling loop needs both a delay and an escape hatch.

Go deeper: the official Python documentation covers every edge case of this topic.

Related Posts

Previous: Python: Ternary Operator & Short-Circuit Evaluation

Next: Python: For Loops with range(), enumerate(), zip()

Series Home: Python + AI/ML Tutorial Series