Module 7 review: loops, sections 4.1, 4.3, and 4.5

Section 4.1

The while Loop

An if statement runs a block of code at most once. A while loop runs the same block over and over, checking the same condition again before every single pass.

A while loop repeats a block of indented statements for as long as its condition evaluates to True. The condition is tested before the body ever runs, and again before every repeat, which is why a while loop is called a pretest loop: if the condition is False the very first time, the body never executes at all, not even once.

The three parts, in code

The flowchart above is this exact program. Notice the loop variable count appears in all three places the diagram calls out: it is set once before the loop, tested in the while line, and changed once per pass through the body.

count = 1                 # 1. initialize

while count <= 5 :        # 2. condition, tested before every pass
    print(count)
    count = count + 1      # 3. update, moves toward making the condition False

print("Done")

A loop whose number of passes is known in advance, like the one above, is called a definite loop. A loop that depends on something not known ahead of time, like user input, is an indefinite loop. Section 4.3 is built entirely out of indefinite loops.

Three more ways a while loop can misbehave

"Forgot the update" is not the only way to write an infinite loop, and these three show up constantly in trace-the-code questions:

• Updating in the wrong direction. while i < 5 : paired with i = i - 1 moves i further from satisfying the condition every pass, not closer. Something changes every time, but the loop still never ends.
• != can get skipped right over. while i != 9 : looks like it stops at 9, but if i starts at 1 and increases by 2, it visits 1, 3, 5, 7, 9 and actually would stop there. Change the step to i = i + 3 instead, and it visits 1, 4, 7, 10, 13…, sails straight past 9, and never stops. < or <= cannot be skipped over this way; != can.
• Only the variable in the condition matters. A loop can update several variables every pass and still be infinite, if the one actually named in the while line is not one of them:

year = 0
rate = 5
principal = 10000

while year < 10 :
    interest = (principal * year * rate) / 100
    print("Interest", interest)
    # year is never updated here -- infinite loop,
    # even though interest changes every single pass

When the loop body changes its own loop variable

A loop variable does not have to change only on the update line at the bottom. An if inside the body can reassign it too, which lets a loop skip ahead or cut itself short early:

i = 1
while i < 10 :
    print(i, end = " ")
    i = i + 2
    if i == 5 :
        i = 9

Tracing i through every pass. The jump happens the moment i becomes exactly 5, which only the if catches.

Pass	i at print	i after i = i + 2	if i == 5 fires?
1	1	3	no
2	3	5	yes → i = 9
3	9	11	no — loop exits, 11 < 10 is False

Output: 1 3 9. Notice 5 and 7 never print; the if jumped i from 5 straight to 9 before the next check. The lesson is the same as above: trace the condition's exact variable after every line that could touch it, including lines inside an if, not only the update line you expect.

Tracing the condition itself

Because the test happens before the body, the loop checks count <= 5 one extra time, at count == 6, and that is the check that finally stops it. Tracing every single check, not just the ones that pass, is the easiest way to catch an off-by-one mistake before it ever becomes a bug:

A loop that accumulates, not just counts

The loop variable does not have to be the thing you print. Here, number plays the same three-part role as count did above, while a second variable, total, builds up a running sum one pass at a time:

total = 0
number = 1

while number <= 10 :
    total = total + number
    number = number + 1

print("Sum:", total)

Tracing total and number through every pass of the loop above.

Pass	number	total after this pass
1	1	1
2	2	3
3	3	6
4	4	10
5	5	15
…	…	…
10	10	55

This pattern, a variable that starts at 0 and gets added to once per pass, is called an accumulator. It comes back constantly in Section 4.5.

Looping over a string by index

A string's characters can be visited the same way: an index variable plays the loop-variable role, and s[i] pulls out one character per pass. Forward, starting the index at 0 and stopping before len(s), visits every character; starting the index at len(s) - 1 and stopping once it drops below 0 visits them in reverse:

s = "abcde"
i = 0
while i < len(s) :         # forward
    print(s[i])
    i = i + 1
# prints a b c d e

j = len(s) - 1
while j >= 0 :              # backward
    print(s[j])
    j = j - 1
# prints e d c b a

Section 4.3

Application: Processing Sentinel Values

The loops in Section 4.1 all knew their count in advance: five rides, ten numbers. A sentinel loop is for when you have no idea how many inputs are coming, and the user tells the program when to stop.

A sentinel value is a special input value that is not real data at all; it exists only to signal "there is nothing more to process." A sentinel has to be something that could never be a legitimate value in the actual data, such as -1 for a list of quiz scores that are always 0 or higher, or an empty string for a list of names.

Why the value gets read twice

The read before the loop is called a priming read, and it exists so the while condition has something to test on its very first check. Without it, the condition would have nothing to compare on pass zero. The second read, at the bottom of the loop body, replaces that value with the next one, which is exactly what the condition checks the next time around.

total = 0
count = 0

score = int(input("Enter a score (-1 to stop): "))   # priming read

while score != -1 :
    total = total + score
    count = count + 1
    score = int(input("Enter a score (-1 to stop): "))  # read next

print("Total:", total)
print("Count:", count)

A sentinel does not have to be a number

