Loops

Make a day05 folder for today’s files, open it in your editor, and run each script from its terminal, as on Days 1 to 4.

On Day 4 your programs learned to choose. But every line still ran at most once: the café menu answered one command and stopped, and printing the numbers 1 to 100 would take 100 print lines. Today you learn to repeat: run the same block again and again, as many times as the job needs, and stop at the right moment.

Day 1 printed a countdown with one print per number. That works for 3, 2, 1, but not for a countdown from 1000, and not when the program cannot know in advance how many times to repeat. You need a way to say “keep doing this while something is true”.

A loop runs a block of code repeatedly. A while loop checks a condition, runs its block if the condition is True, then goes back and checks the condition again. It stops when the condition is False. Its shape looks like an if statement from Day 4:

while condition:
    statement
    statement

• while is a keyword, followed by a condition and a colon.
• The indented block is the loop body: the lines that repeat.
• Each run of the body is called an iteration (or a pass).
• When the condition is False, Python skips the body and carries on with the first line after it, back at the left edge.

The difference from if: an if asks its question once. A while asks again after every pass.

count = 3
while count > 0:
    print(count)
    count = count - 1
print("Liftoff!")

3
2
1
Liftoff!

Now change only the starting value, to 0:

count = 0
while count > 0:
    print(count)
    count = count - 1
print("Liftoff!")

Liftoff!

The very first check, 0 > 0, is False, so the body never runs. A while loop checks before each pass, so its body can run zero times.

count = 3
while count > 0:
    print(count)
print("Liftoff!")

savings = 10
weeks = 0
while savings < 50:
    savings = savings * 2
    weeks = weeks + 1
print(weeks, savings)

3 80

The Day 4 menu handled one command and stopped, and Day 4 promised that today you would see how to keep asking. A while loop is the tool, because the program cannot know how many commands the user will type. It keeps going until the user types quit.

command = ""
while command != "quit":
    command = input("Command: ").strip().lower()
    if command == "hours":
        print("Open 8:00 to 18:00.")
    elif command == "price":
        print("A coffee costs 3.50.")
    elif command != "quit":
        print("Unknown command:", command)
print("Goodbye!")

Command: Hours
Open 8:00 to 18:00.
Command: tea
Unknown command: tea
Command: quit
Goodbye!

The same idea checks typed input. A program that needs an age from 1 to 120 can keep asking until it gets one. This run types 0, 200, then 15:

age = int(input("Age (1 to 120): "))
while not 1 <= age <= 120:
    print("Please type an age from 1 to 120.")
    age = int(input("Age (1 to 120): "))
print(f"Thanks! You are {age}.")

Age (1 to 120): 0
Please type an age from 1 to 120.
Age (1 to 120): 200
Please type an age from 1 to 120.
Age (1 to 120): 15
Thanks! You are 15.

The condition is the Day 4 chained comparison with not in front: “while the age is not between 1 and 120”. The body asks again, which is the line that can make the condition False. If the first answer is already valid, the body runs zero times. (If the user types a word instead of a number, int() still stops with a ValueError; Day 15 shows how to handle that.)

while command != "quit":
    command = input("Command: ").strip().lower()
    print("You typed", command)
print("Goodbye!")

Traceback (most recent call last):
  File ".../day05/keep_asking_no_start.py", line 1, in <module>
    while command != "quit":
          ^^^^^^^
NameError: name 'command' is not defined

password = input("Password: ")
while password != "open sesame":
    print("Wrong, try again.")
    password = input("Password: ")
print("Welcome!")

Password: Open Sesame
Wrong, try again.
Password: open sesame
Welcome!

To print each letter of a word on its own line, you could count positions with a while loop and index each one (Day 3). But “do something with each character” is so common that Python has a loop made for it.

A for loop runs its body once for each item in a sequence. On Day 3 you learned that a string is a sequence of characters, so a for loop over a string runs once per character:

for name in sequence:
    statement

• for is a keyword. name is the loop variable: before each pass, Python assigns the next item to it.
• in is followed by the sequence to go through, then a colon.
• The indented body runs once per item. When there are no items left, the loop ends.

