How to use 'while True' in Python

Learn how to use while True in Python. Discover different methods, tips, real-world applications, and how to debug common errors.

Published on:

Tue

Mar 3, 2026

Updated on:

Fri

Mar 6, 2026

The Replit Team

ON THIS PAGE

Example H2

The while True statement in Python creates an infinite loop, a fundamental tool for many programs. This structure allows code to run continuously until a specific condition is met.

In this article, you'll explore techniques to control these loops and see real-world applications. You'll also get practical tips for safe implementation and find clear advice to debug common problems you might face.

Using `while True` loops in Python

while True: user_input = input("Enter 'quit' to exit: ") if user_input.lower() == 'quit': break print(f"You entered: {user_input}")--OUTPUT--Enter 'quit' to exit: hello You entered: hello Enter 'quit' to exit: python You entered: python Enter 'quit' to exit: quit

This code demonstrates a classic use for a while True loop: creating a persistent user prompt. The loop is designed to run indefinitely, making it ideal for applications that need to repeatedly wait for and process user commands without a predetermined number of iterations.

Control is managed by an explicit exit condition. The if statement checks the user's input on each cycle. When the input matches 'quit', the break statement is executed, providing a clean and predictable way to terminate the otherwise infinite loop.

Common loop control techniques

While break provides a simple exit, you can achieve finer control by combining it with continue to validate user input or build complex interactive menus.

Using `break` and `continue` statements

counter = 0 while True: counter += 1 if counter % 2 == 0: # Skip even numbers continue print(counter) if counter >= 5: break--OUTPUT--1 3 5

This example shows how continue and break work together to control loop flow. The continue statement skips the rest of the current loop iteration and moves to the next one, while break exits the loop entirely.

The condition if counter % 2 == 0 uses the modulo operator (%) to check for even numbers. When true, continue prevents the number from being printed.
The loop terminates when counter is greater than or equal to 5, triggering the break statement.

Handling user input with validation

while True: try: number = int(input("Enter a number: ")) result = 100 / number print(f"100 divided by {number} is {result}") break except ValueError: print("Please enter a valid number.") except ZeroDivisionError: print("Cannot divide by zero.")--OUTPUT--Enter a number: abc Please enter a valid number. Enter a number: 0 Cannot divide by zero. Enter a number: 25 100 divided by 25 is 4.0

This loop demonstrates robust input validation using a try...except block. It continuously prompts for a number until valid input is provided, only exiting via the break statement when the entire try block executes without errors.

If you enter non-numeric text, a ValueError is caught, and the loop continues.
Entering 0 triggers a ZeroDivisionError, which is also handled, preventing a crash.

This structure ensures your program gracefully handles bad input instead of terminating unexpectedly.

Creating interactive menus

while True: print("\nMenu:") print("1. Say Hello") print("2. Count to 3") print("3. Exit") choice = input("Enter your choice (1-3): ") if choice == '1': print("Hello, World!") elif choice == '2': for i in range(1, 4): print(i) elif choice == '3': print("Goodbye!") break else: print("Invalid choice, try again.")--OUTPUT--Menu: 1. Say Hello 2. Count to 3 3. Exit Enter your choice (1-3): 1 Hello, World! Menu: 1. Say Hello 2. Count to 3 3. Exit Enter your choice (1-3): 3 Goodbye!

A while True loop is perfect for building interactive menus that need to run continuously. The loop repeatedly displays a set of options and waits for user input, making it a common pattern for command-line applications.

An if/elif/else structure evaluates the user's choice on each iteration.
The loop only terminates when the user selects the exit option, which executes the break statement.
For any other input, the program performs an action or handles an invalid choice before cycling back to display the menu again.

Advanced loop techniques

Building on these control techniques, you can leverage infinite loops for more advanced applications like performance benchmarking, data streaming, and concurrent programming.

Implementing timers and benchmarks

import time start_time = time.time() counter = 0 while True: counter += 1 if counter >= 1000000: break print(f"Counted to 1 million in {time.time() - start_time:.4f} seconds")--OUTPUT--Counted to 1 million in 0.0612 seconds

This code benchmarks how fast your system can count to one million. It works by recording the start time with time.time() right before the loop begins.

The while True loop runs continuously, incrementing a counter on each pass.
Once the counter reaches one million, the break statement exits the loop.

After the loop terminates, the code calculates the total elapsed time by subtracting the start time from the end time, giving you a simple performance metric.

Using `while True` with generators

def infinite_sequence(): num = 0 while True: yield num num += 1 gen = infinite_sequence() for _ in range(5): print(next(gen))--OUTPUT--0 1 2 3 4

