Control Flow, Conditional Statements, and Loops

Control flow is the order in which a computer executes the statements in a program. Without it, every line of code runs exactly once, from top to bottom, one after the other. That's fine for a simple calculator, but most programs need to make choices and repeat tasks. This is where conditional statements and loops come in, and they form the backbone of how we control the program's flow.

Let's start with conditional statements. These let your program make decisions based on whether a condition is 'true' or 'false'. In Python, the main tools for this are if, elif, and else. Think of if as the primary fork in the road. You give it a test, like a boolean expression (an expression that evaluates to either True or False). If the test passes (is True), the code block underneath the if runs. If it fails (is False), the program skips that block.

For example:

temperature = 30
if temperature > 25:
    print("It's a hot day!")

Here, temperature > 25 is the condition. It checks if the variable temperature (which holds the value 30) is greater than 25. Since it is, the print statement runs. If the temperature were 20, the code inside the if block would be completely ignored.

Sometimes you need a plan B. That's else. It's the catch-all that runs when the if condition is False.

temperature = 15
if temperature > 25:
    print("It's a hot day!")
else:
    print("It's not a hot day.")

Now, if the temperature is not greater than 25, the program automatically runs the else block. This creates two distinct paths the code can take.

Real-life decisions are rarely just two-way. You might need to check multiple conditions. That's where elif (short for 'else if') steps in. It allows you to chain multiple conditions together, checking them one by one until one is True. Once it finds a true condition, it runs the corresponding block and then skips the rest of the elif and else blocks.

temperature = 22
if temperature > 25:
    print("It's a hot day!")
elif temperature > 15:
    print("It's a warm day.")
else:
    print("It's a cold day.")

Here, the first condition (temperature > 25) is False. Python moves to the elif and checks temperature > 15. This is True (because 22 > 15), so it prints "It's a warm day." It then completely ignores the else block. This is perfect for handling multiple, exclusive scenarios.

Now, what about doing something over and over? That's what loops are for. Why do we need them? Imagine you want to print the numbers 1 to 100. Without loops, you'd have to write 100 print() statements. With a for loop, you write two lines. Loops automate repetition, making your code shorter, less error-prone, and more powerful.

There are two main types of loops in Python: for loops and while loops.

A `for` loop is used to iterate (go through) a sequence. A sequence is an ordered collection of items, like a list (a collection of values in square brackets), a string (a sequence of characters), or a range of numbers. The for loop picks each item from the sequence, one at a time, and assigns it to a variable you name. The loop's code block runs once for each item in the sequence.

for number in [1, 2, 3, 4, 5]:
    print(number * 2)

This will print:

2
4
6
8
10

The loop variable number takes the value 1, runs the print, takes the value 2, runs the print, and so on until the list is exhausted. A for loop is perfect when you know exactly how many times you want to loop because you are iterating over a known collection of things.

The `while` loop is different. It doesn't iterate over a sequence. Instead, it keeps repeating a block of code while a given condition is True. It's like a bouncer at a club: "Keep letting people in while there is space inside." The moment the condition becomes False, the loop stops. You use a while loop when you don't know exactly how many repetitions are needed, but you know the condition for stopping.

count = 0
while count < 5:
    print("Count is:", count)
    count = count + 1

This will print:

Count is: 0
Count is: 1
Count is: 2
Count is: 3
Count is: 4

The critical part is count = count + 1. Without this line, count would always be 0, the condition count < 5 would always be True, and the loop would run forever — an infinite loop. This is a common programmer error, so always ensure a while loop's condition will eventually become False.

Both loops can be controlled with two special keywords: break and continue. break is an emergency exit — it immediately stops the loop, regardless of the condition. continue is a skip — it stops the current iteration of the loop and jumps straight to the next one. These are useful for handling special cases within a loop without needing complex nested if statements.

Combining these tools is how you build sophisticated programs. You can nest an if statement inside a for loop to filter data. You can use a while loop to keep asking a user for input until they give a valid answer. Control flow is the engine of your program; conditional statements and loops are the steering wheel and the accelerator.

Imagine you are a junior developer working for an online shop, 'GadgetHub'. Your manager asks you to write a Python script to process the morning's orders. You have a list of orders, each being a dictionary (a collection of key-value pairs like a mini-database row). Each order has a 'total' and a 'loyalty_status'. Your job is to apply discounts, print a summary, and handle special cases.

Step-by-step, here is what an IT professional would do with control flow:

First, you would use a for loop to iterate over every single order in a list called orders. You cannot process all orders manually; a loop handles the repetition automatically.

orders = [{'total': 150, 'loyalty': 'gold'}, {'total': 30, 'loyalty': 'silver'}, {'total': 200, 'loyalty': 'bronze'}]
for order in orders:

Inside the loop, you would need a series of if-elif-else statements to apply the correct discount based on loyalty_status. This is a classic business rule. - If the status is 'gold', apply a 20% discount. - If the status is 'silver', apply a 10% discount. - If the status is 'bronze' or any other value, apply no discount.

if order['loyalty'] == 'gold':
        discount = 0.20
    elif order['loyalty'] == 'silver':
        discount = 0.10
    else:
        discount = 0.00
    final_price = order['total'] * (1 - discount)

Then, you need to validate the data. What if an order has a negative total? That's data corruption. You use a while loop or an if with continue to skip it. A continue inside the loop would skip the rest of the processing for that bad order and move to the next one.

if order['total'] < 0:
        print(f"Error: Skipping order with invalid total.")
        continue

After processing, you need to accumulate a final report. You would have a variable total_revenue outside the loop, and inside the loop you would add the final_price to it. Loops are perfect for aggregating data like this.

Finally, your manager says, "Stop the script if we have a system-wide error, like an empty order list." You would use a while loop to keep asking a user for a file path to a new list of orders until a valid list is loaded, or use a break condition to exit a loop if a critical error flag is raised.

This scenario shows how every IT professional uses control flow daily to automate data processing, validate inputs, and apply business logic. Without for, if, and while, you would be stuck manually editing spreadsheets — a slow, error-prone, and non-scalable nightmare. The PCAP-31-03 exam expects you to be able to write exactly these kinds of simple, practical scripts.