Conditional Statements

So far, every loop you have written executed the same instructions for every value.

Now we take the next step:

We still repeat actions, but we allow the program’s behaviour to change depending on the data it encounters.

1. Conditions as questions¶

When repetition needs decisions¶

A condition is simply a question that the computer can answer with yes or no.

In Python, these answers are represented by the Boolean values:

• True

• False

When conditions are used inside a loop, they allow the program to decide what to do for each individual value. The loop still steps through the data, but the behavior can change from one value to the next.

Reading conditions in plain language¶

Conditions are easiest to write and understand when you read them as questions:

• Is this value greater than 10?

• Is this city contained in the list of capitals?

• Is this index equal to zero?

Each condition controls whether a specific block of code is allowed to execute.

2. Operators for evaluating conditions¶

Comparison operators¶

Comparison operators are used to compare two values against each other.

Each comparison produces a Boolean result: either True or False. These operators are the most common way to express mathematical or textual conditions in code.

Identity operators¶

Identity operators check whether two variables refer to the exact same object in memory, not just whether they contain the same values.

Here is a conceptual example:

Now compare them:

Both a and b point to the same list.

Even though a and c contain the exact same numbers, they are different objects in the computer’s memory.

Membership operators¶

Membership operators test whether a specific value exists inside a collection (like a list or a string).

For example:

Membership operators also work seamlessly with strings to check for substrings:

3. Logical operators (and, or, not)¶

Combining conditions¶

Logical operators allow you to combine multiple conditions into a single decision.

The three logical operators in Python are:

• and (both conditions must be true)

• or (at least one condition must be true)

• not (reverses the condition)

They are often used to make highly precise decisions.

Simple examples¶

Consider a numeric value:

Both conditions are true, so the whole expression is true.

Now consider membership:

Only one of the conditions needs to be true for an or statement to evaluate to True.

Using not simply flips the Boolean result:

Reading logic in words¶

It helps to read logical expressions aloud:

• and means both conditions must be true

• or means at least one condition must be true

• not means the opposite of the condition

For example:

“The value is greater than zero and less than one hundred.”

Parentheses and clarity¶

When combining several conditions, it is best practice to use parentheses to make the logic clear.

Parentheses:

• improve readability

• prevent logic mistakes

• make the order of evaluation explicit

Concept check¶

Predict the result without running the code:

4. Conditional execution (if, elif, else)¶

Choosing what happens¶

So far, conditions have been used purely as questions. Now we will use them to choose between actions.

Python provides three related keywords for control flow:

• if for a single decision

• if … else for a two-way split

• if … elif … else for multiple paths

A single decision with if¶

Use if when you want code to run only if a condition is true.

If the condition is false, nothing happens. The program skips the indented block and continues.

Two paths with if and else¶

Use else when there are exactly two outcomes. It acts as a catch-all for when the if condition is false.

Exactly one of the two blocks will run. Never both.

Multiple paths with if, elif, and else¶

When more than two cases are possible, use elif (short for “else if”).

Python checks conditions from top to bottom. As soon as one condition evaluates to True, it runs that block and skips the rest of the chain.

Output:

-3 degrees is below freezing

Reading conditional chains¶

It helps to read the logic like a checklist:

1. Is the first condition true

2. If not, try the next one

3. If none match, use the fallback (else)

This makes conditional execution predictable and easy to debug.

Concept check¶

Predict the output before running the code:

B

5. Decisions inside loops¶

Using if inside a loop¶

Conditions become very powerful when placed inside loops.

The loop still processes every value in the list. However, only values that satisfy the condition (v > 10) are printed.

• The loop controls how often the code runs.

• The condition controls what happens for each specific value.

Filtering values¶

Filtering means selecting some values and ignoring the rest.

In the previous example, values greater than 10 are printed, while smaller values are skipped. Filtering is a core data science pattern used to:

• select spatial data above or below an elevation threshold

• remove invalid or missing coordinate entries

• focus analysis on a specific country or region

Transforming values¶

Transforming means changing values depending on a condition.

Here:

• values greater than 10 are doubled

• other values are printed unchanged

Unlike filtering, transforming generally produces an output for every value, but the output itself depends on the condition.

Concept check¶

Before running the code, predict the output:

4
16
7

6. Exercises¶

The following exercises help you practise how conditions and loops work together.

Focus on understanding when a condition is checked and what effect it has inside the loop.

Exercise 1: Filtering values¶

You are given a list of temperatures:

Write a loop that prints only temperatures above 10.

1. Write the loop.

2. Predict which values will be printed before running it.

for t in temperatures:
    if t > 10:
        print(t)

12
18
25

Exercise 2: Transforming values¶

You are given a list of distances (in kilometres):

Write a loop that:

• doubles distances greater than or equal to 5

• leaves smaller distances unchanged

Print the result for each value.

for d in distances:
    if d >= 5:
        print(d * 2)
    else:
        print(d)

2
20
4
10

Exercise 3: Using membership inside a loop¶

You are given a list of cities and a list of capitals:

Write a loop that prints only the cities that are also capitals.

for city in cities:
    if city in capitals:
        print(city)

Lima
Bogotá

Exercise 4: Predict before you run¶

Without running the code, predict the output:

Write down the expected output line by line.

odd
even
odd
odd
even

7. Summary¶

In this section, you learned how repetition and decisions work together.

Key ideas¶

• Loops control how often code runs.

• Conditions control what happens for each value.

• Conditions evaluate to True or False.

• Operators allow values (==), objects (is), and collections (in) to be tested.

• Logical operators (and, or, not) combine conditions.

• Placing if inside a loop enables core data workflows like filtering and transforming.

What comes next¶

So far, your decisions have happened inside a loop that already knows how long it will run. Next, you will learn a new kind of repetition: a loop that continues until a condition changes. You will meet the while loop, which is useful when you do not know in advance how many repetitions are needed. The key shift is this:

• for loops focus on what to loop over

• while loops focus on when to stop