Flow of Control

Every program is a list of instructions. Flow of control means the order in which those instructions actually run when you press Run. Python's default order is the simplest one possible: top to bottom, one line after another, each line exactly once. That is called sequential flow.

Worked example 1 — pure sequential flow

price = 250
qty = 3
total = price * qty
print("Total bill = Rs", total)
print("Thank you")

Real output:

Total bill = Rs 750
Thank you

Five lines, five steps, in that order. Nothing is skipped and nothing repeats. But a real program has to make decisions ("if the balance is low, warn the user") and repeat work ("print the table of 7, ten lines"). So Python gives you two more kinds of flow.

Kind of flow	What it does	Statements used
Sequential	Runs every statement once, in written order	plain statements
Conditional (selection)	Chooses which block to run, based on a condition	if, if-else, if-elif-else
Iterative (repetition)	Runs the same block again and again	for, while

Worked example 2 — all three flows in one program

fare = 0                      # sequential
for stop in range(1, 4):      # iterative
    fare = fare + 120         #   inside the loop body
    if fare > 200:            #   conditional, nested inside the loop
        print("Stop", stop, "-> fare Rs", fare, "(above Rs 200)")
    else:
        print("Stop", stop, "-> fare Rs", fare)
print("Final fare = Rs", fare)   # sequential again

Real output:

Stop 1 -> fare Rs 120
Stop 2 -> fare Rs 240 (above Rs 200)
Stop 3 -> fare Rs 360 (above Rs 200)
Final fare = Rs 360

Indentation is not decoration. In Python it is syntax. C, C++ and Java mark a block with braces { }, and indentation there is only for looks — you can delete every space and the program still compiles. Python threw the braces away and promoted the indentation itself to be the block marker. The gain is that ugly, misleading layout cannot exist: what your eye sees is exactly what the interpreter sees. The price is that a single stray space is an error.

The rules are short:

1. A header line (if, elif, else, for, while) must end with a colon :.
2. The statements belonging to that header — its block or suite — must be indented further than the header.
3. Every line of one block must be indented by exactly the same amount.
4. The block ends at the first line that goes back to a smaller indentation.
5. Use 4 spaces per level. Never mix tabs and spaces.

Worked example 3 — the error you will meet on day one. Saved as demo.py:

marks = 82
if marks >= 33:
print("Pass")

Real output:

  File "demo.py", line 3
    print("Pass")
    ^^^^^
IndentationError: expected an indented block after 'if' statement on line 2

The colon promised a block, and no block arrived. The opposite mistake gives the opposite message:

total = 0
  total = total + 5
print(total)

  File "demo.py", line 2
    total = total + 5
IndentationError: unexpected indent

And if you indent one line with a Tab key and the next with the space bar inside the same block:

if True:
	print("this line uses a TAB")
        print("this line uses 8 SPACES")

  File "demo.py", line 3
    print("this line uses 8 SPACES")
TabError: inconsistent use of tabs and spaces in indentation

Python 3 refuses to guess how wide your Tab is, so it stops. Set your editor to "insert spaces" once and you will never see this again.

Worked example 4 — the dangerous one: no error, wrong answer

These two versions differ by four spaces on one line. Both run cleanly. They do different things.

# Version A - the second print is INSIDE the if block
marks = 20
if marks >= 33:
    print("Pass")
    print("Report card printed")
print("--- A over ---")

# Version B - the second print is OUTSIDE the if block
marks = 20
if marks >= 33:
    print("Pass")
print("Report card printed")
print("--- B over ---")

Real output:

--- A over ---
Report card printed
--- B over ---

Version A printed nothing for a failing student, which is right. Version B printed "Report card printed" for a student who scored 20, which is wrong — because that line is no longer part of the if. This is the single most common Python bug in Class 11 practicals, and no error message will warn you.

One more small thing: a block can never be empty. If you want a block that does nothing yet, use the pass statement.

attendance = 0
if attendance == 0:
    pass          # to be filled in later
else:
    print("Present")
print("Program continues")

Real output:

Program continues

A condition is any expression that Python can judge True or False — usually built from the relational operators ==, !=, <, >, <=, >= and joined with and, or, not. A conditional statement uses that judgement to decide which block of code to run.

1. The plain if — the block runs only if the condition is True; otherwise it is skipped entirely.

