while Loop Programs

1Program 1 — add up the digits of a number

# add up the digits of a number: 4271 -> 4 + 2 + 7 + 1

num = int(input('Enter a number: '))
number_typed = num
total = 0

while num > 0:
    digit = num % 10
    total = total + digit
    num = num // 10

print('The digits of', number_typed, 'add up to', total)

Enter a number: 4271
The digits of 4271 add up to 14

2Program 2 — how many digits does it have?

# how many digits does a number have?

num = int(input('Enter a number: '))
number_typed = num
count = 0

while num > 0:
    count = count + 1
    num = num // 10

print(number_typed, 'has', count, 'digits')

Enter a number: 4271
4271 has 4 digits

The same skeleton as program 1, with the counter going up by 1 instead of by the digit — so the digit itself is never even read. Recognising that two problems share a shape is most of what practice is for.

Enter a number: 0
0 has 0 digits

3Program 3 — reverse a number

# reverse a number: 4271 -> 1724

num = int(input('Enter a number: '))
number_typed = num
backwards = 0

while num > 0:
    digit = num % 10
    backwards = backwards * 10 + digit
    num = num // 10

print(number_typed, 'reversed is', backwards)

Enter a number: 4271
4271 reversed is 1724

One line does the work: backwards = backwards * 10 + digit. Multiplying by 10 pushes everything collected so far one place to the left, which leaves an empty units place for the new digit. Round by round with 4271, that is 1, then 17, then 172, then 1724.

4Program 4 — is the number a palindrome?

# a palindrome number reads the same backwards: 121, 4554, 7

num = int(input('Enter a number: '))
number_typed = num
backwards = 0

while num > 0:
    digit = num % 10
    backwards = backwards * 10 + digit
    num = num // 10

if backwards == number_typed:
    print(number_typed, 'is a palindrome')
else:
    print(number_typed, 'is not a palindrome')

Enter a number: 4554
4554 is a palindrome

Enter a number: 123
123 is not a palindrome

Program 3 with four lines added, and this is where number_typed stops being a convenience and becomes necessary: the comparison needs the original number, and num is zero by the time the loop ends. Comparing backwards == num would ask whether the reversal equals zero.

num = int(input('Enter a number: '))
number_typed = num
backwards = 0

while num > 0:
    digit = num % 10
    backwards = backwards * 10 + digit
    num = num // 10

if backwards == number_typed:
    print(number_typed, 'is a palindrome')
else:
    print(number_typed, 'is not a palindrome')

5Program 5 — keep asking until the user says stop

# keep asking for marks until 0 is typed, then report the total

total = 0
count = 0

mark = int(input('Enter a mark (0 to stop): '))

while mark != 0:
    total = total + mark
    count = count + 1
    mark = int(input('Enter a mark (0 to stop): '))

print('You entered', count, 'marks')
print('Their total is', total)

Enter a mark (0 to stop): 45
Enter a mark (0 to stop): 78
Enter a mark (0 to stop): 62
Enter a mark (0 to stop): 0
You entered 3 marks
Their total is 185

This is the program a for loop cannot write. Nobody — not the programmer, not the user — knows how many marks there will be until the 0 arrives. A value that means “that is the lot” like this one is called a sentinel, and it is never added to the total, because the loop ends before the body is reached.

6Program 6 — a countdown

# a countdown, which a for loop would do just as well

n = int(input('Count down from: '))

while n > 0:
    print(n)
    n = n - 1

print('Lift off!')

Count down from: 5
5
4
3
2
1
Lift off!

Here the count is known in advance, so for i in range(n, 0, -1): would do the same job in one line fewer and could not be made to run for ever. Both are correct; for is the better answer to this particular question. Being able to say why is worth more than either program.

7The two endless loops that pass the checklist

The rule at the top of this page — set up, test, change — catches the commonest endless loop, the one with no update line at all. It does not catch these two, and that is exactly why they are worth meeting: both have all three parts present and correct, and neither ever finishes.

The first one changes the loop variable, faithfully, in the wrong direction:

# count down to zero -- except the counter goes the wrong way

i = 5

while i > 0:
    print(i)
    i = i + 1

print('Done')

5
6
7
8
9
10
11
12

Every part is there: i is set up before the loop, tested in the header, and changed in the body. But the test asks is i still above zero? and the change makes i bigger. The condition was true at 5 and every round makes it more true. We ran it with a round cap rather than let it go: after eight rounds i was 13 and i > 0 was still True. One character fixes it — i = i - 1 — and then it prints 5, 4, 3, 2, 1 and Done.

The second is nastier, because the fault is in a line that was added to help. This program accepts a capital or a small letter — and then waits for a value that can now never arrive:

# keep going until the user types q -- which this program can never notice

letter = input('Type a letter (q to quit): ')
letter = letter.upper()

while letter != 'q':
    print('You typed', letter)
    letter = input('Type a letter (q to quit): ')
    letter = letter.upper()

print('Goodbye')

Type a letter (q to quit): q
You typed Q
Type a letter (q to quit): q
You typed Q
Type a letter (q to quit): q
You typed Q
Type a letter (q to quit): q
You typed Q

letter.upper() turns every answer into a capital, so the q the user types is 'Q' by the time the condition sees it — and 'Q' != 'q' is True. The loop is waiting for a value the program has made impossible. Change the condition to while letter != 'Q': and it quits on the first q, capital or not, which is what the upper() was for in the first place.

8Recap