Class 10 Computer Science Chapter 4 Complete Guide Book — Control Structures in Python | PunjabTest.com

Normally a program runs top to bottom, one statement after another — this is sequence. Control structures change that flow:

1. Sequence — steps run in order. 2. Selection — the program chooses between paths using a condition (if). 3. Repetition (loop) — a block repeats while a condition holds (for, while).

Every program, from a marks calculator to a game, is built from these three structures combined. Python shows a block by indentation (spaces at the start of lines) — there are no { } braces. Wrong indentation is a real error in Python, so keep blocks lined up evenly (usually 4 spaces).

marks = int(input("Marks: "))
if marks >= 80:
    print("Grade A")
elif marks >= 60:
    print("Grade B")
else:
    print("Work harder")

if tests a condition; if it is True, its block runs. elif (else-if) tests another condition only when the earlier ones failed. else catches everything left over. Only one block runs — Python stops at the first true condition.

Nested if: an if inside another if tests a second condition only when the first passed (e.g. first check pass/fail, then inside, check grade). Conditions use comparison operators (== < > >=) and logical operators (and or not): if age >= 18 and has_card:.

A for loop repeats a block a known number of times — usually over a sequence or a range():

for i in range(1, 6):
    print(i)   # prints 1 2 3 4 5

range(1, 6) gives 1, 2, 3, 4, 5 — the stop value is never included. range(5) gives 0–4; range(2, 11, 2) gives 2, 4, 6, 8, 10 (step 2). A for loop also walks through strings and lists: for ch in "Ali": visits A, l, i one by one.

Accumulator pattern (very important for exams): start a total at 0 before the loop, add inside it, use it after it:

total = 0
for i in range(1, 11):
    total += i
print(total)   # 55

A while loop repeats while a condition stays true — use it when you do not know in advance how many repeats are needed:

num = 1
while num <= 5:
    print(num)
    num += 1   # without this line the loop never ends!

The loop variable must change inside the loop, or the condition stays true forever — an infinite loop that you must stop with Ctrl+C. Common uses: keep asking until the user enters a valid value, keep a game running until the player quits, read data until a stop value (sentinel) appears.

for vs while: use for when the count is known (tables, lists, ranges); use while when repetition depends on a condition (password attempts, menus, games).

break exits the loop immediately, even if the loop is not finished — e.g. stop searching when the item is found. continue skips the rest of the current round and jumps to the next one — e.g. skip printing when a value is zero:

for i in range(1, 11):
    if i == 5:
        continue   # skips 5
    if i == 8:
        break      # stops at 7
    print(i)

Output: 1 2 3 4 6 7. Nested loops are loops inside loops: the inner loop finishes all its rounds for each single round of the outer loop. They make tables and patterns: outer loop = rows, inner loop = columns. Example: a multiplication table uses an outer loop for the number and an inner loop for 1–10.

Three exam-favourite programs: (1) Table: for i in range(1, 11): print(n, "x", i, "=", n*i). (2) Even/odd count: loop over numbers, use % 2 to test, count each kind. (3) Largest of three: nested if comparing a, b, c.

Dry run means tracing a program on paper: write each variable's value round by round. It catches logic errors before you run the code — examiners love dry-run questions, e.g. “what is the value of total after this loop?”

Debugging checklist: (1) Read the error message — it names the line. (2) Check indentation first. (3) Check = vs == and missing colons : after if/for/while. (4) Print variable values inside the loop to see what is happening. (5) Test with small, known inputs (e.g. table of 2) before big ones.