balance = 4500
if balance < 5000:
    print("Low balance. Please recharge your UPI wallet.")
print("Done checking")

Real output:

Low balance. Please recharge your UPI wallet.
Done checking

2. if-else — exactly one of the two blocks runs, never both, never neither.

age = 16
if age >= 18:
    print("Eligible to vote")
else:
    print("Not eligible to vote")
    print("Wait for", 18 - age, "more years")

Real output:

Not eligible to vote
Wait for 2 more years

Here is that decision drawn as a flowchart, the form CBSE asks you to produce. A diamond is a decision with two labelled exits; a rectangle is a process; a rounded box is start/stop.

            +-------------------+
            |      START        |
            +-------------------+
                      |
                      v
            +-------------------+
            |    read marks     |
            +-------------------+
                      |
                      v
                  /---------\
                 /  marks    \    No
                 \  >= 33 ?  /----------+
                  \---------/           |
                      | Yes             v
                      v            +----------+
                +----------+       | print    |
                | print    |       | "Fail"   |
                | "Pass"   |       +----------+
                +----------+            |
                      |                 |
                      +--------+--------+
                               v
                          +---------+
                          |  STOP   |
                          +---------+

3. if-elif-else — a ladder for more than two outcomes. Python tests the conditions strictly top to bottom, runs the block of the first one that is True, and then jumps past the whole ladder. At most one block ever runs.

marks = 73
if marks >= 91:
    grade = "A1"
elif marks >= 81:
    grade = "A2"
elif marks >= 71:
    grade = "B1"
elif marks >= 61:
    grade = "B2"
elif marks >= 33:
    grade = "Pass"
else:
    grade = "E (needs improvement)"
print("Marks:", marks, "-> Grade:", grade)

Real output:

Marks: 73 -> Grade: B1

Notice that 73 >= 61 and 73 >= 33 are also True — but Python never reaches those tests, because it stopped at the first True one. Drawn as a flowchart the ladder is a staircase of diamonds, each "No" exit feeding the next test:

              +---------+
              |  START  |
              +---------+
                   |
                   v
               /-------\
              / c1 ?    \  No      /-------\
              \         /-------> / c2 ?    \  No      +----------+
               \-------/          \         /-------> | block C  |
                   | Yes           \-------/          | (else)   |
                   v                   | Yes          +----------+
              +---------+              v                    |
              | block A |         +---------+               |
              +---------+         | block B |               |
                   |              +---------+               |
                   |                   |                    |
                   +---------+---------+--------------------+
                             v
                        +---------+
                        |  STOP   |
                        +---------+

That staircase is exactly why the order of a ladder matters. Write the same tests in the wrong order and the ladder breaks:

marks = 95
if marks >= 33:
    grade = "Pass"
elif marks >= 91:
    grade = "A1"
else:
    grade = "Fail"
print(grade)

Real output:

Pass

A 95 was labelled just "Pass" and the A1 branch became unreachable. In a ladder of overlapping ranges, always test the narrowest (most extreme) condition first.

4. Nested if — an if inside the block of another if, used when the second question only makes sense after the first is answered.

bill = 3200
member = True

if bill >= 2000:
    if member:
        discount = 0.20
    else:
        discount = 0.10
else:
    discount = 0.0

print("Bill Rs", bill)
print("Discount =", int(discount * 100), "%")
print("Payable = Rs", bill - bill * discount)

Real output:

Bill Rs 3200
Discount = 20 %
Payable = Rs 2560.0

In a nested if, an else belongs to the if at its own indentation level. That is one more thing indentation decides for you.

Syllabus program A — absolute value without abs()

for n in [-17, 0, 17]:
    if n < 0:
        result = -n
    else:
        result = n
    print("n =", n, "-> absolute value =", result)

Real output:

n = -17 -> absolute value = 17
n = 0 -> absolute value = 0
n = 17 -> absolute value = 17

Syllabus program B — divisibility of a number

n = int(input("Enter a number: "))
if n % 3 == 0 and n % 5 == 0:
    print(n, "is divisible by both 3 and 5")
elif n % 3 == 0:
    print(n, "is divisible by 3 only")
elif n % 5 == 0:
    print(n, "is divisible by 5 only")
else:
    print(n, "is divisible by neither 3 nor 5")

