for Loops

A for loop runs its block once for every item in a sequence, handing you the current item under a name you pick.

for letter in "AB":
    print(letter)

A string is a sequence of characters, so this prints A and then B. The colon and the indented block work exactly as they did with if.

Your task: print each character of code on its own line:

P
Y
2
6

split() hands back a list, and a list is a sequence, so a loop walks it the same way it walks a string.

The work inside the block is whatever you would have done to one item — the loop is what makes it happen to all of them.

Your task: the tags below arrive with inconsistent spacing. Split them on the comma, then print each one stripped and title-cased, one per line:

Loops
Lists
Functions

range() produces numbers. It starts at 0 unless told otherwise, and it always stops before the number you give it.

range(5)        # 0 1 2 3 4
range(1, 6)     # 1 2 3 4 5
range(3, 0, -1) # 3 2 1

The exclusive end is deliberate — range(5) gives you five numbers — and it is also where nearly every off-by-one bug comes from.

Your task: two loops. The first prints 1 to 5 inclusive, one per line. The second counts back down from 3 to 1. Eight lines altogether:

1
2
3
4
5
3
2
1

The most useful loop does not print. It builds an answer, and it always has the same three parts:

total = 0              # start it OUTSIDE the loop
for price in prices:
    total += price     # update it inside
print(total)           # use it after

Your task: four line items arrive as one comma-separated string. Total them into total, then print the total and the average to two decimal places:

Total: 3040
Average: 760.00

Remember that split() hands back text. Each piece needs converting before it can be added to anything.

Change what the accumulator does and the same shape counts instead of totalling: start at zero, add one whenever a condition holds, read it afterwards.

count = 0
for line in lines:
    if "ERROR" in line:
        count += 1

splitlines() cuts a multi-line string into a list of lines, which is how a block of log text becomes something a loop can walk.

Your task: count how many of the five log lines are errors, and print:

Errors: 2 of 5

Sometimes the block needs to know where it is, not just what it has. enumerate() hands back both, as two names on the for line:

for number, tag in enumerate(tags, start=1):
    print(number, tag)

Without start=1 the numbering begins at 0, which is right for indexes and wrong for anything a person reads.

This is what replaces for i in range(len(tags)) — that version counts to a number in order to look the item up, which is two steps where one will do.

Your task: print a numbered menu:

1. loops
2. lists
3. functions

break abandons the loop immediately. The classic use is a search: once the thing is found, every remaining pass is wasted work.

for check in checks:
    if check == "FAIL":
        break

Your task: find the position of the first failing check, counting from 1, and stop looking as soon as you have it. There are two failures in the list; only the first one matters.

First failure at check 3

continue abandons the current pass and moves to the next item. It is how you drop the rows that are not your problem without wrapping the whole body in an if:

for line in lines:
    if not line.strip():
        continue
    print(line)

With one filter the two shapes are equivalent. With three, the continue version stays flat while the nested version marches off the right of the screen.

Your task: print only the real settings from this config, skipping blank lines and anything starting with #. Strip each line before printing it:

port=8080
debug=false
timeout=30

This loop reports a total of 79 for three scores that add up to 259. It raises no error, and the number it prints is a perfectly believable score.

The accumulator is being created inside the loop, so every pass throws away everything before it. What survives to the print is the last item alone.

Your task: move one line, and print the real total:

259