The in here is part of the for statement. It is not the Day 3 in that asks “is this inside that?”, although both read naturally as English.

word = "loop"
for letter in word:
    print(letter)
print("Done")

l
o
o
p
Done

The body can do anything with the loop variable, such as call a method on it or put it in an f-string:

name = "Ana"
for letter in name:
    print(f"Give me {letter.upper()}!")
print(f"What does that spell? {name}!")

Give me A!
Give me N!
Give me A!
What does that spell? Ana!

The loop variable changes on every pass, but the body’s code is the same each time. Line 4 is back at the left edge, so it runs once, after the loop.

word = "loop"
for letter in word:
    letter = letter.upper()
print(word)

loop

message = "a b!"
for ch in message:
    print(f"[{ch}]")

[a]
[ ]
[b]
[!]

Printing the numbers 1 to 100 is not a job about a string. You need a sequence of numbers to loop over.

The built-in function range() makes a sequence of whole numbers for a for loop to go through. It takes up to three arguments:

>>> for n in range(4):
...     print(n)
...
0
1
2
3

>>> for n in range(2, 6):
...     print(n)
...
2
3
4
5

In the REPL, a line ending in a colon starts a block, so the prompt changes to ... for the indented lines. Press Enter on an empty ... line to finish the loop and run it. range(4) starts at 0 and gives four numbers, 0 to 3. range(2, 6) starts at 2 and stops before 6.

Why is the stop value left out of the numbers? Because then range(n) gives exactly n numbers, and the numbers 0 to n - 1 match the indexes of a string of length n (Day 3). Read range(2, 6) as “from 2, stop at 6”.

The third argument, the step, is how much to add each time. A negative step counts down:

>>> for n in range(1, 10, 3):
...     print(n)
...
1
4
7

>>> for n in range(10, 0, -3):
...     print(n)
...
10
7
4
1

range(1, 10, 3) gives 1, 4, 7; the next would be 10, which is not before the stop. range(10, 0, -3) counts down from 10 and stops before reaching 0. With a negative step, start must be bigger than stop, or there are no numbers at all.

>>> 10 in range(1, 10)
False
>>> len(range(1, 10))
9
>>> 10 in range(1, 11)
True
>>> len(range(1, 11))
10

You now have two loops, and many jobs can be done with either. Here is the spelling program from 5.3 written with a while loop and an index:

word = "loop"
index = 0
while index < len(word):
    print(word[index])
    index = index + 1
print("Done")

l
o
o
p
Done

The output is the same, but this version needs three extra pieces: a counter that starts at 0 (line 2), a condition that stops at the length (line 3), and an update (line 5). Each is a place to make a mistake: start at 1 and you skip the first letter; write <= and word[4] stops the program with an IndexError; forget line 5 and the loop never ends. The for loop does all three for you.

A quick test: if you can say “for each…”, use for. If you say “until…” or “as long as…”, use while.

A loop that only prints is useful, but most loops work something out: how many vowels in a sentence, the total of 100 numbers. To get one answer from many passes, the program needs to remember something between passes.

An accumulator is a variable that collects a result across the passes of a loop. The pattern always has three parts:

1. Before the loop: set the accumulator to a starting value (0 for a count or a total).
2. Inside the loop: update it on each pass that matters.
3. After the loop: use the finished result.

A counter is an accumulator that goes up by 1 each time something happens:

text = "Programming is fun"
vowels = 0
for letter in text.lower():
    if letter in "aeiou":
        vowels = vowels + 1
print("Vowels:", vowels)

Vowels: 5

Updating a variable from its own value is so common that Python has a short form. count += 1 means count = count + 1. This is called augmented assignment, and it works with the other arithmetic operators too: -=, *=, and so on. A running total adds each value instead of 1:

total = 0
for number in range(1, 101):
    total += number
print("Sum:", total)

Sum: 5050

range(1, 101) gives 1 to 100, and each pass adds the current number to total.

Strings can accumulate too. Start with the empty string and add characters with +=:

text = "see you soon"
result = ""
for ch in text:
    if ch != " ":
        result += ch
print(result)

seeyousoon

