How to loop in Python

In Python, loops are a cornerstone to automate repetitive actions. They empower you to run a code block repeatedly, a core concept for data manipulation and workflow control.

You'll master for and while loops with practical techniques and tips. The article covers real-world applications and provides advice to debug your code for common loop-related issues.

Using the basic for loop

for i in range(5):
   print(i)--OUTPUT--0
1
2
3
4

The basic for loop iterates over a sequence, and the range() function is a common way to generate one. Here, range(5) creates a sequence of integers that the loop cycles through. This is an efficient method for running a block of code a predetermined number of times.

• The sequence starts at 0 by default.
• It stops before reaching the specified number, 5.

As a result, the variable i takes on the values 0, 1, 2, 3, and 4 in successive iterations, which are then printed to the console.

Common looping techniques

The basic for loop is just the start; Python provides more versatile tools like the while loop and concise methods for handling data structures.

Using the while loop

count = 0
while count < 5:
   print(count)
   count += 1--OUTPUT--0
1
2
3
4

A while loop runs as long as a specific condition remains true. It gives you control based on a state—in this case, the value of the count variable. The loop continues executing until the condition count < 5 evaluates to false, offering a flexible alternative to iterating a set number of times.

• The condition is checked before every loop cycle.
• It's crucial to update the variable inside the loop. Without count += 1, the condition would always be true, creating an infinite loop.

Looping through data structures

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
   print(fruit)--OUTPUT--apple
banana
cherry

A for loop isn't just for number ranges; it's perfect for iterating directly over items in a collection like a list. This is often cleaner than tracking an index. In this case, the loop takes each string from the fruits list and assigns it to the fruit variable for each cycle.

• The loop variable, fruit, holds the actual item's value (like "apple"), not its numerical index.
• This direct iteration works on any sequence, including lists, tuples, and even strings.

Using list comprehensions

numbers = [1, 2, 3, 4, 5]
squared = [x**2 for x in numbers]
print(squared)--OUTPUT--[1, 4, 9, 16, 25]

List comprehensions offer a compact and readable way to create a new list from an existing one. They combine a for loop with an expression inside a single pair of brackets, making your code more efficient and Pythonic.

• In the expression [x**2 for x in numbers], the for x in numbers part iterates over the original list.
• The x**2 operation is performed on each element, and the results are collected into a new list.
• This is a direct alternative to using a traditional for loop with an append() method.

Advanced looping techniques

Building on those fundamentals, you can tackle more complex iteration challenges with specialized functions like enumerate(), zip(), and the powerful itertools module.

Using enumerate() to access index and value

fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
   print(f"Index {index}: {fruit}")--OUTPUT--Index 0: apple
Index 1: banana
Index 2: cherry

The enumerate() function is a Pythonic way to access both the index and the value of an item during iteration. It simplifies your loop by automatically keeping track of the count, so you don't have to manage a separate index variable yourself.

• In each loop cycle, enumerate() provides a tuple containing the current index and the corresponding item from the sequence.
• The for loop then unpacks this tuple into two variables—in this case, index and fruit.

Using zip() to iterate through multiple sequences

names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
   print(f"{name} is {age} years old")--OUTPUT--Alice is 25 years old
Bob is 30 years old
Charlie is 35 years old

The zip() function is a clever way to iterate over multiple sequences simultaneously. It pairs up elements from each list, creating tuples of corresponding items. For instance, it takes "Alice" from names and 25 from ages and combines them.

• In each loop cycle, this tuple is unpacked into the variables name and age.
• The loop automatically stops as soon as the shortest sequence runs out of items, which prevents errors.

Using itertools for complex iteration patterns

import itertools
for item in itertools.chain([1, 2], ['a', 'b']):
   print(item)--OUTPUT--1
2
a
b

The itertools module offers powerful tools for handling complex iteration. The chain() function lets you treat multiple sequences as one continuous stream. It processes each iterable in order, moving to the next only when the previous one is exhausted.

• In this example, itertools.chain() links the lists [1, 2] and ['a', 'b'] sequentially.
• This is more memory-efficient than combining lists with the + operator because it doesn't create a new list. Instead, it generates each item on the fly.

Move faster with Replit

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

For the looping techniques we've explored, Replit Agent can turn them into production-ready tools:

• Build a data merger that combines parallel datasets, like user names and their corresponding sign-up dates, using the logic of zip().
• Create a dynamic leaderboard that processes a list of scores and uses enumerate() to assign a rank to each player.
• Deploy a batch processor that iterates through a directory of files to apply a consistent transformation to each one.

Describe your app idea, and Replit Agent writes the code, tests it, and fixes issues automatically, all in your browser.

Common errors and challenges

Understanding how to debug common loop errors will make your code more robust and reliable.

• Fixing infinite while loops. An infinite loop is a classic trap where a while loop’s condition never becomes false, causing it to run forever. This usually happens when you forget to update the variable that the condition depends on. Always ensure there's a mechanism inside the loop—like incrementing a counter—that will eventually terminate it.
• Safely modifying a list during iteration. Changing a list while you're looping through it can cause bizarre behavior, like skipping items. That's because the loop is tracking positions, and when you remove an item, the list's structure shifts underneath it. The safest approach is to iterate over a copy of the list, which you can create with a slice, like for item in my_list[:]:.
• Fixing off-by-one errors in range(). This common bug happens when your loop runs one too many or one too few times. It often stems from forgetting that range() stops before its specified end number. For example, range(5) produces numbers from 0 to 4, not 5. Double-checking your start and end values will help you avoid these errors.

