The `while` loop in Python is a control structure that repeats a block of code as long as a specified condition remains true. It's especially useful when you don’t know in advance how many times you’ll need to repeat the loop, as it evaluates the condition at each iteration.
Basic Syntax of `while` Loop
Here’s the general form:
while condition:
# Code block to execute repeatedly
The `while` loop will run as long as `condition` is `True`. When `condition` becomes `False`, it exits the loop and moves on to the next section of code.
Example 01
Let’s start with a simple example where we print numbers from 1 to 5 using a `while` loop:
counter = 1
while counter <= 5:
print(counter)
counter += 1
In this example:
1. The `counter` variable starts at `1`.
2. The `while` loop checks if `counter` is less than or equal to `5`.
3. If true, it prints the current value of `counter` and then increments `counter` by 1.
4. The loop stops once `counter` is greater than `5`.
Example 02: Monitoring a Process
Imagine a scenario where you’re monitoring the status of a long-running process (like a data load or server operation). You can use a `while` loop to keep checking the process status until it’s complete.
process_status = "running"
while process_status != "completed":
print("Process is still running...")
# Code that checks process status and updates it
# (For illustration, we'll simulate completion after one iteration)
process_status = "completed" # Simulate process completion
print("Process completed.")
Here, the `while` loop checks the `process_status`. Once the status is set to `"completed"`, the loop exits, and the completion message is printed.
Infinite Loops and Breaking Out
If the loop’s condition never becomes false, the loop will run indefinitely (an infinite loop). To prevent this, make sure the condition will eventually be met, or use the `break` statement to exit prematurely.
Example 03 of `break`
count = 0
while True: # Infinite loop
print(count)
count += 1
if count == 5:
break # Exit the loop when count is 5
This loop would otherwise run forever, but with `break`, it stops once `count` equals 5.
Common uses of while Loops
1. Waiting for a Condition to Change
Consider a situation where you’re waiting for a file to become available for processing:
import os
file_path = "data.txt"
while not os.path.exists(file_path):
print("File not found, waiting...")
# Here, you'd typically add a small delay to avoid constant checking
# Example: time.sleep(1)
print("File is now available!")
In this code: - The loop checks whether the file exists. - It continues to print "File not found" until the file appears in the directory.
2. Validating User Input
You can use a `while` loop to continuously prompt a user until they provide valid input. Here’s an example of asking for a password that meets certain criteria:
password = input("Enter your password: ")
while len(password) < 8:
print("Password must be at least 8 characters long.")
password = input("Enter a new password: ")
print("Password accepted.")
Here:
- The loop checks if the password length is less than 8 characters.
- If so, it keeps prompting until a valid password is entered.
`else` with `while`
Python provides an optional `else` clause with `while`, which executes if the loop completes without encountering a `break` statement.
Example 03 of `while` with `else`
count = 0
while count < 3:
print("Count:", count)
count += 1
else:
print("Loop completed successfully.")
In this example:
- The `else` clause runs after the `while` loop finishes normally.
- If there were a `break`, the `else` block wouldn’t execute.
Summary
- while Loop: Repeats as long as a condition is `True`.
- Infinite Loops: Avoid by ensuring the condition will eventually be `False`, or use `break`.
- Use Cases : Useful for conditions that aren’t based on a fixed number of iterations, like waiting for a process or validating input.
- Optional else: Executes if the loop exits normally, without `break`.
The while loop gives you flexibility for controlling flows where the number of iterations isn’t predetermined, and you need to check dynamic conditions during runtime.