Python Tutorials

Python For Loop Tutorial : Iterate Over Ranges & Sequences

12 min read

Imagine you need to send a “Happy New Year” email to 10,000 customers. If you didn’t know how to use loops, you would have to write the exact same send_email() line of code 10,000 times. Not only would this take hours of mindless typing, but it would also make your code impossibly large, highly prone to errors, and incredibly difficult to maintain.

In programming, one of the most fundamental rules is DRY (Don’t Repeat Yourself). We use Loops to tell the computer to repeat a specific block of code multiple times. Python has a few different types of loops, but the most common, powerful, and frequently used is the for loop. It allows you to grab a collection of data (like a list of 10,000 customer emails) and perform an action on every single item, one by one, automatically. Mastering the python for loop is the key to unlocking the true automation power of programming.

What is a for Loop?

In Python, a for loop is a control flow statement used for iteration—the process of repeatedly executing a block of code. Specifically, the Python for loop is designed to iterate over any iterable object.

An “iterable” is any Python object capable of returning its members one at a time. This includes sequences like lists, tuples, and strings, as well as complex mappings like dictionaries and sets. The loop continues to execute until it has visited every single item in the provided sequence, at which point the loop terminates automatically and the program moves on to the next line of code.

Syntax & Basic Usage

The syntax of a for loop reads almost exactly like plain English, which is one of Python’s greatest strengths. You use the for keyword, invent a temporary variable name to represent the current item being processed, use the in keyword, and then provide the collection of data.

Just like an if statement, the code that belongs inside the loop must be indented.

# A simple list of data representing a shopping cart
shopping_cart = ["Apples", "Bread", "Milk"]

# The for loop syntax: for <temporary_variable> in <collection>:
for current_item in shopping_cart:
    print(f"Adding {current_item} to the grocery bag.")

# Expected Output:
# Adding Apples to the grocery bag.
# Adding Bread to the grocery bag.
# Adding Milk to the grocery bag.
Code language: PHP (php)

How it works under the hood: Python looks at the list and grabs the first item, “Apples”. It assigns the string “Apples” to your temporary current_item variable, and runs the indented print statement. Once the indented block finishes, Python jumps back to the top of the loop, grabs “Bread”, overwrites the current_item variable with this new value, and runs the print statement again. It repeats this cycle until the list is completely empty.

Exhaustive Exploration & Methods

The for loop is incredibly versatile. To truly learn how to iterate in python, you must understand that it doesn’t just work on simple lists; it adapts to almost any data structure in the language. Let’s explore every major way to use a for loop.

1. Iterating Over Strings

Strings are technically just sequences of individual characters. Therefore, you can use a for loop to cycle through a word or sentence, letter by letter. This is incredibly useful for parsing data, counting specific characters, or encrypting text.

# Iterating through a text string to count specific letters
secret_password = "Open Sesame"
vowel_count = 0

for single_letter in secret_password:
    # Convert to lowercase to catch both 'O' and 'e'
    if single_letter.lower() in "aeiou":
        vowel_count += 1
        print(f"Vowel found: {single_letter}")

print(f"Total vowels in password: {vowel_count}")

# Expected Output:
# Vowel found: O
# Vowel found: e
# Vowel found: e
# Vowel found: a
# Vowel found: e
# Total vowels in password: 5
Code language: PHP (php)

2. The range() Function

Often, you don’t have a pre-existing list of data; you just want to repeat an action a specific number of times (like retrying a failed server connection 5 times). The built-in range() function generates a temporary, highly memory-efficient sequence of numbers for you to loop through.

Because range() evaluates lazily (meaning it generates numbers on the fly rather than storing them all in your computer’s RAM), you can safely loop through a range of a billion numbers without crashing your computer!

range() can take up to three arguments: range(start, stop, step).

# 1. Using range(stop): Starts at 0, stops BEFORE 5
print("--- Standard Range ---")
for current_number in range(5):
    print(f"Count: {current_number}")

# 2. Using range(start, stop, step): Start at 10, stop before 50, count by 10s
print("\n--- Stepped Range ---")
for tens_counter in range(10, 50, 10):
    print(f"Counting by tens: {tens_counter}")

# 3. Using range backwards: Start at 3, stop before 0, step backwards by -1
print("\n--- Countdown Range ---")
for countdown_timer in range(3, 0, -1):
    print(f"T-Minus: {countdown_timer}...")
print("Liftoff!")