Strings cannot be changed (Day 3), so result += ch builds a new string, one character longer, and stores it in result. This is how to build a changed copy of a string one character at a time.

for number in range(1, 5):
    total = 0
    total += number
print("Sum:", total)

Sum: 4

total = 0
count = 0
for n in range(2, 11, 2):
    if n % 4 == 0:
        count += 1
    total += n
print(count, total)

2 30

A weather station records five temperatures and wants the highest. A total adds every value; here you keep only the best so far, replacing it whenever a bigger value turns up. That is the maximum pattern.

What should “the best so far” be before you have seen any value? Day 2’s None means exactly “no value yet”, and Day 4’s is None checks for it. This run types 12, 17.5, 9, 17, and 14:

highest = None
for day in range(1, 6):
    temp = float(input(f"Day {day}: "))
    if highest is None or temp > highest:
        highest = temp
print("Highest:", highest)

Day 1: 12
Day 2: 17.5
Day 3: 9
Day 4: 17
Day 5: 14
Highest: 17.5

>>> highest = None
>>> 12.0 > highest
Traceback (most recent call last):
  ...
TypeError: '>' not supported between instances of 'float' and 'NoneType'

To find the minimum, the smallest value, use the same pattern with <.

highest = 0
for day in range(1, 6):
    temp = float(input(f"Day {day}: "))
    if temp > highest:
        highest = temp
print("Highest:", highest)

Day 1: -3
Day 2: -1.5
Day 3: -7
Day 4: -4
Day 5: -2
Highest: 0

lowest = 0
for game in range(1, 4):
    score = int(input(f"Game {game} score: "))
    if score < lowest:
        lowest = score
print("Lowest:", lowest)

lowest = None
for game in range(1, 4):
    score = int(input(f"Game {game} score: "))
    if lowest is None or score < lowest:
        lowest = score
print("Lowest:", lowest)

Game 1 score: 72
Game 2 score: 64
Game 3 score: 91
Lowest: 64

Some loops should stop early: once you have found the first digit in a product code, there is no point looking at the rest. Others should skip some items, such as spaces. Python has two statements for these jobs. Both go inside the loop body, usually inside an if.

break ends the loop at once. Python jumps to the first line after the loop, skipping the rest of the body and every remaining pass.

code = "AB7C9"
for ch in code:
    if ch in "0123456789":
        print("First digit:", ch)
        break
    print("Not a digit:", ch)
print("Search over")

Not a digit: A
Not a digit: B
First digit: 7
Search over

A and B are not in "0123456789", so for them the if is skipped and line 6 runs. At 7, the if runs, prints, and break ends the loop. Line 6 does not run for 7, and C and 9 are never looked at.

break gives the “keep asking” loop from 5.2 a common shorter shape: while True: is a loop whose condition never becomes False, so the only way out is a break. This run types hello, then quit:

while True:
    command = input("Command: ").strip().lower()
    if command == "quit":
        break
    print("You typed", command)
print("Goodbye!")

Command: hello
You typed hello
Command: quit
Goodbye!

There is no starting value to set, because the condition no longer uses command. The loop reads first, then decides whether to stop.

continue ends only the current pass. Python skips the rest of the body and goes straight to the next pass (in a while loop, back to the condition check):

for ch in "a b c":
    if ch == " ":
        continue
    print(ch.upper())
print("Done")

A
B
C
Done

For each space, continue skips line 4, so spaces are not printed. The loop itself goes on to the next character.

n = 0
while n < 5:
    if n == 2:
        continue
    print(n)
    n += 1

n = 0
while n < 5:
    n += 1
    if n == 3:
        continue
    print(n)

1
2
4
5

result = ""
for ch in "no-way!out":
    if ch == "-":
        continue
    if ch == "!":
        break
    result += ch
print(result)

noway

After a search loop, you often need to know why it ended: did break stop it because the thing was found, or did it run out of items? Python lets a loop answer that question itself.

A loop can have an else clause, written at the same indentation as for or while. Its block runs when the loop ends normally: a for loop ran out of items, or a while loop’s condition became False. It does not run when break ended the loop. Think of it as “if no break”.