This example shows how a while True loop inside a generator function, infinite_sequence(), can produce an endless stream of values without consuming infinite memory. The yield keyword is the key here. It pauses the function, returns the current value of num, and saves its state. When you call next(gen), the function resumes right where it left off.

The while True loop allows the generator to run indefinitely, ready to produce the next number on demand.
The external for loop controls consumption, pulling just five values before stopping. This prevents an infinite loop in the main program.

Threading with controllable infinite loops

import threading import time stop_flag = threading.Event() def background_task(): while not stop_flag.is_set(): print("Working...", end="\r") time.sleep(0.5) print("Background task stopped.") thread = threading.Thread(target=background_task) thread.start() time.sleep(2) # Let it run for 2 seconds stop_flag.set() thread.join()--OUTPUT--Working... Background task stopped.

This pattern is ideal for running tasks in the background without freezing your main program. The loop inside the background_task function is controlled by a threading.Event, which is a safe way to communicate between threads.

The loop continues as long as stop_flag.is_set() returns false.
Your main thread starts the task, waits for two seconds, and then calls stop_flag.set(). This signals the background loop to stop.
Finally, thread.join() makes the main thread wait for the background task to exit gracefully before the program ends.

Move faster with Replit

Replit is an AI-powered development platform that transforms natural language into working applications. Describe what you want to build, and Replit Agent creates it—complete with databases, APIs, and deployment.

For the while True techniques we've explored, Replit Agent can turn them into production tools:

Build an interactive command-line utility that provides a persistent menu for managing system tasks.
Deploy a background service that continuously monitors a website for changes and sends notifications.
Create a robust data entry application that uses a try...except block to validate input until a valid entry is submitted.

Describe your app idea, and Replit Agent will write, test, and deploy the code for you, all in your browser.

Common errors and challenges

While powerful, infinite loops introduce unique challenges that can cause bugs or slow your program down if you're not careful.

Preventing index errors with proper bounds checking in while True loops
When iterating through a collection like a list, an IndexError can occur if your loop tries to access an index that is out of bounds. Always confirm the collection's size before accessing an element, especially if its length might change during execution. A simple if check is all you need to prevent the program from crashing.
Reducing CPU usage with time.sleep() in polling loops
Polling loops that run without a pause can easily max out a CPU core as the program continuously checks a condition. You can fix this by calling time.sleep() inside the loop. This simple function introduces a small delay, freeing up system resources for other tasks and making your application much more efficient.
Ensuring loop variables are properly updated in while True loops
An infinite loop can become truly stuck if the variables controlling its exit condition are never updated. For example, if your break statement relies on a counter that you forget to increment, the loop will never terminate. Always double-check that your loop's logic guarantees progress toward the exit condition on each iteration.

Preventing index errors with proper bounds checking in `while True` loops

An IndexError is a common pitfall when using a while True loop to process a list. It occurs if your loop tries to access an index that doesn't exist, often because the exit condition isn't met before you've run out of items.

The sum_until_negative function below highlights this risk. It's designed to add numbers until it hits a negative one, but it will crash if the list only contains positive values because the loop will run past the final element.

def sum_until_negative(numbers): total = 0 i = 0 while True: if numbers[i] < 0: # Will cause IndexError if no negative number exists break total += numbers[i] i += 1 return total

The index i increments on every pass. If the list contains no negative numbers, the loop will eventually try to access an index that doesn't exist, causing an IndexError. The following code demonstrates how to prevent this crash.

def sum_until_negative(numbers): total = 0 i = 0 while i < len(numbers): # Add bounds check if numbers[i] < 0: break total += numbers[i] i += 1 return total

The fix replaces the infinite loop with a conditional one: while i < len(numbers). This bounds check ensures the loop terminates if it reaches the end of the list, preventing the index i from going out of range. It’s a simple but crucial safeguard. You should always add a similar check when manually incrementing an index to access items in a collection, especially if your loop’s exit condition might not be met.

Reducing CPU usage with `time.sleep()` in polling loops

A polling loop that constantly checks for a condition without pausing can easily consume an entire CPU core. It's a common problem where the loop runs as fast as possible, leaving no room for other processes and slowing your system down.

The wait_for_file function below demonstrates this issue. It continuously checks for a file's existence, maxing out the CPU while it waits.

import os import time def wait_for_file(filename, timeout=30): start_time = time.time() while True: if os.path.exists(filename): return True if time.time() - start_time > timeout: return False # CPU is running at 100% while checking

The while True loop in wait_for_file runs without any pause, forcing the CPU to check the condition as fast as it can. This is highly inefficient. See how a small modification makes the function much more resource-friendly.