Real output for four separate runs. The number you type sits on the same line as the prompt, which is why each transcript line below looks like one sentence:

Enter a number: 45 is divisible by both 3 and 5
Enter a number: 9 is divisible by 3 only
Enter a number: 20 is divisible by 5 only
Enter a number: 22 is divisible by neither 3 nor 5

The "both" test has to come first for the same ordering reason as the grade ladder.

Syllabus program C — sort three numbers using only conditionals

a, b, c = 47, 12, 30

if a <= b and a <= c:
    small = a
    if b <= c:
        mid, large = b, c
    else:
        mid, large = c, b
elif b <= a and b <= c:
    small = b
    if a <= c:
        mid, large = a, c
    else:
        mid, large = c, a
else:
    small = c
    if a <= b:
        mid, large = a, b
    else:
        mid, large = b, a

print("Ascending order:", small, mid, large)

Real output:

Ascending order: 12 30 47

Why <= and not <. The else at the bottom catches everything the first two tests reject, so no value ever escapes this ladder — instead the wrong branch quietly claims it. Replace all six comparisons with strict < and feed it a triple whose smallest value is repeated:

a, b, c = 3, 3, 5

if a < b and a < c:
    small = a
    if b < c:
        mid, large = b, c
    else:
        mid, large = c, b
elif b < a and b < c:
    small = b
    if a < c:
        mid, large = a, c
    else:
        mid, large = c, a
else:
    small = c
    if a < b:
        mid, large = a, b
    else:
        mid, large = b, a

print("Strict < version says:", small, mid, large)

Real output:

Strict < version says: 5 3 3

Here a < b is False (3 is not less than 3) and b < a is False as well, so the if and the elif are both rejected and the else runs. The else assumes c must be the smallest, so it announces 5 as the smallest of 3, 3 and 5 — a wrong answer with no error message. Writing <= lets a tie satisfy the first test, and the program then gives the correct order for every triple, including ones with two or three equal values.

Two extras worth knowing. First, a conditional expression is a one-line if-else that produces a value rather than running a block:

n = -8
sign = "negative" if n < 0 else "non-negative"
print(n, "is", sign)

Real output:

-8 is negative

Second, a condition does not have to be a comparison. Python treats 0, the empty string and the empty list as False and almost everything else as True:

for value in [0, 7, "", "hi", []]:
    if value:
        print(repr(value), "-> treated as True")
    else:
        print(repr(value), "-> treated as False")

Real output. repr() is used only so that the empty string shows up as a visible pair of quotes instead of a blank:

0 -> treated as False
7 -> treated as True
'' -> treated as False
'hi' -> treated as True
[] -> treated as False

A for loop is a counted loop: it takes a sequence, hands you one item at a time in the loop variable, and stops automatically when the sequence runs out. You never write the stopping test yourself, so a for loop cannot run forever.

Worked example 1 — looping over a string and over a list

for ch in "PATNA":
    print(ch, end=" ")
print()

for city in ["Delhi", "Chennai", "Kochi"]:
    print("Branch:", city)

Real output:

P A T N A
Branch: Delhi
Branch: Chennai
Branch: Kochi

The syllabus also asks for the flowchart of an iterative statement. A loop is drawn as a decision diamond with an arrow that goes backwards — that back-arrow is what makes it a loop rather than a branch:

             +---------+
             |  START  |
             +---------+
                  |
                  v
      +----->/-----------------\
      |     /  any item left    \   No
      |     \  in the sequence ? /-------+
      |      \-----------------/         |
      |               | Yes              |
      |               v                  |
      |     +---------------------+      |
      |     | var = next item     |      |
      |     +---------------------+      |
      |               |                  |
      |               v                  |
      |     +---------------------+      |
      |     |     loop body       |      |
      |     +---------------------+      |
      |               |                  v
      +---------------+             +---------+
                                    |  STOP   |
                                    +---------+

Very often you do not have a ready-made list — you just want the numbers 1 to 10. That is what range() is for. It builds a sequence of integers on demand.

Form	Meaning	Example	Produces
range(stop)	0 up to stop−1	range(5)	0, 1, 2, 3, 4
range(start, stop)	start up to stop−1	range(1, 5)	1, 2, 3, 4
range(start, stop, step)	start, start+step, ... while below stop	range(1, 10, 2)	1, 3, 5, 7, 9
negative step	counts downward, stays above stop	range(10, 0, -2)	10, 8, 6, 4, 2

