Loops: Repeating Code in Python

Trace through this step by step:

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(fruit.upper())

print("Done:", fruit)

The sentinel value pattern — loop until a special value

A sentinel is a special value that signals "stop". This pattern is everywhere in real programs:

# Keep asking until user types "quit"
responses = ["hello", "how are you", "quit"]  # Simulates user input
index = 0

while True:                         # Intentional infinite loop...
    user_input = responses[index]
    index += 1

    if user_input == "quit":        # ...with a guaranteed exit
        print("Goodbye!")
        break

    print(f"You said: {user_input}")

while True: is valid — an intentional infinite loop is fine as long as you have a break condition inside. This pattern is used for menus, game loops, and server request handling.

Safety net: maximum iteration counter

MAX_TRIES = 1000
tries = 0

while some_condition and tries < MAX_TRIES:
    # ... do work ...
    tries += 1

if tries >= MAX_TRIES:
    print("Warning: hit maximum iterations — check your logic!")

When writing complex while loops, adding a maximum counter is a professional safety habit — it turns an accidental infinite loop into a detectable bug.

Pattern 1: Accumulator — build a running total

scores = [85, 92, 78, 96, 73]

total = 0               # ← Start at zero
for score in scores:
    total += score      # ← Add each item

average = total / len(scores)
print(f"Total: {total}, Average: {average:.1f}")  # Total: 424, Average: 84.8

Pattern 2: Counter — count items that match a condition

words = ["python", "java", "python", "rust", "python", "go"]

python_count = 0        # ← Start at zero
for word in words:
    if word == "python":
        python_count += 1

print(f"'python' appears {python_count} times")  # 3 times

Pattern 3: Filter — collect items that meet a condition

numbers = [3, -1, 7, -4, 0, 9, -2, 5]

positives = []           # ← Start with empty result
for num in numbers:
    if num > 0:
        positives.append(num)   # ← Add matching items

print(f"Positives: {positives}")  # [3, 7, 9, 5]

Pattern 4: Maximum/Minimum finder

temperatures = [18.5, 22.1, 15.3, 25.8, 19.0, 12.4]

highest = temperatures[0]    # ← Assume first is the answer
for temp in temperatures:
    if temp > highest:
        highest = temp        # ← Update if we find better

print(f"Hottest day: {highest}°C")  # 25.8°C

# Python's built-in does the same:
print(f"Using max(): {max(temperatures)}°C")

Pattern 5: Transform — build a new list from an old one

names = ["alice", "bob", "charlie"]

capitalised = []
for name in names:
    capitalised.append(name.capitalize())

print(capitalised)  # ['Alice', 'Bob', 'Charlie']

You'll soon learn a shorter way to write this using list comprehensions — but the pattern is the same.

Real use case: searching for a prime number factor

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            print(f"{n} is divisible by {i} — not prime")
            break
    else:
        print(f"{n} is prime!")   # Only runs if no factor was found
        return True
    return False

is_prime(17)   # 17 is prime!
is_prime(15)   # 15 is divisible by 3 — not prime

enumerate() — get the index alongside the value

Without it, you'd need a manual counter variable. With it, Python tracks the index for you:

players = ["Alice", "Bob", "Charlie"]
i = 0
for player in players:
    print(f"{i+1}. {player}")
    i += 1

players = ["Alice", "Bob", "Charlie"]
for i, player in enumerate(players, start=1):
    print(f"{i}. {player}")
# 1. Alice
# 2. Bob
# 3. Charlie

The start=1 argument makes numbering start at 1 instead of 0 — perfect for user-facing lists.

zip() — loop through two sequences in parallel

zip() pairs up items from two (or more) sequences, giving you one item from each per iteration:

names  = ["Alice", "Bob",   "Charlie"]
scores = [92,      78,      85]

for name, score in zip(names, scores):
    grade = "Pass" if score >= 60 else "Fail"
    print(f"{name}: {score}/100 — {grade}")

# Output:
# Alice: 92/100 — Pass
# Bob: 78/100 — Pass
# Charlie: 85/100 — Pass

zip() stops at the shortest sequence. If one list has 3 items and another has 5, you get 3 pairs.

reversed() — loop backwards through a sequence

steps = ["Open app", "Log in", "Browse", "Checkout", "Pay"]

print("Reverse order:")
for step in reversed(steps):
    print(f"  ← {step}")

# Countdown using reversed() with range:
for i in reversed(range(1, 6)):
    print(i, end=" ")
print("Go!")  # 5 4 3 2 1 Go!

The transformation: for loop → list comprehension

numbers = [1, 2, 3, 4, 5]
squared = []
for n in numbers:
    squared.append(n ** 2)
# squared = [1, 4, 9, 16, 25]

numbers = [1, 2, 3, 4, 5]
squared = [n ** 2 for n in numbers]
# squared = [1, 4, 9, 16, 25]

With a filter condition

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Only keep even numbers:
evens = [n for n in numbers if n % 2 == 0]
print(evens)   # [2, 4, 6, 8, 10]

# Square only the odd numbers:
odd_squares = [n ** 2 for n in numbers if n % 2 != 0]
print(odd_squares)   # [1, 9, 25, 49, 81]

# Capitalise names that are longer than 4 letters:
names = ["Ali", "Bobby", "Charlie", "Di"]
long_names = [name.upper() for name in names if len(name) > 4]
print(long_names)   # ['BOBBY', 'CHARLIE']