Python for Loop Explained — Syntax, Examples and Common Mistakes

# ── Basic for loop ───────────────────────────────────────────────────────────
planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter"]

for planet in planets:           # 'planet' holds the current item each round
    print(f"Visiting {planet}")  # this line runs once per planet

print("Tour complete!")          # NOT indented — runs after the loop finishes

# ── What Python actually does under the hood ─────────────────────────────────
# The for loop above is equivalent to this manual iterator protocol:
print("\n=== Manual iterator (what Python does internally) ===")
iterator = iter(planets)         # get an iterator from the list

while True:
    try:
        planet = next(iterator)  # ask for the next item
        print(f"Visiting {planet}")
    except StopIteration:        # no more items — loop ends
        break

# Knowing this explains WHY you can loop over strings, files, generators:
# any object that implements __iter__ and __next__ is fair game.
print("\n=== Strings are iterable too ===")
for char in "Mars":             # string is just a sequence of characters
    print(char)

# ── range(n): repeat N times, starting from 0 ────────────────────────────────
print("=== Countdown prep ===")
for step_number in range(5):           # generates 0, 1, 2, 3, 4
    print(f"Step {step_number}")

# ── range(start, stop): control where counting begins ────────────────────────
print("\n=== Lap counter ===")
for lap in range(1, 6):                # generates 1, 2, 3, 4, 5 (NOT 6)
    print(f"Lap {lap} complete")

# ── range(start, stop, step): skip values ────────────────────────────────────
print("\n=== Even floors only ===")
for floor in range(0, 11, 2):          # 0, 2, 4, 6, 8, 10
    print(f"Elevator stops at floor {floor}")

# ── Counting backwards ────────────────────────────────────────────────────────
print("\n=== Rocket launch ===")
for countdown in range(5, 0, -1):      # 5, 4, 3, 2, 1
    print(f"T-minus {countdown}...")
print("Liftoff!")

# ── range() is lazy — not a list ─────────────────────────────────────────────
import sys

lazy_range   = range(1_000_000)
eager_list   = list(range(1_000_000))

print(f"\nrange(1_000_000) memory: {sys.getsizeof(lazy_range)} bytes")
print(f"list(range(1_000_000)) memory: {sys.getsizeof(eager_list):,} bytes")
# Never convert range to a list just to iterate — there is no benefit

# ── Looping over a string ─────────────────────────────────────────────────────
word = "Python"
print("=== Characters in 'Python' ===")
for character in word:               # each character, one at a time
    print(character)

# ── Looping over a dictionary ─────────────────────────────────────────────────
student_grades = {
    "Alice": 92,
    "Bob": 78,
    "Carlos": 85
}
print("\n=== Keys only (direct iteration) ===")
for student_name in student_grades:          # gives keys by default
    print(student_name)

print("\n=== Keys AND values (.items()) ===")
for student_name, grade in student_grades.items():
    if grade >= 90:
        remark = "Excellent"
    elif grade >= 80:
        remark = "Good"
    else:
        remark = "Keep practising"
    print(f"{student_name}: {grade} — {remark}")

print("\n=== Values only (.values()) ===")
total = sum(student_grades.values())   # .values() in a built-in — no loop needed
print(f"Class total: {total}")

# ── Using enumerate() to track position ───────────────────────────────────────
race_finishers = ["Aisha", "Ben", "Clara", "David"]
print("\n=== Race Results — enumerate(start=1) ===")
for position, runner_name in enumerate(race_finishers, start=1):
    print(f"Position {position}: {runner_name}")

# ── The anti-pattern enumerate() replaces ─────────────────────────────────────
print("\n=== Avoid this pattern: range(len()) ===")
# BAD — unidiomatic, error-prone, breaks on non-sequence iterables
for i in range(len(race_finishers)):
    print(f"{i+1}: {race_finishers[i]}")

print("\n=== Prefer enumerate() instead ===")
# GOOD — clean, works on any iterable, no manual index math
for i, runner in enumerate(race_finishers, start=1):
    print(f"{i}: {runner}")

