Control Flow Logic

Beyond Simple Decisions

You already know how to use if, elif, and else to make your programs choose a path. But real-world logic is rarely so simple. Often, one decision leads to another, and another, creating layers of conditions. This is where nested logic comes in.

Imagine a program that validates a user's access to a sensitive report. First, you must check if their login is valid. If it is, you then need to check their permission level. Only then can you grant access. This creates a sequence of checks, one inside the other.

# A user must be logged in and have 'admin' rights

logged_in = True
permission_level = 'admin'

if logged_in:
    print("Login successful. Checking permissions...")
    if permission_level == 'admin':
        print("Access granted. Displaying sensitive report.")
    elif permission_level == 'editor':
        print("Access denied. Editor permissions are not sufficient.")
    else:
        print("Access denied. User permissions are not sufficient.")
else:
    print("Access denied. Please log in first.")

This is a classic example of nested conditional branching. The inner if/elif/else block only runs if the outer if logged_in: condition is met. While powerful, deep nesting can make code difficult to read and debug. A good practice is to handle failure cases or invalid conditions first to reduce indentation. This approach is sometimes called using and can make your logic much flatter and easier to follow.

Checking for Truth

In Python, checking for truth seems simple, but there's a crucial distinction between equality (==) and identity (is).

== (Equality): Checks if the values of two variables are the same.
is (Identity): Checks if two variables refer to the exact same object in memory.

For immutable types like booleans (True, False) and None, this distinction often doesn't matter in practice because Python optimizes them to point to a single object. However, for mutable objects like lists, it's a different story.

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)  # True, because their values are identical
print(a is b)  # False, because they are two different objects in memory

print(a == c)  # True, values are identical
print(a is c)  # True, because c points to the same object as a

When dealing with booleans, you might be tempted to write if my_variable is True:. While this works, the more idiomatic, or way, is to simply write if my_variable:. This relies on Python's concept of "truthiness," where non-empty collections, non-zero numbers, and the True object itself are all evaluated as true in a conditional context.

Smarter Looping

You're familiar with for loops for iterating over sequences and while loops for repeating actions until a condition becomes false. Choosing the right one depends on your goal.

Use a for loop when you have a definite collection to iterate over (like a list of items or a range of numbers).
Use a while loop when you don't know how many iterations you'll need, such as waiting for user input, processing a data stream, or waiting for a task to complete.

Sometimes you need more fine-grained control within a loop. That's where break and continue come in.

break terminates the loop entirely and execution continues at the first statement after the loop.
continue skips the rest of the current iteration and jumps to the beginning of the next one.

# Find the first even number in a list, but ignore negative numbers
numbers = [1, -2, 3, 5, -4, 6, 7, 8]

for num in numbers:
    if num < 0:
        continue  # Skip to the next number if it's negative
    if num % 2 == 0:
        print(f"Found the first positive even number: {num}")
        break  # Exit the loop since we found what we wanted

This pattern is very common for searching or processing data where you can stop early once a condition is met.

Logic in a Single Line

As you get more comfortable with Python, you'll find ways to express logic more concisely. are a prime example. They allow you to create a new list by applying an expression to each item in an existing iterable, often including conditional logic.

Suppose you have a list of numbers and you want a new list containing only the squares of the even numbers. The traditional for loop approach works, but a list comprehension is more direct.

numbers = [1, 2, 3, 4, 5, 6]
squared_evens = []

# The traditional for loop
for num in numbers:
    if num % 2 == 0:
        squared_evens.append(num * num)

# The list comprehension way
squared_evens_comp = [num * num for num in numbers if num % 2 == 0]

print(squared_evens)          # Output: [4, 16, 36]
print(squared_evens_comp)   # Output: [4, 16, 36]

The list comprehension packs the loop and the conditional logic into a single, readable line. It’s a powerful tool for transforming data based on logical rules.

Now let's test your understanding of these control flow techniques.

Quiz Questions 1/6

What is the primary purpose of a "guard clause" in programming?

Quiz Questions 2/6

Consider the following Python code:

list_a = [1, 2, 3]
list_b = [1, 2, 3]
list_c = list_a

print(list_a == list_b) # Statement 1
print(list_a is list_b) # Statement 2
print(list_a is list_c) # Statement 3

What will be the output of these three print statements?

Practical Programming and Software Logic