Worked example 2 — proving that range() excludes its stop value

print(list(range(5)))
print(list(range(1, 5)))
print(list(range(1, 10, 2)))
print(list(range(10, 0, -2)))
print(list(range(5, 5)))
print(list(range(5, 1)))
print(len(range(1, 10, 3)))

Real output:

[0, 1, 2, 3, 4]
[1, 2, 3, 4]
[1, 3, 5, 7, 9]
[10, 8, 6, 4, 2]
[]
[]
3

Read those carefully. range(5) stops at 4, not 5. range(10, 0, -2) stops at 2, not 0. range(5, 5) and range(5, 1) are both empty — the loop body simply never runs, and Python does not complain. This exclusive-stop behaviour is not an accident: it makes range(len(s)) give exactly the valid indices of s, and it makes range(a, b) contain exactly b - a items.

So to loop from 1 to n inclusive, you must write range(1, n + 1). Forgetting the + 1 is the most common loop error in Class 11.

Two things range() refuses to do:

print(list(range(1, 5.0)))

TypeError: 'float' object cannot be interpreted as an integer

print(list(range(1, 10, 0)))

ValueError: range() arg 3 must not be zero

A zero step would never move, so Python rejects it rather than hang.

Also note that range is a lazy object, not a list — it stores only start, stop and step, which is why range(1, 10000000) costs no memory:

r = range(1, 6)
print(r)
print(type(r))
print(list(r))
print(3 in r, 9 in r)

Real output:

range(1, 6)

[1, 2, 3, 4, 5]
True False

Syllabus program A — factorial of a positive number

n = 6
fact = 1
for i in range(1, n + 1):
    fact = fact * i
    print("after i =", i, "-> fact =", fact)
print("Factorial of", n, "is", fact)

Real output:

after i = 1 -> fact = 1
after i = 2 -> fact = 2
after i = 3 -> fact = 6
after i = 4 -> fact = 24
after i = 5 -> fact = 120
after i = 6 -> fact = 720
Factorial of 6 is 720

The accumulator fact starts at 1, not 0 — starting at 0 would make every product 0. For a sum the accumulator starts at 0; for a product it starts at 1.

Syllabus program B — summation of a series: S = 1 + 1/2 + 1/3 + ... + 1/n

n = 5
total = 0
for i in range(1, n + 1):
    total = total + 1 / i
print("Sum of first", n, "terms =", total)
print("Rounded to 4 places:", round(total, 4))

Real output:

Sum of first 5 terms = 2.283333333333333
Rounded to 4 places: 2.2833

Worked example 3 — checking a loop against a known formula

n = 10
total = 0
for i in range(1, n + 1):
    total = total + i ** 2