The fix is adding a time.sleep(0.5) call inside the loop. This function pauses execution for half a second on each pass, preventing the loop from running continuously and consuming all available CPU resources. By yielding execution time, your program becomes much more efficient. It's a crucial technique whenever your loop is polling for an external event, like a file appearing or a network response, as it keeps your application from bogging down the system.

Ensuring loop variables are properly updated in `while True` loops

A while True loop can get stuck if the variable controlling its exit condition is never updated. This oversight creates a true infinite loop that never terminates, causing your program to hang because the logic to reach the break statement is flawed.

The find_all_occurrences function below demonstrates this problem. It's designed to find every instance of a character but gets trapped because the starting search position is never updated, preventing it from moving through the text and finishing its search.

def find_all_occurrences(text, char): positions = [] i = 0 while True: pos = text.find(char, i) if pos == -1: break positions.append(pos) # Forgot to update i, causing infinite loop return positions

Because the search index i is never incremented, text.find() repeatedly finds the character at the same spot. The loop never reaches its break condition and gets stuck appending the same position. The corrected code below resolves this.

def find_all_occurrences(text, char): positions = [] i = 0 while True: pos = text.find(char, i) if pos == -1: break positions.append(pos) i = pos + 1 # Move past the found character return positions

The fix, i = pos + 1, is crucial because it advances the search index past the character just found. This update ensures the loop makes progress on each iteration, eventually allowing text.find() to return -1 and trigger the break. You should always watch for this issue when manually managing state—like an index or counter—inside a while True loop to ensure your exit condition is always reachable.

Real-world applications

With the common pitfalls addressed, you can confidently use while True to build practical tools for tasks like file monitoring and network retries.

File monitoring for changes with `while True`

You can create a simple file monitoring system by using a while True loop to periodically check a file's modification time with os.path.getmtime().

import os import time file_path = "data.txt" last_modified = os.path.getmtime(file_path) if os.path.exists(file_path) else 0 while True: if os.path.exists(file_path): current_modified = os.path.getmtime(file_path) if current_modified > last_modified: print(f"File changed at {time.ctime(current_modified)}") last_modified = current_modified time.sleep(1) # This would run forever in a real application # Adding a counter for demonstration break

This script creates a simple file monitor that watches data.txt for any changes. It begins by storing the file's last modification time, defaulting to 0 if the file doesn't exist yet. The loop then runs continuously to check for updates.

Inside the loop, os.path.getmtime() fetches the file's current modification timestamp.
If this timestamp is newer than the last one recorded, it prints a notification and updates the stored time.
The time.sleep(1) call pauses execution for one second, preventing the loop from consuming excessive CPU resources.

Implementing retry logic with exponential backoff

A while True loop provides a straightforward way to implement retry logic with exponential backoff, making your application more resilient to temporary issues like network errors.

import time import random def request_with_retry(url): max_retries = 5 retry_count = 0 base_delay = 1 # seconds while True: try: print(f"Attempting request to {url}...") # Simulate network request with potential failure if random.random() < 0.7: # 70% chance of failure raise ConnectionError("Network error") print("Request successful!") return "Response data" except ConnectionError as e: retry_count += 1 if retry_count > max_retries: print(f"Max retries reached. Giving up.") raise delay = base_delay * (2 ** (retry_count - 1)) + random.uniform(0, 1) print(f"Retry {retry_count}/{max_retries} after {delay:.2f}s") time.sleep(delay) # Example usage (would normally throw an exception eventually) try: request_with_retry("https://api.example.com/data") except ConnectionError: print("Failed to connect after multiple attempts")

This request_with_retry function demonstrates how to handle temporary failures, like a flaky network connection. It uses a while True loop to keep trying a request until it succeeds or runs out of attempts. This approach makes your code more robust when interacting with external services.

If a ConnectionError is caught, the loop waits before trying again instead of crashing.
The delay between retries increases after each failed attempt, which helps avoid overwhelming a service that might be temporarily down.
It gives up and re-raises the error only after max_retries is reached, preventing a truly infinite loop.

Get started with Replit

Turn these concepts into a real tool. Describe what you want to build, like “a command-line utility that monitors a file for changes” or “an interactive menu-based calculator that handles invalid input.”

Replit Agent writes the code, tests for errors, and deploys your app from a simple description. It handles the setup, letting you focus on your idea. Start building with Replit.

Get started free

Create and deploy websites, automations, internal tools, data pipelines and more in any programming language without setup, downloads or extra tools. All in a single cloud workspace with AI built in.

Get started free

Get started for free

Create & deploy websites, automations, internal tools, data pipelines and more in any programming language without setup, downloads or extra tools. All in a single cloud workspace with AI built in.

Get started for free