Python Control Flow.

A useful script rarely evaluates a single variable once. It makes decisions, processes multiple records, and knows when to stop. This lesson builds those skills with small, readable examples before introducing a real coding exercise.

• Explain how Python evaluates if / elif / else in order and selects one branch.
• Predict how for loops iterate over ranges and small collections, including exclusive stop values.
• Use counters and accumulators to summarize repeated checks.
• Write bounded while loops with clear exit conditions.
• Distinguish break from continue and trace their effect on execution.
• Debug indentation, off-by-one errors, and loops that fail to update state.
• Predict nested-loop iteration counts and safely filter site/service combinations using two loops.

Sometimes a device is neither simply healthy nor unhealthy. Python's if, elif and else chain examines conditions from top to bottom. It executes the first matching branch and skips the rest, even when a later comparison could also be true. Order the most specific conditions intentionally.

latency = 240
if latency >= 200:
    print("Critical")
elif latency >= 100:
    print("Warning")
else:
    print("Normal")

When a technician needs to inspect several records, writing the same test five times is error-prone. A for loop binds a variable to each item in an iterable and executes its indented block once for each item. For now, a short list represents an inventory; we'll explore data structures deeply in a later lesson.

devices = ["SW-01", "FW-01", "AP-02"]
for name in devices:
    print(name)
print("Inventory reviewed")

range(start, stop, step) produces a sequence of integer values. Its stop value is not included, so range(1, 4) visits 1, 2 and 3. If you forget the exclusive boundary, your final port or retry count may silently be missed.

for attempt in range(1, 4):
    print(f"Attempt {attempt}")

for attempt in range(1, 4):
    print(f"Attempt {attempt}")

(nothing yet)

Sometimes you want a single report from many records. An accumulator is a variable initialized before the loop and updated inside it. Resetting a counter inside the loop discards previous results, and printing inside the loop may produce intermediate values rather than the requested final summary.

statuses = ["online", "offline", "offline", "online"]
offline_count = 0
for state in statuses:
    if state == "offline":
        offline_count += 1
print(f"{offline_count} offline devices")

A for loop is ideal for a known sequence. A while loop repeats for as long as a condition remains true, which can model retries or waiting for a result. Unlike a for range, your code usually must update the condition's state. Missing that update causes an endless loop.

attempt = 1
while attempt <= 3:
    print(f"Checking attempt {attempt}")
    attempt += 1
print("Finished")

When scanning event codes, some entries may be irrelevant while others require stopping the investigation. continue skips the rest of the current iteration and moves to the next item; break exits the nearest enclosing loop. Confusing them can skip an important record or stop a report too early.

responses = [200, 429, 503, 200]
for code in responses:
    if code == 200:
        continue
    if code >= 500:
        print(f"Critical: {code}")
        break
    print(f"Review: {code}")

A nested loop means a complete inner loop runs once for every outer-loop item. For two sites and three services, Python visits six site–service combinations in a predictable order. Trace the outer item, then walk the full inner sequence before the outer loop advances. An if statement inside a loop is different: it makes a decision but does not create additional iterations.

sites = ['HQ', 'BR1']
services = ['dns', 'dhcp', 'vpn']
checks = 0
for site in sites:
    for service in services:
        checks += 1
        print(f'{site}: {service}')
print(f'{checks} total checks')

For a two-dimensional grid, a schedule, or a small site-by-service checklist, two loops describe two coordinates. Each outer item is paired with each inner item in order. To filter the combinations, put an if statement inside the inner loop. A useful debugging habit is to record the pair before deciding whether it matches: this shows whether a bug comes from the loop boundary, the condition, or the output. Avoid accidentally resetting the result list inside the outer loop.

sites = ['HQ', 'BR1']
services = ['dns', 'vpn']
failed = {'HQ:vpn', 'BR1:dns'}
matches = []
for site in sites:
    for service in services:
        pair = f'{site}:{service}'
        if pair in failed:
            matches.append(pair)
print(sorted(matches))

for site in sites:
    for service in services:
        print(site, service)

A loop can be valid Python and still be wrong. Typical problems include an off-by-one range, a misplaced counter initialization, a print statement at the wrong indentation, a condition that never changes, or using break where continue was intended. Start from the observed behavior and compare each iteration to the requirement.

ports = [22, 80, 443, 3389]
review_count = 0
for port in ports:
    if port == 22 or port == 443:
        continue
    review_count += 1
print(f"{review_count} ports need review")

The first challenge asks you to fix overlapping latency thresholds using if/elif/else. Run real Python, predict the output, inspect the trace, then continue into loops, bounds, nested-loop grids and a simulated port audit in Practice.

You don't need to memorize everything. Learn how to read the Python documentation and use it when a behavior is unfamiliar.