Loops: for, while, step, break, continue and nested loops

Suppose you must count the numbers from 1 to 1000 that are divisible by 7. Write if a thousand times? Never! A loop repeats a group of commands as many times as needed. In the four entrance-exam papers of 2025–2026 the most frequent topic was exactly “Loops. Operations on numbers”: 14 of the 120 informatics tasks. In this lesson you will learn to build loops and, above all, to trace them without mistakes using a trace table.

The for loop and range(): the step

The range function produces a sequence of whole numbers and has three forms: range(b) — 0, 1, …, b − 1; range(a, b) — a, a + 1, …, b − 1; range(a, b, d) — a, a + d, a + 2d, … The third number d is the step of the loop variable. With d > 0 the numbers grow until they reach b; with d < 0 they shrink until they reach b. The stop value b is never included — “up to b, without b”.

for i in range(10, 0, -3):
    print(i)
print(len(range(3, 20, 4)), len(range(20, 121)))

10
7
4
1
5 101

for works not only over range but over any sequence: for ch in 'Baku': takes the characters of a string one by one, and for x in [4, 9, 2]: the elements of a list. This will be used widely in the lessons “Strings and string operations” and “Lists and list operations”; in this lesson we work with numbers, that is, with range.

Counters and accumulators: conditions inside a loop

A loop often counts or adds up something. For that a variable gets a starting value before the loop and is updated inside the loop on every suitable iteration. A conditional statement inside the loop acts as a “filter”: only the values that satisfy the condition are counted or added.

• counter: k = 0, in the loop k = k + 1 — how many times the condition held;
• accumulator (sum): s = 0, in the loop s = s + x — the sum of the values;
• product: p = 1 (not 0 — otherwise the result is always 0), in the loop p = p * x.

s = 0
p = 1
k = 0
for i in range(1, 11):
    if i % 2 == 1:
        s = s + i
    else:
        p = p * i
    if i % 3 == 0:
        k = k + 1
print(s, p, k)

25 3840 3

The same pattern finds the largest (or smallest) value: before the loop mx gets the first value (or a number smaller than any possible one), and inside the loop if x > mx: mx = x is checked. So when the loop ends, mx holds the largest of the values seen. In all these patterns the loop looks at every value once and “collects” the result step by step.

k = 0
for n in range(30, 131):
    if n % 2 == 0 and n < 100:
        if n % 7 == 0 or n % 9 == 0:
            k = k + 1
    else:
        k = k + 2
print(k)

141

The while loop and the trace table

A while condition: loop repeats its body as long as the condition is true. The condition is checked before every iteration, so this is a pre-condition loop: if the condition is false from the start, the body does not run even once. The body must change a variable used in the condition, otherwise the loop never ends. When the loop finishes, the condition is false: the variable holds the first value that broke it. while is chosen when the number of repetitions is not known in advance: “until the sum passes 1000”, “until the digits of the number run out”.

Any for loop can be written with while: for i in range(a, b, d): (d > 0) is the same as i = a, while i < b:, the body, and i = i + d at the end of the body. This translation helps with the loops of flowcharts: there too the loop variable gets a start value, the condition is checked, and after the body the variable changes by the step (see “Loop algorithms and trace tables”).

n = 0
k = 1
while k <= 15:
    n = n + k
    if k % 4 == 0:
        k = k + 1
    else:
        k = k + 3
print(n + k)

68

A trace table writes down the variables row by row for every iteration: the value when the condition is checked, the result of the condition and the values after the body. For the program above:

When each new value is computed from earlier values, the loop produces a recurrence. The best known is the Fibonacci sequence: 1, 1, 2, 3, 5, 8, …, where every term is the sum of the two before it. In a program two variables hold the last two terms and “slide one step forward” on every iteration: c = a + b, a = b, b = c. The order of the assignments matters: if a = b came before c is computed, the old a would be lost.

a = 1
b = 1
for i in range(3, 11):
    c = a + b
    a = b
    b = c
print(b)

55

break and continue

break stops the loop at once and completely: the remaining iterations are cancelled and the program goes to the line after the loop. continue does not stop the loop — it only skips the rest of the current iteration and moves on to the next one (in for the loop variable takes its next value, in while the condition is checked again). In nested loops both affect only the innermost loop. When a for loop is stopped by break, the loop variable keeps the value it had at that moment.

s = 0
for i in range(1, 50, 3):
    if i % 5 == 0:
        continue
    if s > 40:
        break
    s = s + i
print(i, s)

19 41

n = 100
while True:
    n = n + 1
    if n % 7 == 0 and n % 13 == 0:
        break
print(n)

182

Nested loops

A loop body can contain another loop — these are nested loops. On every iteration of the outer loop the inner loop runs from start to finish, and the inner variable starts again each time. Think of a clock: when the minute hand (the outer loop) moves one mark, the second hand (the inner loop) makes a full circle. The inner loop’s limit may depend on the outer variable (range(i, 6)) — then the inner loop runs a different number of times on each outer iteration.

for a in range(1, 25):
    for b in range(a, 25):
        if a * b == 24:
            print(a, b)

1 24
2 12
3 8
4 6

k = 0
for i in range(1, 5):
    for j in range(i, 6):
        if j % 4 == 0:
            break
        k = k + i
print(k)

10

k = 0
# for n in range(...):

print(k)

27

a = 1
b = 1
# while ...:

print(b)

1597