print("Loop total   =", total)
print("Formula n(n+1)(2n+1)/6 =", n * (n + 1) * (2 * n + 1) // 6)

Real output:

Loop total   = 385
Formula n(n+1)(2n+1)/6 = 385

Whenever a maths formula exists, use it to verify your loop. If the two disagree, your range() bounds are wrong.

Worked example 4 — a gotcha worth marks: changing the loop variable inside the body does not change the loop, because the next round overwrites it from the sequence.

for i in range(1, 5):
    print("i at top =", i, end="   ")
    i = i * 100
    print("i after change =", i)
print("i after the loop ends =", i)

Real output:

i at top = 1   i after change = 100
i at top = 2   i after change = 200
i at top = 3   i after change = 300
i at top = 4   i after change = 400
i after the loop ends = 400

The loop still ran exactly 4 times. And note the last line: in Python the loop variable survives after the loop, holding whatever it held on the final round.

Use a for loop when you know how many rounds you need. Use a while loop when you do not — when the loop should keep going "until something happens". A while loop tests its condition before every round, so if the condition is False at the start the body never runs at all.

A correct while loop always has three parts, and forgetting the third one is what makes loops hang:

1. Initialisation — set up the variable the condition uses, before the loop.
2. Condition — the test in the while header.
3. Update — change that variable inside the body so the condition eventually becomes False.

Those same three parts are what you draw in the flowchart of a while loop. The initialisation sits above the diamond, the update sits inside the loop, and the arrow from the update runs backwards to the diamond:

             +---------+
             |  START  |
             +---------+
                  |
                  v
        +---------------------+
        |  i = 1   (initialise)|
        +---------------------+
                  |
                  v
      +----->/---------------\
      |     /                 \   False
      |     \    i <= 5 ?     /---------+
      |      \---------------/          |
      |               | True            |
      |               v                 |
      |     +---------------------+     |
      |     |     print(i)        |     |
      |     +---------------------+     |
      |               |                 |
      |               v                 |
      |     +---------------------+     |
      |     |  i = i + 1  (update)|     |
      |     +---------------------+     |
      |               |                 v
      +---------------+            +---------+
                                   |  STOP   |
                                   +---------+

That flowchart is the program below, and both agree:

i = 1
while i <= 5:
    print(i, end=" ")
    i = i + 1
print()
print("loop ended with i =", i)

Real output:

1 2 3 4 5
loop ended with i = 6

The loop ends with i at 6, not 5 — the update runs on the last round too, and it is the failed test on 6 that stops the loop.

Worked example 1 — a recharge that lasts until the money runs out

balance = 1000
month = 0
while balance >= 250:
    balance = balance - 250
    month = month + 1
    print("Month", month, "-> balance Rs", balance)
print("Recharge lasted", month, "months. Left over: Rs", balance)

Real output:

Month 1 -> balance Rs 750
Month 2 -> balance Rs 500
Month 3 -> balance Rs 250
Month 4 -> balance Rs 0
Recharge lasted 4 months. Left over: Rs 0

Nothing in the program said "4". The loop worked it out.

Worked example 2 — reversing a number, the classic while question

n = 4056
rev = 0
while n > 0:
    digit = n % 10
    rev = rev * 10 + digit
    n = n // 10
    print("digit =", digit, "| rev so far =", rev, "| n left =", n)
print("Reversed number =", rev)

Real output:

digit = 6 | rev so far = 6 | n left = 405
digit = 5 | rev so far = 65 | n left = 40
digit = 0 | rev so far = 650 | n left = 4
digit = 4 | rev so far = 6504 | n left = 0
Reversed number = 6504

You cannot write this as a for loop cleanly, because you do not know in advance how many digits the number has. % peels off the last digit and // throws it away; when n reaches 0 the condition fails and the loop ends. Note that this version destroys n; if you still need the original number at the end, copy it into another variable first.

Worked example 3 — the infinite loop. Here the update step is missing:

i = 1
while i <= 5:
    print("i =", i)

Real output (first six lines, before the process was stopped by hand):

i = 1
i = 1
i = 1
i = 1
i = 1
i = 1
...

i never changes, so i <= 5 is True forever. If this happens to you, press Ctrl + C to stop the program.

break and continue. Both are jump statements used inside a loop, and the difference is exactly one word:

• break — leave the loop completely, right now. The remaining rounds never happen.
• continue — skip the rest of this round only and go straight to the next round.

Worked example 4 — the same loop, once with each

print("WITH break:")
for n in range(1, 8):
    if n == 4:
        break
    print(n, end=" ")
print()

print("WITH continue:")
for n in range(1, 8):
    if n == 4:
        continue
    print(n, end=" ")
print()

Real output:

WITH break:
1 2 3
WITH continue:
1 2 3 5 6 7

break lost everything from 4 onwards. continue lost only the 4.

Worked example 5 — where break is the right tool: stop searching once found

roll_numbers = [11, 14, 19, 23, 27, 31]
target = 19
position = -1
for i in range(len(roll_numbers)):
    print("checking index", i)
    if roll_numbers[i] == target:
        position = i
        break
print("Found", target, "at index", position)

Real output:

checking index 0
checking index 1
checking index 2
Found 19 at index 2

Indices 3, 4 and 5 were never checked. That is the whole point — break saves work.

Worked example 6 — where continue is the right tool: skip bad data, keep the rest

marks = [78, -1, 65, -1, 90, 42]
total = 0
count = 0
for m in marks:
    if m == -1:
        continue
    total = total + m
    count = count + 1
print("Students present:", count)
print("Total marks:", total)
print("Average:", round(total / count, 2))

Real output:

Students present: 4
Total marks: 275
Average: 68.75

The -1 entries (absentees) are skipped, and crucially count is not incremented for them, so the average is over 4 students and not 6.

Worked example 7 — while True with a sentinel. When the stopping condition is only discoverable in the middle of the body, the standard shape is a deliberately infinite loop plus a break. Here 0 is the sentinel value meaning "no more items".

entries = [250, 120, 80, 0, 999]
i = 0
total = 0
while True:
    value = entries[i]
    i = i + 1
    if value == 0:
        break
    total = total + value
print("Bill total = Rs", total)
print("Items after the sentinel were never read. i stopped at", i)

Real output:

Bill total = Rs 450
Items after the sentinel were never read. i stopped at 4

The 999 was never added, because the loop had already left. A while True loop is safe only if some path through the body definitely reaches a break.

A loop can be the body of another loop. When it is, the inner loop finishes completely for every single round of the outer loop. If the outer loop runs 4 times and the inner runs 3 times, the innermost statement runs 4 × 3 = 12 times.

Worked example 1 — counting the rounds. The outer loop runs 5 times and the inner loop runs 3 times, so the print inside runs 15 times and fills 5 rows of 3 entries.

for i in range(1, 6):
    for t in range(2, 5):
        print(t, "x", i, "=", t * i, end="   ")
    print()

Real output:

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

Note the bare print() at the end of the outer body, aligned with the inner for, not inside it. That is the line-break. Every pattern program in this section uses the same two tools:

• print(x, end="") prints without moving to a new line, so the inner loop builds one row across.
• print() with nothing prints just the newline, ending the row.

The universal recipe: outer loop = which row, inner loop = how many characters in that row. Get the inner loop's count expression right and the pattern falls out.

Pattern 1 — right triangle of stars (row i has i stars)

n = 5
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print("*", end="")
    print()

Real output:

*
**
***
****
*****

Pattern 2 — inverted triangle (count the outer loop downwards)

n = 5
for i in range(n, 0, -1):
    for j in range(1, i + 1):
        print("*", end="")
    print()

Real output:

*****
****
***
**
*

Pattern 3 — number pattern, printing the inner variable

n = 4
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print(j, end="")
    print()

Real output:

1
12
123
1234

Pattern 4 — number pattern, printing the outer variable. The loops are identical to Pattern 3; only the variable inside print changed from j to i. That one character is the whole difference.

n = 4
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print(i, end="")
    print()

Real output:

1
22
333
4444

Pattern 5 — letter pattern. chr() converts a character code to a character, and the code for 'A' is 65, so chr(64 + j) gives A when j is 1, B when j is 2, and so on. ord('A') converts back and gives 65.

n = 5
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print(chr(64 + j), end="")
    print()

Real output:

A
AB
ABC
ABCD
ABCDE

Swap j for i and you get the repeated-letter version. Since a string multiplied by an integer repeats it, this one does not even need the inner loop:

n = 5
for i in range(1, n + 1):
    print(chr(64 + i) * i)

Real output:

A
BB
CCC
DDDD
EEEEE

Pattern 6 — centred pyramid. Two inner loops now: one prints leading spaces, the other prints stars. Row i needs n - i spaces and 2i - 1 stars.

n = 5
for i in range(1, n + 1):
    for s in range(1, n - i + 1):
        print(" ", end="")
    for j in range(1, 2 * i):
        print("*", end="")
    print()

Real output:

    *
   ***
  *****
 *******
*********

Check the arithmetic against the output: row 1 has 4 spaces and 1 star, row 5 has 0 spaces and 9 stars. range(1, 2 * i) runs 2i - 1 times because range excludes its stop value — the exclusive-stop rule from the previous section is doing real work here.

Worked example 2 — break inside a nested loop leaves ONLY the inner loop. This is a favourite exam trap.

for i in range(1, 4):
    for j in range(1, 4):
        if j == 2:
            break
        print("i =", i, "j =", j)
    print("inner loop over for i =", i)
print("done")

Real output:

i = 1 j = 1
inner loop over for i = 1
i = 2 j = 1
inner loop over for i = 2
i = 3 j = 1
inner loop over for i = 3
done

The outer loop still completed all three of its rounds. break only ever ends the loop it is directly inside — Python has no "break out of two loops" statement.