# Expected Output:
# --- Standard Range ---
# Count: 0
# Count: 1
# Count: 2
# Count: 3
# Count: 4
#
# --- Stepped Range ---
# Counting by tens: 10
# Counting by tens: 20
# Counting by tens: 30
# Counting by tens: 40
#
# --- Countdown Range ---
# T-Minus: 3...
# T-Minus: 2...
# T-Minus: 1...
# Liftoff!
Code language: PHP (php)

3. Loop Control: break and continue

Sometimes you need to interrupt a loop before it finishes naturally based on a specific condition. Python provides two vital keywords for this exact scenario:

  • break: Completely destroys the loop. Python exits the loop entirely and moves on to the rest of your script.
  • continue: Skips the rest of the current iteration. Python abandons the current item and instantly jumps back to the top of the loop to process the next item.
# A list of users, including one banned user and our target user
system_users = ["Alice", "Bob", "BANNED_USER", "Charlie", "David"]

for active_user in system_users:
    # If we see a banned user, we skip them entirely using 'continue'
    if active_user == "BANNED_USER":
        print("-> Alert: Skipping a banned account.")
        continue 
    
    # We break the loop entirely if we reach Charlie, ignoring David completely
    if active_user == "Charlie":
        print("-> Charlie found! Stopping the entire search process.")
        break
        
    print(f"Sending newsletter to {active_user}.")

print("Newsletter program finished.")

# Expected Output:
# Sending newsletter to Alice.
# Sending newsletter to Bob.
# -> Alert: Skipping a banned account.
# -> Charlie found! Stopping the entire search process.
# Newsletter program finished.
Code language: PHP (php)

4. Tracking the Index with enumerate()

A massive beginner mistake when learning to python loop through list data is trying to manually create a counter variable to track how many times a loop has run. Or worse, using range(len(my_list)) to generate index numbers.

Python has a highly optimized, built-in function called enumerate() that elegantly provides the data item AND its numerical index (position) at the exact same time.

# Using enumerate to get the index and the item simultaneously
top_movies = ["The Matrix", "Inception", "Interstellar"]

# ANTI-PATTERN (Do not do this):
# for i in range(len(top_movies)):
#     print(f"Rank: {top_movies[i]}")

# PYTHONIC WAY (Do this):
# enumerate() unpacks two variables: the index number, and the list item
for ranking_index, movie_title in enumerate(top_movies):
    # We add 1 to the index because computers start counting at 0!
    display_rank = ranking_index + 1
    print(f"Rank #{display_rank}: {movie_title}")

# Expected Output:
# Rank #1: The Matrix
# Rank #2: Inception
# Rank #3: Interstellar
Code language: PHP (php)

5. Iterating Over Dictionaries

Dictionaries store data in Key-Value pairs. Depending on what data you need, Python offers three different methods to loop through a dictionary: .keys(), .values(), and .items().

# A dictionary mapping player names (Keys) to their scores (Values)
player_scores = {"Arthur": 1500, "Gwen": 2200}

# Method 1: Iterating over Keys (This is the default behavior)
print("--- Keys ---")
for player_name in player_scores.keys():
    print(f"Player recognized: {player_name}")

# Method 2: Iterating over Values
print("\n--- Values ---")
for current_score in player_scores.values():
    print(f"Score recorded: {current_score}")

# Method 3: Iterating over Both using .items() (Most Common)
print("\n--- Items (Key/Value Pairs) ---")
for player_name, current_score in player_scores.items():
    print(f"Player {player_name} has {current_score} points.")

# Expected Output:
# --- Keys ---
# Player recognized: Arthur
# Player recognized: Gwen
#
# --- Values ---
# Score recorded: 1500
# Score recorded: 2200
#
# --- Items (Key/Value Pairs) ---
# Player Arthur has 1500 points.
# Player Gwen has 2200 points.
Code language: PHP (php)

6. The for...else Clause (Python’s Hidden Gem)

Python has a unique feature rarely found in other programming languages: you can attach an else statement to the very end of a for loop.

This is incredibly useful for “search” operations. Normally, you would have to create a variable like is_found = False before a loop, update it if you found your target, and check it after the loop. The for...else construct eliminates this boilerplate. The code inside the else block will only run if the loop finishes completely naturally (meaning it processed every item and was never stopped by a break statement).

# Searching a database for a specific, highly confidential file
database_files = ["report.txt", "budget.xlsx", "image.png"]
search_target = "secret_passwords.pdf"

for current_file in database_files:
    if current_file == search_target:
        print(f"CRITICAL: {search_target} found! Initiating lockdown.")
        break
else:
    # This runs ONLY if the loop finishes without hitting the 'break'
    print(f"Security scan complete: '{search_target}' was safely not found.")

