Flow of Control

Written and reviewed by Rohit Singh, Computer Science & Commerce faculty at UniDrill (MCA, Osmania University · 6 years teaching). Based on NCERT Computer Science Class XI, Chapter 6.

Why does a program ever need to choose?

A school bus has one road. The driver cannot decide anything, so he simply follows the milestones one after another. Now open a map app: it offers the shortest route and the least crowded route, and you pick one. Programs behave the same way. Until now yours ran like the bus, one statement after another. This chapter gives them a steering wheel (decisions) and a lap counter (repetition). Almost every CUET code question is really asking: which statements run, and how many times?

The three ways a program can flow

The order in which statements are executed is called the flow of control. Python supports three patterns, and every program you will ever read is built from them.

Selection: if, if..else and if..elif..else

An if statement runs its indented block only when the condition is true. If it is false, the block is skipped and Python moves on. The if..else form gives two alternatives, and exactly one of them runs.

When you have more than two alternatives, chain the conditions with elif, which simply means else if. Python checks the conditions from top to bottom, runs the block of the first true condition and then skips the whole rest of the chain. A final else is optional and catches everything that failed all the tests.

Worked example: grade by marks. What does this program print, and what goes wrong if the conditions are written in the opposite order?

The common wrong step is to put the loosest test first. If marks >= 60 came first, a student with 95 marks would also print C, because the chain stops at the first true condition and the >= 90 test is never reached. Order conditions from the most specific to the most general.

Nested if. An if..else placed inside another if or elif block is a nested if. The inner test is reached only if the outer one passed. For example, a calculator can first check the operator and, for division, check inside that block whether the divisor is zero.

Pause and predict: x = 15. Statement A is if x > 10: print("A"). Statement B, written directly below it as a separate statement, is if x > 12: print("B"). What is printed? What changes if B is written as elif x > 12: attached to A?

Check your answer: With two separate if statements, both conditions are tested independently, so both A and B are printed. With elif, the chain stops after the first true test, so only A is printed. This difference is behind many "predict the output" questions.

Indentation: Python's replacement for curly brackets

Most languages mark a block with curly brackets. Python marks it with indentation: the leading white space (spaces or tabs) at the start of a statement. Statements with the same indentation belong to one block, and the interpreter checks this strictly, raising an error if the levels do not match. The usual habit is one tab for each level.

This is not just style, because moving one line changes what the program does.

Worked example: one line, two meanings. The only difference between the two programs below is the indentation of the last print.

In the first program print("done") is outside the loop, so it runs once, after the loop ends. In the second it is inside the loop body, so it runs three times.

Beyond the textbook. For the exam: a block is any group of statements at the same indentation. In reality: a block can never be empty. If you need a placeholder where Python demands a statement but you have nothing to do yet, write the keyword pass, which does nothing. It is useful when you are sketching a program and want it to run before you have filled in every branch.

Repetition: the idea of a loop

Printing the first five natural numbers needs five print statements. Printing the first 100,000 would need 100,000, which no sensible person would type. A loop solves this: it runs a block repeatedly as long as a condition stays true. The condition is tested using the value of a control variable. The programmer must make sure that the condition eventually becomes false. If it never does, the result is an infinite loop, which is a logical error rather than a syntax error, so Python will not warn you.

Python has two loops. Use for when you know in advance how many times (or over which items) you want to repeat. Use while when you only know the condition for stopping.

The for loop and range()

A for loop takes each item of a range or a sequence in turn (the characters of a string, the elements of a list or tuple) and runs the body once per item. When the items are exhausted, control moves to the statement after the loop.

This prints P, Y, T, H, O and N, one per line. To loop over numbers, Python gives you the built-in function range(), with the syntax range([start], stop[, step]).

The three rules of range(). start is included and defaults to 0. stop is never included. step defaults to 1, may be negative, but may never be zero. All three must be integers. Here is how common calls behave.

You can count the values without listing them. For a positive or negative step:

$$\text{count} = \max\left(0,\ \left\lceil \dfrac{\text{stop} - \text{start}}{\text{step}} \right\rceil\right)$$