from itertools import zip_longest

# ── Basic zip(): pair two lists ───────────────────────────────────────────────
names  = ["Alice", "Bob", "Carlos", "Diana"]
scores = [92, 78, 85, 96]

print("=== Score Report ===")
for name, score in zip(names, scores):   # no index math, no range(len())
    status = "Pass" if score >= 80 else "Fail"
    print(f"{name}: {score} — {status}")

# ── zip() stops at the shorter sequence ───────────────────────────────────────
extra_names = ["Alice", "Bob", "Carlos", "Diana", "Evan"]  # 5 names
fewer_scores = [92, 78, 85]                                  # 3 scores

print("\n=== zip() stops early — Evan and Diana are silently dropped ===")
for name, score in zip(extra_names, fewer_scores):
    print(f"{name}: {score}")
# Evan and Diana never appear — zip() stopped when fewer_scores ran out

# ── zip_longest(): process all items, fill gaps with a default ────────────────
print("\n=== zip_longest() — no items dropped ===")
for name, score in zip_longest(extra_names, fewer_scores, fillvalue="N/A"):
    print(f"{name}: {score}")

# ── zip() with three sequences ────────────────────────────────────────────────
students = ["Alice", "Bob", "Carlos"]
grades   = ["A",     "C",   "B"    ]
years    = [2024,    2025,  2026   ]

print("\n=== Three-way zip ===")
for student, grade, year in zip(students, grades, years):
    print(f"{student} ({year}): {grade}")

# ── zip() to build a dictionary from two lists ────────────────────────────────
headers = ["name", "score", "year"]
row     = ["Alice", 92, 2026]

record = dict(zip(headers, row))      # cleaner than a manual loop
print(f"\n=== dict from zip: {record}")

# ── zip() is lazy: constant memory regardless of input size ──────────────────
import sys
large_zip = zip(range(1_000_000), range(1_000_000))
print(f"\nzip object memory: {sys.getsizeof(large_zip)} bytes — not 8MB")

# ── break: stop the moment you find what you need ────────────────────────────
passenger_list = ["Tom", "Sara", "Jake", "Mia", "Leo"]
target_passenger = "Jake"

print("=== Boarding check ===")
for passenger in passenger_list:
    if passenger == target_passenger:
        print(f"Found {target_passenger}! Stopping search.")
        break
    print(f"Not {target_passenger}, checked {passenger}")

# ── continue: skip invalid items, keep going ──────────────────────────────────
raw_scores = [88, -5, 76, 0, 95, -1, 60]
print("\n=== Valid scores only ===")
for score in raw_scores:
    if score <= 0:       # invalid — skip
        continue
    print(f"Recording score: {score}")

# ── for...else: runs ONLY if the loop was NOT broken out of ───────────────────
seating_chart = ["14A", "14B", "15A", "15B"]
requested_seat = "16C"

print("\n=== Seat search ===")
for seat in seating_chart:
    if seat == requested_seat:
        print(f"Seat {requested_seat} found!")
        break
else:
    # This block runs ONLY because we never hit 'break'
    print(f"Seat {requested_seat} is not available.")

# ── break only affects the innermost loop ─────────────────────────────────────
# If you need to exit a nested loop early, use a function + return
print("\n=== Nested loop: break exits inner only ===")
found = False
for row in range(3):
    for col in range(3):
        if row == 1 and col == 1:
            print(f"Found target at row={row}, col={col}")
            found = True
            break          # exits inner loop only
    if found:
        break              # flag lets outer loop exit too

# Cleaner approach: extract nested search into a function
print("\n=== Nested loop: function + return is cleaner ===")
def find_in_grid(grid, target):
    for r, row in enumerate(grid):
        for c, value in enumerate(row):
            if value == target:
                return r, c   # exits both loops immediately
    return None

grid = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
result = find_in_grid(grid, 5)
print(f"Found 5 at: {result}")