Fixing infinite while loops

An infinite loop is a classic coding pitfall where a while loop's condition never evaluates to false, making it run forever. This typically happens when the variable in the condition isn't updated inside the loop, which can freeze or crash your program.

Examine the following code, which demonstrates this exact problem.

counter = 0
while counter < 5:
   print(counter)
   # Forgot to increment counter

The loop runs forever because the value of counter never changes, so the condition counter < 5 is always met. The corrected code below shows how a small change fixes the issue.

counter = 0
while counter < 5:
   print(counter)
   counter += 1

The solution is adding counter += 1. This line is the escape hatch—it ensures the loop makes progress toward its end. With each cycle, counter increases until the condition counter < 5 is no longer true, which stops the loop. You'll want to be especially careful with this when your loop's exit depends on a state that you must update manually, like a counter or a flag.

Safely modifying a list during iteration

It's a common instinct to remove items from a list directly within a loop. While it seems straightforward, this approach can cause your loop to skip elements unpredictably because the list's size is changing mid-iteration. Observe this behavior in the following code.

numbers = [1, 2, 3, 4, 5]
for num in numbers:
   if num % 2 == 0:
       numbers.remove(num)
print(numbers)

When numbers.remove(2) runs, the list resizes. The number 3 shifts into the index the loop just finished, so the iterator misses it entirely and moves on to 4. The following code shows the proper way to handle this.

numbers = [1, 2, 3, 4, 5]
odd_numbers = [num for num in numbers if num % 2 != 0]
print(odd_numbers)

The solution uses a list comprehension to build a new list, odd_numbers, containing only the desired elements. This is the safest and most Pythonic way to filter a list because it avoids modifying the original list during iteration, which prevents unpredictable behavior like skipping items.

You should always favor this approach—or iterating over a copy—whenever you need to remove items from a collection you're looping through.

Fixing off-by-one errors in range()

An off-by-one error is a classic bug where your loop runs the wrong number of times. With range(), this often happens because it's easy to forget the loop stops before reaching the end number. See if you can spot the issue below.

for i in range(1, 5):
   print(i)

This loop prints the numbers 1 through 4. If you expected it to include 5, you've hit a classic off-by-one error. The following code shows how a simple adjustment to the range() arguments produces the correct sequence.

for i in range(1, 6):
   print(i)

The solution is to increase the stop value by one. Using range(1, 6) ensures the loop runs up to and includes 5, since the range() function always excludes the final number in its sequence.

• Always double-check your range() arguments when your logic depends on including the endpoint. This is especially common when dealing with counts or lengths where you need the loop to run an exact number of times.

Real-world applications

Now that you can navigate common loop errors, you can apply these concepts to build powerful tools for batch processing and dynamic simulations.

Batch processing files with for loops

A for loop lets you automate tasks across many files at once, such as checking each file's extension with a method like endswith() to decide how to process it.

files = ["data.txt", "report.csv", "image.jpg", "notes.txt"]
txt_count = 0
csv_count = 0

for filename in files:
   if filename.endswith('.txt'):
       print(f"Processing text file: {filename}")
       txt_count += 1
   elif filename.endswith('.csv'):
       print(f"Processing CSV file: {filename}")
       csv_count += 1

print(f"Processed {txt_count} text files and {csv_count} CSV files")

This script demonstrates how to use conditional logic within a loop to sort and count items based on specific criteria. The code iterates through the files list, using if and elif statements to route each filename based on its extension.

• It uses the endswith() string method to check if a filename matches '.txt' or '.csv'.
• Separate counters, txt_count and csv_count, track how many of each file type are found.
• Any file that doesn't meet a condition, like "image.jpg", is simply ignored.

After the loop finishes, it prints a final summary of the counts.

Simulating population growth with while loops

A while loop is perfect for simulations where the number of iterations isn't predetermined, allowing a process to continue until a specific condition, like reaching a target population, is met.

initial_population = 1000
growth_rate = 0.05
target = 2000
years = 0
population = initial_population

while population < target:
   population *= (1 + growth_rate)
   years += 1

print(f"Starting population: {initial_population}")
print(f"Growth rate: {growth_rate*100}% per year")
print(f"It takes {years} years to reach {target}")

This script models compound population growth to find how many years it takes to reach a target. The core logic is inside the while loop, which simulates the passage of time year by year.

• In each cycle, the population is updated by applying the annual growth_rate.
• The years counter increments, tracking the total time elapsed.
• The loop continues until the population meets or exceeds the target value.

Once the condition is no longer met, the loop terminates, and the script prints the final result.

Get started with Replit

Turn what you've learned into a real application. Tell Replit Agent to “build a CSV data merger that combines two files using a common ID column” or “create a simple population growth calculator.”

The agent writes the code, tests for errors, and deploys your app automatically. You just focus on the idea. Start building with Replit.