Check it on range(2, 10, 3): $(10 - 2)/3 = 2.67$, and the ceiling is 3, which matches 2, 5, 8. Check it on range(0, 9, -1): $(9 - 0)/(-1) = -9$, so the count is 0.

Worked example: tracing a for loop. What is printed by this program?

range(1, 6, 2) gives 1, 3, 5. Writing the table is the fastest way to avoid the usual slip of including 6 or stepping by 1 out of habit.

Pause and predict: after for i in range(5): pass, what is the value of i?

Check your answer: 4. The control variable is an ordinary variable. It keeps the last value it received, even after the loop has finished.

The while loop

A while loop tests its condition before every pass. While it is true the body runs, and when it becomes false control moves to the statement after the loop. If the condition is false the very first time, the body runs zero times. Because Python never changes the control variable for you, the body itself must contain a statement that eventually makes the condition false.

Worked example: sum of the digits of 345. The two operators do the work: n % 10 gives the last digit and n // 10 removes it.

If the line n = n // 10 were forgotten, n would stay 345 for ever and the loop would never end. That is the classic infinite loop.

for or while? The two loops are interchangeable in theory, but each fits a different situation.

break and continue

Sometimes a loop needs to be interrupted from inside. Python gives two statements for this, and CUET loves to test whether you can tell them apart.

Worked example: break. Program: the body adds 1 to num, quits the loop if num is 8, and otherwise prints it.

Each pass, for hands num the next value from the range (0, 1, 2, ...), then the body adds 1. So the body sees 1, 2, 3, ... The first seven passes print 1 to 7. On the eighth pass num becomes 8, break runs before the print, and control jumps to print("Out of loop"). The line with value 8 is never printed, so the loop body prints exactly 7 times.

Worked example: continue. Same idea, but the loop uses continue for the value 3 and the range is range(6).

Why the next pass is not affected. Changing num inside the body does not change the range. At the top of every pass, for overwrites num with the next value from the range. That is why the loop still makes six passes even though num was bumped up inside.

Pause and predict: a while loop starts with i = 1 and runs while i <= 5. Inside, if i == 3: continue comes first, and i = i + 1 comes last. What happens?

Check your answer: it prints 1 and 2, then hangs. When i reaches 3, continue jumps back to the test before i is incremented, so i stays 3 for ever. In a for loop continue is safe because the loop advances itself. In a while loop, you must update the control variable before continue.

Beyond the textbook. For the exam: while repeats while the condition is true, and break exits the loop. In reality: the most common professional pattern combines them: while True: starts a loop that never ends by itself, and a break inside leaves it when the work is done, for example as soon as the user enters a negative number. Used carefully this is clean, because the exit condition sits exactly where you detect it.

Beyond the textbook. For the exam: a prime-number checker loops over possible factors and uses break as soon as one is found. In reality: the stop value of range() is exclusive, so a loop written as range(2, int(num / 2)) never tests num / 2 itself. For num = 4 the range is empty, no factor is found, and 4 is wrongly reported as prime. Writing range(2, num // 2 + 1) repairs it. This is the exclusive-stop trap showing up in real code.

Nested loops

A loop inside another loop is a nested loop. Any mix of for and while is allowed, to any depth. The rule to remember: for each single pass of the outer loop, the inner loop runs through its complete cycle. So if the outer loop runs $m$ times and the inner runs $n$ times, the inner body runs $m \times n$ times.

Worked example: a number pattern.

The print() at one indentation level less than the inner loop belongs to the outer loop, so it runs once per row and moves the cursor to a new line. A break inside the inner loop ends only the inner loop. The outer loop carries on with its next pass.

Exam traps

60-second revision

Where this chapter connects

• Previous: Getting Started with Python gives the data types, operators and input and output that every condition and loop body here depends on.
• Next: Functions wraps the loops and decisions you just wrote into named, reusable blocks.
• Where loops return: Strings and Lists use for loops to traverse every character or element, and Introduction to Problem Solving shows the flowcharts for the same three patterns.