Python Infinite Loop: Control and Safe Usage
python infinite loop: Learn how to create and control infinite loops in Python—when they're intentional, how to exit safely, and how to avoid accidental infinite loops.

An infinite loop in Python is a loop that never reaches a terminating condition. In most code that is a bug, but in long-running programs such as servers, daemons, and event listeners, an intentional infinite loop in Python is the core of the design. The same while True: syntax is used for both cases, and the difference is entirely in how the loop is controlled.
The while True Pattern for Intentional Loops
An intentional infinite loop in Python is almost always written with while True: followed by a body that performs work and then yields control. The condition is a constant, so the loop never ends on its own.
while True:
message = queue.get()
handle_message(message)This loop is typical of a worker process: it blocks on queue.get() until a message arrives, processes it, then blocks again. Because the call blocks the thread, it does not consume CPU while waiting. The same structure appears in network servers, where the loop accepts a connection, handles it, and returns to wait for the next one.
The key property of an intentional infinite loop is that each iteration either makes progress or blocks. A loop that neither blocks nor makes progress is usually a bug.
Exiting with break and return
An intentional infinite loop needs a controlled way out. The break statement exits the innermost loop immediately, skipping the rest of the body.
while True:
command = input("> ")
if command == "quit":
break
execute(command)Here break ends the loop when the user types quit. Execution continues at the first statement after the loop. If the loop is inside a function, return exits the function entirely, which also terminates the loop. Choose break when the loop should resume after the exit condition; choose return when the loop is the last meaningful work of the function.
A common pattern is a loop with multiple exit conditions. Each condition can be a separate break, or the conditions can be combined into a single check. Separate break statements are easier to read when each condition has a distinct reason.
Avoiding Accidental Infinite Loops
Most accidental infinite loops come from a condition that never becomes false. The classic case is a while loop whose body fails to update the variable that the condition depends on.
count = 0
while count < 10:
print(count)
# count += 1 # missing incrementBecause count never changes, the condition count < 10 stays true forever. The fix is to update the variable in every iteration. The same failure appears when the wrong variable is updated, or when the update is placed after a continue that skips it.
count = 0
while count < 10:
if count == 5:
continue
count += 1When count reaches 5, continue jumps back to the condition without incrementing, so the loop never advances past 5. This is a subtle variant of the same problem: the loop body does not guarantee progress on every path.
A related mistake is a while condition that depends on a variable that is never updated. If the condition is while status != "done" and nothing in the loop ever sets status, the loop runs forever.
for Loops Over Non-Terminating Iterators
A for loop normally terminates when its iterator is exhausted. An iterator that never raises StopIteration produces an infinite loop, even though the code looks finite.
import itertools
for item in itertools.cycle([1, 2, 3]):
print(item)itertools.cycle repeats the sequence indefinitely, so this loop never ends. The same happens with a generator that contains while True: internally. A for loop over such a generator is an infinite loop in disguise.
This is not always a bug. A generator that yields an infinite sequence can be consumed with break once a condition is met:
def integers():
n = 0
while True:
yield n
n += 1
for value in integers():
if value > 10:
break
print(value)This shows a finite use of an infinite generator. The for loop is controlled by break, not by iterator exhaustion.
Runtime Cost and CPU Usage
An infinite loop that does no blocking work will consume one CPU core at full speed. A tight loop with no I/O and no sleep can pin a core, raise power consumption, and slow down other processes on the same machine.
while True:
pass # burns a CPU coreThe pass body does nothing, so the loop spins as fast as the interpreter allows. If the loop is waiting for a condition that changes in another thread, add a small sleep to yield the CPU:
import time
while not ready():
time.sleep(0.01)A sleep interval of a few milliseconds is usually enough for a polling loop. The tradeoff is latency: a longer sleep means slower detection of the condition. Choose the interval based on how quickly the loop must react.
For loops that use blocking calls, such as queue.get() or socket.accept(), no sleep is needed because the blocking call already yields control.
Graceful Shutdown with Exceptions and Signals
An intentional infinite loop should be interruptible. When the user presses Ctrl+C, Python raises KeyboardInterrupt in the main thread. Catching it lets the program run cleanup code before exiting.
try:
while True:
process_next_item()
except KeyboardInterrupt:
save_state()
print("shutting down")The try block wraps the entire loop, so the exception is caught wherever it occurs. This works for interactive scripts. On Unix-like systems, daemons and services are often stopped with SIGTERM; a signal handler is required for a controlled shutdown.
import signal
running = True
def stop(signum, frame):
global running
running = False
signal.signal(signal.SIGTERM, stop)
while running:
process_next_item()The handler sets running to False, and the loop exits at the next iteration boundary. This is the standard way to make a long-running loop terminate cleanly when the process is asked to stop. In CPython, the handler runs between bytecode instructions rather than as an exception inside the loop body, so the current iteration usually finishes before the loop checks running again.
When an Infinite Loop Is the Right Design
Use an intentional infinite loop when the program must run until an external event stops it. A server accepting connections, a worker consuming from a queue, and a background monitor are all examples. In each case, the loop has no natural finite end; it ends only when the process is terminated or a shutdown signal arrives.
If the loop has a natural finite end, a for loop or a while loop with a real condition is clearer. A while True: loop that exits only through break is acceptable, but if the loop always runs a fixed number of times, the explicit condition communicates the intent better.
The decision comes down to whether the termination condition is known before the loop starts. If it is, write it in the condition. If the loop must run until an external event, while True: with a shutdown mechanism is the honest design.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.