Flags

When talking about loops, we must talk about flags. A flag is a simple variable, often being a boolean, in which it acts as an indicator or signal to represent a condition or state in the program. Think of it as a literal flag, when some condition is met, we might raise it up or down. It could be used to:

• Signify that something has happened.
• Signify that we need to stop looping.

Flags are an essential concept for any developer to know. A great example would be to write a program which keeps asking the user to provide a positive integer, until the user provides a negative one, and when that happens, we exit the loop, and print the sum of the positive numbers entered.

1
running = True
2
total = 0
3
while running:
4
  num = int(input("Please enter a positive number: "))
5
  if num < 0: # <-- The user has entered a negative number
6
    running = False # so we change the state to exit
7
  else:
8
    total += num
9
print("The sum of the positive numbers is:", total)

Another example would be to check if a number is prime, to do so, we may suppose that it is prime, then we check all the numbers from 2 upto that number and if there is any divisor, we flip the state to not prime.

1
n = int(input("Please enter a number to check for prime: "))
2
is_prime = True
3

4
if n > 1:
5
  i = 2
6
  while is_prime and i < n:
7
    if n % i == 0:
8
      is_prime = False
9
    i += 1
10

11
  if is_prime:
12
    print(n, "is prime")
13
  else:
14
    print(n, "is not prime")
15
else: # anything less than 2 is not a prime
16
  print(n, "is not a prime number");

If the above code is too messy, maybe we could just remove the check for positive input, and assume the user enters a positive number:

1
n = int(input("Please enter a number to check for prime: "))
2
is_prime = True
3
i = 2
4
while is_prime and i < n:
5
  if n % i == 0:
6
    is_prime = False
7
  i += 1
8

9
# Now we check our flag
10
if is_prime:
11
  print(n, "is prime")
12
else:
13
  print(n, "is not prime")

It doesn’t have to be purely about loops, we could use it with if statements too:

1
has_permission = False
2

3
username = input("Please enter your username")
4
password = input("Please enter your password")
5

6
if username == "admin" and password == "some_secret_password":
7
  has_permission = True
8

9

10
if has_permission:
11
  print("You have permission to execute this action")
12
else:
13
  print("You do not have permission to do this action")

Infinite loops

A loop that runs forever, or at least without a bound/condition is said to be an infinite loop. Sometimes we want infinite loops, but most of the times, they are just made by mistake as a bug.

Funny

Bug means a flaw or a glitch in some system. The first ever bug in computers was discovered in 1947, where a moth was discovered to be stuck in the relays of the Mark II computer at Harvard, being the first ever recorded incident of a bug taking place. This incident gave the literal twist and helped popularize it in computing.

An example of an infinite loop would be:

1
while True:
2
  print("Hello")

This code will print the string "Hello" to the screen forever (or until your PC turns off). This isn’t something entirely useful. Practically, we use it to keep checking until some condition or event has occurred. Let’s say that we want to copy files to the USB, but wait the user didn’t plug-in the usb, so we keep checking until this even happen, and so we can copy the files:

1
while check_for_usb():
2
    wait_some_time() # Wait so that we don't exhuast the system by always checking
3
    copy_files()

There are more practical examples, like a web server, which waits for web requests to take place, then process them, and repeats this cycle.

1
while True:
2
  check_for_requests()
3
  process_pending_tasks()

Or maybe a game. In a game we check if there is any user input, update the game (if necessary), and finally redraw the screen.

1
while True:
2
  #if the mouse moves, or a keypress/release takes place
3
  handle_input()
4
  update_game_state()
5
  redraw_game_canvas()

Nested loops

As we have seen, loops help us repeat code blocks, but what if we want to repeat a repeated code! Meet nested loops. A nested loop is essentially a loop inside a loop, in other words, while the outer loop runs, the inner loop executes, and once the inner code completely finishes execution (the inner loop completed along with anything else), we count it as one full iteration for the outer loop. We might visualize it as follows:

1
Outer Loop -> starts its first iteration
2
   |
3
   -> Inner Loop -> runs fully
4
Outer Loop → starts its second iteration
5
   |
6
   -> Inner Loop -> runs fully again

A basic example would be:

1
i = 1
2
while i <= 2:
3
  j = 1
4
  while j <= 3:
5
    print("i =", i, "j =", j)
6
    j += 1
7
  i += 1

Execution steps:

• i is set to 1
• i <= 2 -> Outer loop starts with its first iteration
• • j is set to 1
• • j <= 3 -> Inner loop starts with its first iteration
• • print i = 1 j = 1
• • j becomes 2
• • j <= 3 -> Inner loop starts with its second iteration
• • print i = 1 j = 2
• • j becomes 3
• • j <= 3 -> Inner loop starts with its third iteration
• • print i = 1 j = 3
• • j becomes 4
• • j <= 3 is False so the inner loop finishes
• i becomes 2
• i <= 2 -> Outer loop starts with its second iteration
• • j is set to 1
• • j <= 3 -> Inner loop starts with its first iteration
• • print i = 2 j = 1
• • j becomes 2
• • j <= 3 -> Inner loop starts with its second iteration
• • print i = 2 j = 2
• • j becomes 3
• • j <= 3 -> Inner loop starts with its third iteration
• • print i = 2 j = 3
• • j becomes 4
• • j <= 3 is False so the inner loop finishes
• i becomes 2
• i < 2 is False so the outer loop finishes

Wow, that was too much right? Let’s print out the following pattern:

1
****
2
****
3
****

But with a catch, the width (number of starts on each row), and height (number of stars on each column) is given by the user:

1
width = int(input("What is the width of your pattern? "))
2
height = int(input("What is the height of your pattern? "))
3

4
i = 0
5
while i < height:
6
  j = 0
7
  while j < width:
8
    print("*", end="")
9
    j += 1
10
  print()
11
  i += 1

Note

The order of the loops (height before width) matters, as it generates a different grid formation.

We have seen in the previous section how to check if a number is prime or not, what if we wanted to print all the numbers inside the range [2,1000], how can we do that? We could use the code previous made as our starting point:

• First we loop over the range from 2 to 1000
• For each number, we label it as prime
• Instead of reading the number from the user, we use this loop’s iterator

1
n = 2 # <-- keeping it as `n` to make the two code snippets more similar
2
while n < 1000:
3
  # add the code that was previously used to check if a number is prime or not
4
  # remove the input as we wont be reading from the user
5
  n = n + 1

Doing all of that would yield:

1
n = 2 # <-- keeping it as `n` to make the two code snippets more similar
2
while n < 1000:
3
  # Primality test
4
  is_prime = True
5
  i = 2
6
  while is_prime and i < n:
7
    if n % i == 0:
8
      is_prime = False
9
    i += 1
10

11
  # Now we check our flag
12
  if is_prime:
13
    print(n, "is prime")
14
  else:
15
    print(n, "is not prime")
16

17
  n = n + 1

Exercises

Below are exercises to practice while loops. Try solving them on your own before checking the solutions.

1
i = 1
2
while i <= 100:
3
    print(i)
4
    i += 1

1
total = 0
2
i = 1
3
while i <= 100:
4
    if i % 2 == 0:
5
        total += i
6
    i += 1
7
print(total)

1
total = 0
2
isPositive = True
3
while isPositive:
4
    num = int(input())
5
    if num >= 0:
6
        total += num
7
    else:
8
        isPositive = False
9
print(total)

1
n = int(input())
2
factorial = 1
3
i = 1
4
while i <= n:
5
    factorial *= i
6
    i += 1
7
print(factorial)

1
x = int(input())
2
y = int(input())
3
result = 1
4
i = 1
5
while i <= y:
6
    result *= x
7
    i += 1
8
print(result)

1
num = int(input())
2
largest = num
3
while num != 0:
4
    if num > largest:
5
        largest = num
6
    num = int(input())
7
print(largest)

1
5 x 1 = 5
2
5 x 2 = 10
3
5 x 3 = 15
4
...
5
5 x 10 = 50

1
n = int(input())
2
i = 1
3
while i <= 10:
4
    print(n, 'x', i, '=', n * i)
5
    i += 1

1
*
2
**
3
***
4
****

1
n = int(input())
2
i = 1
3
while i <= n:
4
    j = 1
5
    while j <= i:
6
        print('*', end='')
7
        j += 1
8
    print()
9
    i += 1

1
a = int(input())
2
b = int(input())
3
while b != 0:
4
    temp = b
5
    b = a % b
6
    a = temp
7
print(a)

1
n = int(input())
2
sum_divisors = 0
3
i = 1
4
while i < n:
5
    if n % i == 0:
6
        sum_divisors += i
7
    i += 1
8
if sum_divisors == n:
9
    print('Perfect')
10
else:
11
    print('Not Perfect')

1
num = int(input())
2
count = 0
3
if num != 0:
4
    while num > 0:
5
        count += 1
6
        num //= 10
7
else:
8
    count = 1
9
print(count)

1
num = int(input())
2
reversed_num = 0
3
while num > 0:
4
    digit = num % 10
5
    reversed_num = reversed_num * 10 + digit
6
    num //= 10
7
print(reversed_num)

1
num = int(input())
2
original = num
3
sum_cubes = 0
4
while num > 0:
5
    digit = num % 10
6
    sum_cubes += digit * digit * digit
7
    num //= 10
8
if sum_cubes == original:
9
    print('Armstrong')
10
else:
11
    print('Not Armstrong')