password = "sunshine"
for ch in password:
    if ch in "0123456789":
        print("Has a digit.")
        break
else:
    print("No digits: add one to make it stronger.")

No digits: add one to make it stronger.

password = "sun5hine"
for ch in password:
    if ch in "0123456789":
        print("Has a digit.")
        break
else:
    print("No digits: add one to make it stronger.")

Has a digit.

Notice the indentation: this else lines up with for, not with if. It belongs to the loop. The same works on a while loop: its else runs when the condition becomes False, but not after a break.

password = "ab3"
for ch in password:
    if ch in "0123456789":
        print("Has a digit.")
        break
    else:
        print("No digits.")

No digits.
No digits.
Has a digit.

for n in range(3, 10, 3):
    if n % 2 == 0:
        print("Even:", n)
        break
else:
    print("No even numbers")
print("Done")

Even: 6
Done

A theater has rows A and B, with seats 1 to 3 in each. To list every seat, you need to go through the seats for each row: a loop inside a loop.

A nested loop is a loop inside the body of another loop. The outer loop runs once per row; on every one of its passes, the inner loop runs all the way through.

for row in "AB":
    for seat in range(1, 4):
        print(f"{row}{seat}")
print("All seats listed")

A1
A2
A3
B1
B2
B3
All seats listed

To print a grid, build each row as a string in the inner loop (the string accumulator from 5.6), then print it once the inner loop is done. To line the numbers up in columns, Day 3’s format specifiers can take a width: f"{value:3}" shows a number in at least 3 characters, adding spaces on the left.

for first in range(1, 4):
    line = ""
    for second in range(1, 4):
        line += f"{first + second:3}"
    print(line)

  2  3  4
  3  4  5
  4  5  6

Each row’s value is first + second. line = "" is inside the outer loop, so each row starts empty, and print(line) is at the outer loop’s level, so it runs once per row, after the inner loop has added all three numbers.

for first in range(1, 3):
    line = ""
    for second in range(1, 4):
        line += f"{first + second:3}"
        print(line)

  2
  2  3
  2  3  4
  3
  3  4
  3  4  5

total = 0
for outer in range(1, 4):
    for inner in range(outer):
        total += 1
    print(outer, total)

1 1
2 3
3 6

A for loop over a string gives each character but not its position. To print “Letter 1: c”, you need both. 5.5 got positions from a while loop and a counter. With a for loop, you can go through range(len(word)), the indexes of word, and index with word[index]:

word = "code"
for index in range(len(word)):
    print(index, word[index])

0 c
1 o
2 d
3 e

It works, but you have to index the string yourself. Python has a built-in function that hands you both.

enumerate() goes through a sequence and gives, on each pass, the index and the item together. Give the for loop two loop variable names, separated by a comma: the first receives the index, the second the item.

word = "code"
for index, letter in enumerate(word):
    print(index, letter)

0 c
1 o
2 d
3 e

Same output, and no len, no range, and no word[index]. Day 7 explains how this two-name form works in general.

People usually count from 1, not 0. Pass a second argument, the number to start counting at:

word = "code"
for position, letter in enumerate(word, 1):
    print(f"Letter {position}: {letter}")

Letter 1: c
Letter 2: o
Letter 3: d
Letter 4: e

enumerate(word, 1) only changes the numbers it gives you; the characters are the same, and word[1] is still "o".

for item in enumerate("hi"):
    print(item)

(0, 'h')
(1, 'i')

word = "banana"
for i, letter in enumerate(word):
    if letter == "a":
        print("a at", i)

a at 1
a at 3
a at 5

A teacher types quiz scores one at a time and types done to finish. The program skips anything outside 0 to 100, then reports how many scores it counted, their average, and the highest. This run types 72, 105, 88, 91, and done:

count = 0
total = 0
highest = None
while True:
    entry = input("Score (or done): ").strip().lower()
    if entry == "done":
        break
    score = int(entry)
    if not 0 <= score <= 100:
        print("Skipped: scores run from 0 to 100.")
        continue
    count += 1
    total += score
    if highest is None or score > highest:
        highest = score
if count > 0:
    print(f"{count} scores, average {total / count:.1f}, highest {highest}")