# Expected Output:
# Security scan complete: 'secret_passwords.pdf' was safely not found.
Code language: PHP (php)

Real-World Practical Examples

To see how python for loop examples translate to real software engineering, let’s look at two practical scenarios involving data processing and cleaning.

Scenario 1: Processing E-Commerce Sales Data

Imagine you have extracted a list of daily transaction amounts from a database. You need a program to calculate the total daily revenue, identify the highest single sale, and find the average transaction amount.

# A list of transactions in dollars
daily_transactions = [45.50, 12.00, 89.99, 105.25, 5.00]

# Initialize variables outside the loop to track our metrics
total_daily_revenue = 0.0
highest_transaction = 0.0
total_transaction_count = 0

# Iterate through every transaction
for single_transaction in daily_transactions:
    # 1. Add the current transaction to the running total
    total_daily_revenue += single_transaction
    
    # 2. Increment our counter for the average calculation
    total_transaction_count += 1
    
    # 3. Check if this is the biggest sale we've seen so far
    if single_transaction > highest_transaction:
        highest_transaction = single_transaction

# Calculate the average after the loop is completely finished
average_transaction = total_daily_revenue / total_transaction_count

# Output the final analytics dashboard
print("--- DAILY SALES REPORT ---")
print(f"Total Revenue:  ${total_daily_revenue:.2f}")
print(f"Highest Sale:   ${highest_transaction:.2f}")
print(f"Average Ticket: ${average_transaction:.2f}")

# Expected Output:
# --- DAILY SALES REPORT ---
# Total Revenue:  $257.74
# Highest Sale:   $105.25
# Average Ticket: $51.55
Code language: PHP (php)

Scenario 2: Data Cleaning and Filtering Pipeline

Often, raw data comes from user forms in messy, unpredictable formats. We can use a for loop to act as a filter, removing bad data, fixing formatting issues, and appending the good data into a brand new, clean list ready for the database.

# Raw data containing valid emails, mixed casing, and invalid empty strings
raw_email_database = ["User1@Mail.com", "", "admin@MAIL.com", "   ", "help@mail.com"]

# An empty list to securely store our cleaned data
cleaned_email_list = []

for email_address in raw_email_database:
    # Clean the string by removing whitespace and forcing lowercase
    formatted_email = email_address.strip().lower()
    
    # If the string is empty after cleaning, skip it to the next iteration
    if not formatted_email:
        continue
        
    # If it is valid, add it to our new list (.append adds an item to a list)
    cleaned_email_list.append(formatted_email)

print("Cleaned Database Ready For Processing:")
for valid_email in cleaned_email_list:
    print(f"- {valid_email}")

# Expected Output:
# Cleaned Database Ready For Processing:
# - user1@mail.com
# - admin@mail.com
# - help@mail.com
Code language: PHP (php)

Best Practices & Common Pitfalls

  • Using Non-Descriptive Loop Variables: Beginners often write for i in customers: or for x in my_list:. What are i and x? Instead, write for customer_name in customers:. This makes your code instantly readable. Always make the loop variable a singular, descriptive version of the plural list.
  • Modifying a List While Looping Over It: This is a massive, highly destructive trap! If you try to .remove() items from a list while you are currently looping through it, the entire list shifts underneath Python’s feet. Python will lose its index place, skip items entirely, or crash. Always create a brand new list and .append() to it, or loop over a safe copy of the original list.
  • Forgetting the Colon (:): Just like if statements, the for loop declaration must end with a colon. Forgetting it immediately triggers a SyntaxError.
  • Not Utilizing enumerate(): If you ever find yourself manually creating a tracking variable (e.g., counter = 0) before a loop, and manually adding to it (counter += 1) inside the loop, stop immediately! Use enumerate() instead. It is faster, safer, and the industry standard.

Summary

  • A for loop is an iterative control flow statement used to sequentially process items in iterable objects like lists, strings, and dictionaries.
  • The loop automatically grabs each item one by one, assigns it to a temporary variable, and executes your indented block of logic.
  • The range() function generates a sequence of numbers dynamically, allowing you to specify a start, stop, and step size (including stepping backwards).
  • You can control the immediate flow of a loop using break (to exit the loop entirely) or continue (to skip processing the current item and move to the next).
  • Use the enumerate() function when you need to access both the data item and its numerical index position simultaneously.
  • Use .keys(), .values(), or .items() to effectively unpack specific data when looping over a Dictionary.
  • Python’s unique for...else construct allows you to execute code specifically when a loop finishes its entire sequence without encountering a break statement.

Leave a Comment