# ── The accumulator loop pattern (fine, but verbose) ─────────────────────────
raw_scores = [88, -5, 76, 0, 95, -1, 60, 45, 101]

valid_scores_loop = []
for score in raw_scores:
    if 0 < score <= 100:
        valid_scores_loop.append(score)

print(f"Loop result:   {valid_scores_loop}")

# ── The same logic as a list comprehension ────────────────────────────────────
valid_scores_comp = [score for score in raw_scores if 0 < score <= 100]
print(f"Comprehension: {valid_scores_comp}")

# ── Transformation: apply an operation to every item ─────────────────────────
temps_celsius    = [0, 20, 37, 100]
temps_fahrenheit = [(c * 9/5) + 32 for c in temps_celsius]
print(f"\nFahrenheit: {temps_fahrenheit}")

# ── Filter AND transform in one line ─────────────────────────────────────────
words   = ["hello", "world", "python", "for", "loop"]
# Uppercase words longer than 4 characters
result  = [w.upper() for w in words if len(w) > 4]
print(f"\nFiltered + uppercased: {result}")

# ── Dict comprehension ────────────────────────────────────────────────────────
students = {"Alice": 92, "Bob": 78, "Carlos": 85}
passing  = {name: grade for name, grade in students.items() if grade >= 80}
print(f"\nPassing students: {passing}")

# ── Generator expression vs list comprehension: memory comparison ─────────────
import sys

list_comp = [x ** 2 for x in range(10_000)]        # builds entire list in memory
gen_expr  = (x ** 2 for x in range(10_000))         # lazy — one value at a time

print(f"\nList comprehension size: {sys.getsizeof(list_comp):,} bytes")
print(f"Generator expression size: {sys.getsizeof(gen_expr)} bytes")

# When summing, use a generator — no need to build the list
list_sum = sum([x ** 2 for x in range(10_000)])    # builds list, then discards it
gen_sum  = sum(x ** 2 for x in range(10_000))      # constant memory — prefer this
print(f"\nBoth produce same sum: {list_sum == gen_sum}")

from itertools import product

# ── Basic nested loop: multiplication table ───────────────────────────────────
print("=== Multiplication Table (3x3) ===")
for row in range(1, 4):         # outer loop: 3 iterations
    for col in range(1, 4):     # inner loop: 3 iterations per outer iteration
        print(f"{row} x {col} = {row * col}")
    print()                     # blank line after each row

# ── Working with a 2D grid ────────────────────────────────────────────────────
print("=== Grid traversal ===")
grid = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
for row_index, row in enumerate(grid):
    for col_index, value in enumerate(row):
        print(f"  grid[{row_index}][{col_index}] = {value}")

# ── The O(n²) anti-pattern: nested loop membership check ─────────────────────
import time

list_a = list(range(5_000))
list_b = list(range(2_500, 7_500))  # overlaps with list_a

# BAD: O(n²) — checks every item in list_b for every item in list_a
start = time.perf_counter()
bad_overlap = [x for x in list_a if x in list_b]   # 'in list_b' is O(n) each time
bad_time = time.perf_counter() - start

# GOOD: O(n) — convert list_b to a set first, then check is O(1)
set_b = set(list_b)
start = time.perf_counter()
good_overlap = [x for x in list_a if x in set_b]   # 'in set_b' is O(1) each time
good_time = time.perf_counter() - start

print(f"\n=== Membership check performance ===")
print(f"Nested loop (O(n²)): {bad_time*1000:.2f}ms, {len(bad_overlap)} overlapping items")
print(f"Set lookup  (O(n)):  {good_time*1000:.2f}ms, {len(good_overlap)} overlapping items")

# ── itertools.product(): cartesian product without nested loops ───────────────
colors  = ["Red", "Blue"]
sizes   = ["S",   "M",   "L"  ]

print("\n=== All colour/size combinations ===")
for color, size in product(colors, sizes):   # same result as nested loop
    print(f"{color} - {size}")