else:
    print("No scores entered.")

Score (or done): 72
Score (or done): 105
Skipped: scores run from 0 to 100.
Score (or done): 88
Score (or done): 91
Score (or done): done
3 scores, average 83.7, highest 91

• while True: with break (5.8) fits because the program cannot know how many scores will be typed.
• continue skips the 105 before any accumulator changes, so it is neither counted nor added.
• The input is checked for done before int(), because int("done") would stop the program with a ValueError.
• After the loop, 251 / 3 is 83.666…, which :.1f shows as 83.7 (Day 3). The if count > 0: guard means that typing done straight away prints a message instead of dividing by zero.

• A while loop repeats while its condition is true and checks before every pass, so its body can run zero times. Something in the body must move the condition toward False, or you get an infinite loop.
• A for loop runs once per item: each character of a string, or each number from range(start, stop, step), which stops before stop. Use for for “each…”, while for “until…”.
• An accumulator is set before the loop, updated inside it, and used after it: counters, running totals, built-up strings, and the largest or smallest value (start that one at None).
• break ends a loop, continue skips to the next pass, and a loop’s else runs only when no break happened.
• In a nested loop, the inner loop runs completely on every outer pass. enumerate() gives each item with its index.

Do these in your day05 folder. Type each program yourself, run it, and only then open the answer.

for number in range(1, 101):
    if number % 15 == 0:
        print("FizzBuzz")
    elif number % 3 == 0:
        print("Fizz")
    elif number % 5 == 0:
        print("Buzz")
    else:
        print(number)

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz

secret = 7
print("I am thinking of a number from 1 to 10.")
for attempt in range(1, 4):
    guess = int(input(f"Guess {attempt} of 3: "))
    if guess == secret:
        print(f"Yes! You got it in {attempt}.")
        break
    elif guess < secret:
        print("Too low.")
    else:
        print("Too high.")
else:
    print(f"Out of guesses. It was {secret}.")

I am thinking of a number from 1 to 10.
Guess 1 of 3: 5
Too low.
Guess 2 of 3: 8
Too high.
Guess 3 of 3: 7
Yes! You got it in 3.

I am thinking of a number from 1 to 10.
Guess 1 of 3: 2
Too low.
Guess 2 of 3: 9
Too high.
Guess 3 of 3: 4
Too low.
Out of guesses. It was 7.

for row in range(1, 6):
    line = ""
    for column in range(1, 6):
        line += f"{row * column:4}"
    print(line)

   1   2   3   4   5
   2   4   6   8  10
   3   6   9  12  15
   4   8  12  16  20
   5  10  15  20  25

n = 0
total = 0
while n < 6:
    n += 1
    if n % 3 == 0:
        continue
    total += n
print(n, total)

6 12

total = 0
for number in range(1, 10):
    total += number
print("Sum of 1 to 10:", total)

total = 0
for number in range(1, 11):
    total += number
print("Sum of 1 to 10:", total)

Sum of 1 to 10: 55

word = "rhythm"
for index, letter in enumerate(word):
    if letter in "aeiou":
        print(f"First vowel at {index}")
        break
else:
    print("No vowels")

No vowels

for a in range(2):
    for b in range(3):
        print(a, b)
    print("--")

0 0
0 1
0 2
--
1 0
1 1
1 2
--

The official Python Tutorial covers today’s loops in More Control Flow Tools: for Statements, The range() Function, break and continue Statements, and else Clauses on Loops. Its for examples loop over lists, which you meet tomorrow on Day 6.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can write a while loop and point to the line that makes it stop. Reread
• I can write a loop that keeps asking until the user types what is needed. Reread
• I can loop over the characters of a string with for. Reread
• I can predict the numbers any range() call gives, including the stop. Reread
• I can choose between for and while and explain why. Reread
• I can count and sum with an accumulator set before the loop. Reread
• I can find the largest or smallest value starting from None. Reread
• I can use break and continue and explain the difference. Reread
• I can use a loop else for "not found". Reread
• I can trace a nested loop and count how many times its body runs. Reread
• I can loop over index and item together with enumerate(). Reread