Chapter 7 — Loops & Iteration Basics

The why

Computers never get bored. If you need to do the same thing 1,000 times, a loop does it in milliseconds. Without loops, you'd copy-paste code — and copy-paste code is unmaintainable code.

Loops are the foundation of data processing. Every later chapter (lists, files, APIs, databases) builds on the patterns you'll learn here. Master loops, and you can process any collection of data.

Core concepts: Loop types and patterns

Python gives you two loop types and three classic patterns. Click each to see how to use it:

# Loop over a list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
 
# Loop over a string
for char in "hello":
    print(char)
 
# Loop over a range
for i in range(5):
    print(i)  # 0, 1, 2, 3, 4
 
# Loop with index
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# Basic while loop
count = 0
while count < 5:
    print(count)
    count += 1
 
# User input loop
while True:
    command = input("Enter command (or 'quit'): ")
    if command == "quit

total = 0
for num in [1, 2, 3, 4, 5]:
    total += num
print(total)  # 15

numbers = [1, 3, 5, 8

# break — exit early
for i in range(10):
    if i == 5:
        break
    print(i)  # 0, 1, 2, 3, 4
 
# continue — skip iteration
for i in range(5):
    if i ==

I need to…
├── Process every item in a collection → for loop
├── Repeat until a condition changes → while loop
├── Build up a result → for + accumulate pattern
├── Find a specific item → for + search pattern
└── Count matching items → for + count pattern

for loops: the Python way

In Python, for loops iterate over collections — lists, strings, ranges, and anything else that's iterable. You don't manage an index variable like in C or Java.

Looping over a list

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

Mental model: "For each item in the collection, do this."

Looping over a string

for char in "hello":
    print(char)
# h
# e
# l
# l
# o

Looping over a range

range(n) generates numbers from 0 to n-1:

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

range(start, stop) generates from start to stop-1:

for i in range(2, 6):
    print(i)
# 2
# 3
# 4
# 5

range(start, stop, step) generates with a custom step:

for i in range(0, 10, 2):
    print(i)
# 0
# 2
# 4
# 6
# 8

enumerate() — when you need the index

If you need both the item and its index, use enumerate():

fruits = ["apple", "banana", "cherry"]
 
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")
# 0: apple
#

When to use enumerate:

• Displaying numbered lists
• Building dictionaries from lists
• Any time you need "the position" of an item

When NOT to use enumerate:

• If you only need the item, don't use enumerate — it's clutter
• If you need to modify the list, use indices directly (but consider if you really need to)

while loops: condition-driven loops

while loops run as long as a condition is true. Use them when you don't know how many iterations you need.

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

Key facts:

• The condition is checked before each iteration.
• If the condition is false initially, the loop body never runs.
• You must update the condition variable inside the loop, or you'll get an infinite loop.

Infinite loop example:

# WARNING: Don't run this — it never stops
count = 0
while count < 5:
    print(count)
    # Forgot to increment count — infinite loop!

When to use while:

• Reading user input until they type "quit"
• Polling a resource until it's ready
• Retry logic with a maximum attempt count

# User input loop
while True:
    command = input("Enter command (or 'quit'): ")
    if command == "quit":
        break
    print(f"Executing: {command}")

break and continue

break exits the loop immediately:

for i in range(10):
    if i == 5:
        break
    print(i)
# 0
# 1
# 2
# 3
# 4

continue skips the rest of the current iteration and moves to the next:

for i in range(5):
    if i == 2:
        continue
    print(i)
# 0
# 1
# 3
# 4

When to use break:

• Searching for an item and stopping when you find it
• Exiting a loop on an error condition

When to use continue:

• Skipping invalid items in a collection
• Filtering out cases you don't want to process

# Skip negative numbers
numbers = [1, -2, 3, -4, 5]
for num in numbers:
    if num < 0:
        continue
    print(num)
# 1
# 3

The three patterns

Most loops follow one of three patterns. Recognize them, and you can write any loop.

Pattern 1: Accumulate

Build up a result by adding to it in each iteration:

# Sum a list
total = 0
for num in [1, 2, 3, 4, 5]:
    total += num
print(total)  # 15
 
# Build a string
result = ""
for word in

Pattern 2: Search

Find an item that matches a condition:

# Find the first even number
numbers = [1, 3, 5, 8, 9]
for num in numbers:
    if num % 2 == 0:
        print(f"Found: {num}")
        break
# Found: 8

Pattern 3: Count

Count items that match a condition:

# Count even numbers
numbers = [1, 2, 3, 4, 5, 6]
count = 0
for num in numbers:
    if num % 2 == 0:
        count += 1
print(f"Even count: {count

Nested loops

Loops inside loops. The inner loop runs completely for each iteration of the outer loop:

for i in range(3):
    for j in range(2):
        print(f"({i}, {j})")
# (0, 0)
# (0, 1)
# (1, 0)
# (1, 1)

When to use nested loops:

• Iterating over 2D data (matrices, grids)
• Generating combinations
• Comparing every pair of items

When NOT to use nested loops:

• If you're doing O(n²) work on large datasets, consider if there's a more efficient algorithm
• If the logic is complex, extract the inner loop into a function

Real-world usage

Processing files:

# Count lines in a file
with open("data.txt") as f:
    line_count = 0
    for line in f:
        line_count += 1
print(f"Total lines: {line_count}")

Building reports:

users = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
    {"name": "Charlie", "age":

Retry logic:

import time
 
max_retries = 3
for attempt in range(max_retries):
    try:
        result = fetch_data()
        break
    except ConnectionError:
        print(f"Attempt {attempt + 1} failed, retrying...")
        time.sleep(1

Common mistakes

Production notes

List comprehensions: For simple accumulate patterns, list comprehensions are more concise and faster:

# Loop
squares = []
for num in range(5):
    squares.append(num ** 2)
 
# Comprehension (preferred)
squares = [num ** 2 for num in range(5)]

We'll cover comprehensions in L1.

Performance: For loops are fast enough for most tasks. For large datasets (millions of items), consider using map(), filter(), or numpy for vectorized operations.

Generator expressions: If you're accumulating into a large list but only need to iterate once, use a generator expression to save memory:

# List (loads everything into memory)
squares = [num ** 2 for num in range(1_000_000)]
 
# Generator (computes on demand)
squares = (num ** 2 for num in range(1_000_000))

We'll cover generators in L2.

Practice: Prove your Mastery

Interview Questions

Summary

• for loops iterate over collections: for item in items:.
• range(n) generates numbers from 0 to n-1. Use range(start, stop, step) for custom ranges.
• enumerate() gives you both the index and the value.
• while loops run as long as a condition is true.
• break exits the loop, continue skips to the next iteration.
• Three patterns: accumulate (build up), search (find), count (tally).
• Nested loops run the inner loop completely for each outer iteration.

Quick recall

I want to…
├── Loop over a list → for item in items:
├── Loop with index → for i, item in enumerate(items):
├── Loop N times → for i in range(N):
├── Loop until condition → while condition:
├── Exit early → break
├── Skip iteration → continue
├── Accumulate → total = 0; for x in items: total += x
├── Search → for item in items: if matches(item): break
└── Count → count = 0; for item in items: if matches(item): count += 1

Self-Check Quiz

Warning: Forgetting to update the condition variable → infinite loop.

Pattern 3: Count — tally matches:

Key insight: else after a loop runs only if the loop completed normally (no break).