Any value that can never legitimately appear in the data works as a sentinel, including an empty string. Pressing Enter with no text produces "", which makes a natural stop signal for a loop that collects names:

name = input("Enter a name (press Enter to stop): ")   # priming read
count = 0

while name != "" :
    count = count + 1
    print("Hello,", name)
    name = input("Enter a name (press Enter to stop): ")  # read next

print("Greeted", count, "people")

A sentinel does not have to be a single exact value

The stop condition can also be a general rule instead of one magic number. A loop collecting only positive scores can simply stop the moment a value fails to be positive, letting the condition that defines "real data" double as the sentinel check:

total = 0
count = 0

value = int(input("Enter a positive value (0 or less stops): "))

while value > 0 :
    total = total + value
    count = count + 1
    value = int(input("Enter a positive value (0 or less stops): "))

Here anything that is not positive ends the loop, not just one specific number. The logic is identical to the -1 version above, just phrased as a range instead of an exact match.

Controlling a sentinel loop with a flag variable

Instead of testing the sentinel directly in the while line, some programs use a separate bool variable, often named done, that starts False and gets explicitly set to True once the stop condition is detected inside the loop. The loop shape is while not done : instead of while value != sentinel ::

done = False

while not done :
    letter = input("Enter a letter (Q to stop): ")
    if letter == "Q" :
        done = True
    else :
        print("You entered:", letter)

Guarding against a sentinel that never arrives

If there is any chance a sentinel might never show up, such as reading from a file that could be malformed, combining the sentinel check with a maximum count using and keeps the loop from running forever:

count = 0
value = input("Enter a value, Q to quit: ")

while count < 100 and value != "Q" :
    count = count + 1
    value = input("Enter a value, Q to quit: ")

This loop stops whichever comes first: the user typing Q, or 100 values having been entered. Both halves of the and have to still be true for the loop to continue.

Section 4.5

Common Loop Algorithms

Almost every loop you will write this term is a small variation on one of three patterns: adding things up, counting things, and finding the biggest or smallest thing. Learn the shape once and you will recognize it everywhere.

Sum and average

This is the accumulator from Section 4.1, applied to sentinel-terminated input from Section 4.3. total and count are both initialized to 0 before the loop; the average is only computed after the loop, and only if at least one value was actually entered.

total = 0
count = 0

score = int(input("Enter a score (-1 to stop): "))

while score != -1 :
    total = total + score
    count = count + 1
    score = int(input("Enter a score (-1 to stop): "))

if count > 0 :
    average = total / count
    print("Average:", average)
else :
    print("No scores were entered.")

Counting matches

A counting loop adds 1 to a counter only when a condition is met, instead of adding every value unconditionally. The accumulator and the condition from Section 4.3 combine directly:

passingCount = 0

score = int(input("Enter a score (-1 to stop): "))

while score != -1 :
    if score >= 60 :
        passingCount = passingCount + 1
    score = int(input("Enter a score (-1 to stop): "))

print("Passing scores:", passingCount)

Finding a maximum (or minimum)

To track the largest value seen so far, use the first real value as a starting guess, then compare every later value against it, replacing the guess whenever something bigger comes along:

highest = int(input("Enter a score (-1 to stop): "))   # first value is the first guess
score = highest

while score != -1 :
    if score > highest :
        highest = score
    score = int(input("Enter a score (-1 to stop): "))

print("Highest score:", highest)

Comparing consecutive values

Some problems care about how a value relates to the one entered right before it, not the whole data set. The trick is a variable, usually named previous, that is set to the old value before the new one overwrites it:

letter = input("Enter a letter (Enter to stop): ")

while letter != "" :
    previous = letter
    letter = input("Enter a letter (Enter to stop): ")
    if letter == previous :
        print("Duplicate entry:", letter)

Searching until found

A search loop stops as soon as it finds what it is looking for, not after a fixed number of passes. The usual shape pairs a bool flag with a position counter, and the loop condition checks both: keep going while not yet found and still more to check.

s = "abcdEfghI"
position = 0
found = False

while position < len(s) and not found :
    if s[position].isupper() :
        found = True
    else :
        position = position + 1

print("First uppercase letter is at position", position)

All five patterns side by side. Each is the same accumulator shape with a different update rule.

Goal	Before the loop	Each pass through the loop	After the loop
Sum / average	total = 0, count = 0	total += value, count += 1	average = total / count
Counting matches	matchCount = 0	if condition: matchCount += 1	use matchCount directly
Maximum / minimum	best = first value	if value beats best: best = value	use best directly
Comparing consecutive values	read one value first	previous = current, read next, compare	— (acts as it goes)
Searching until found	found = False, position = 0	if match: found = True, else advance position	use position or found

Combining all three in one pass

Nothing stops a single loop from updating more than one accumulator at a time. This version computes the sum, the count, and the highest score, all from the same sentinel-terminated input, in one trip through the data:

total = 0
count = 0

score = int(input("Enter a score (-1 to stop): "))
highest = score

while score != -1 :
    total = total + score
    count = count + 1
    if score > highest :
        highest = score
    score = int(input("Enter a score (-1 to stop): "))

if count > 0 :
    print("Average:", total / count)
    print("Highest:", highest)

Quick check