🔀 Python Control Structures and Functions

Why Control Flow?

Control structures are the traffic signals of a program. They direct the flow of execution — deciding which code runs, when it runs, and how many times. Without them, a program could only march straight from the first line to the last, doing exactly the same thing every run.

Python implements these ideas with unusually clean syntax, staying true to its readability-first philosophy. Everything you learn here transfers directly to writing API request handlers, processing database rows, and validating user input later in this course.

Conditional Statements

Conditionals let a program branch, just as we make decisions all day: if it's raining, take an umbrella.

if, if-else, if-elif-else

# Simple if
temperature = 28
if temperature > 25:
    print("It's a hot day! Stay hydrated.")

# Two alternatives with else
age = 17
if age >= 18:
    print("You are eligible to vote.")
else:
    print(f"Wait {18 - age} more years.")

# Many alternatives with elif
score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"
print(f"Your grade is {grade}")

Python evaluates each condition top to bottom and runs the first branch that is true, then skips the rest. Think of a customer-service phone menu routing each caller to exactly one department.

Conditional expressions (the ternary)

For a simple either/or assignment, Python offers a compact one-liner:

age = 20
status = "adult" if age >= 18 else "minor"
print(status)   # adult

Loops

Loops repeat a block of code — the assembly line of programming, processing items one after another.

for loops iterate over sequences

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(f"I like {fruit}.")

# enumerate() gives you the index too
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# Iterate a dict's key-value pairs
person = {"name": "Helen", "city": "Boston"}
for key, value in person.items():
    print(f"{key}: {value}")

range() generates numbers

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

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

for i in range(0, 11, 2):   # 0,2,4,6,8,10  (start, stop, step)
    print(i)

while loops repeat until a condition ends

A while loop runs as long as its condition stays true — ideal when you don't know the number of iterations in advance, such as retrying a network call until it succeeds.

countdown = 5
while countdown > 0:
    print(f"{countdown}...")
    countdown -= 1
print("Blast off!")

Loop Control & else

Three keywords let you steer a loop's flow:

• break — exit the loop immediately (an emergency exit door).
• continue — skip to the next iteration (a "staff only" door back to the start).
• pass — do nothing; a placeholder where syntax requires a statement.

# Stop at the first number divisible by 7
for num in range(1, 100):
    if num % 7 == 0:
        print(f"Found it! {num} is divisible by 7.")
        break

# Skip even numbers, print only odds
for num in range(10):
    if num % 2 == 0:
        continue
    print(f"{num} is odd")

target = 42
for n in [10, 20, 30]:
    if n == target:
        print("Found target!")
        break
else:
    print("Target not found.")   # runs — no break happened

Defining Functions

A function is a named, reusable block of code that performs one task — a specialized tool in your kit. Functions keep code DRY (Don't Repeat Yourself), testable, and easy to read.

def, parameters, and return

def greet(name):
    """Return a friendly greeting for the given name."""
    return f"Hello, {name}! How are you today?"

message = greet("Alice")   # call the function
print(message)

The triple-quoted docstring documents what the function does; tools and help() read it. A function that hits return sends a value back to the caller. A function with no return (or a bare return) hands back None.

Default parameter values

def make_coffee(size="medium", kind="regular", milk=True):
    """Prepare a coffee order, filling in sensible defaults."""
    order = f"{size} {kind} coffee"
    if milk:
        order += " with milk"
    return order + "."

print(make_coffee())                    # medium regular coffee with milk.
print(make_coffee("large"))             # override just the size
print(make_coffee(kind="espresso", milk=False))  # keyword arguments

Passing arguments by keyword (kind="espresso") makes calls self-documenting and lets you skip earlier optional parameters.

# Buggy: the list persists between calls
def add_item(item, cart=[]):   # DON'T
    cart.append(item)
    return cart

# Correct
def add_item(item, cart=None):
    if cart is None:
        cart = []
    cart.append(item)
    return cart

Flexible Arguments

Sometimes a function should accept any number of arguments. Python provides *args (extra positional arguments, collected into a tuple) and **kwargs (extra keyword arguments, collected into a dict).

def total(*numbers):
    """Sum any number of positional arguments."""
    return sum(numbers)

print(total(1, 2, 3))        # 6
print(total(5, 10, 15, 20))  # 50

def build_profile(name, **details):
    """Accept a name plus arbitrary extra key-value fields."""
    profile = {"name": name}
    profile.update(details)
    return profile

print(build_profile("Alice", age=30, city="NYC"))
# {'name': 'Alice', 'age': 30, 'city': 'NYC'}

You'll see *args, **kwargs constantly in web frameworks, where a handler needs to pass along whatever arguments it received without knowing them all in advance.

Worked Example

Let's combine conditionals, a loop, and a function into one realistic utility — the kind of analytical helper you'd find in a weather app or an IoT data pipeline.

def analyze_temperatures(readings):
    """
    Summarize a list of Celsius temperature readings.

    Args:
        readings (list[float]): temperature values in Celsius.

    Returns:
        dict: min, max, average, count, and a per-reading classification.
    """
    if not readings:                     # guard against empty input
        return {"error": "No temperature data provided"}

    result = {
        "min": min(readings),
        "max": max(readings),
        "average": sum(readings) / len(readings),
        "count": len(readings),
        "classifications": [],
    }

    for temp in readings:                # loop + if-elif chain
        if temp < 0:
            label = "freezing"
        elif temp < 10:
            label = "cold"
        elif temp < 20:
            label = "cool"
        elif temp < 30:
            label = "warm"
        else:
            label = "hot"
        result["classifications"].append(label)

    return result


weekly = [14, 21, 25, 18, 12, 22, 27]
report = analyze_temperatures(weekly)
print(f"Min: {report['min']}°C, Max: {report['max']}°C")
print(f"Average: {report['average']:.1f}°C")
print(f"Labels: {report['classifications']}")

Min: 12°C, Max: 27°C
Average: 19.9°C
Labels: ['cool', 'warm', 'warm', 'cool', 'cool', 'warm', 'warm']

This one function shows every idea from the lesson working together: input validation (a conditional guard), iteration (the for loop), branching (the if-elif chain), and a rich return value (a dict).

Hands-on Exercise

def fizzbuzz(n):
    for i in range(1, n + 1):
        if i % 15 == 0:
            print("FizzBuzz")
        elif i % 3 == 0:
            print("Fizz")
        elif i % 5 == 0:
            print("Buzz")
        else:
            print(i)


def password_strength(pw):
    checks = [
        len(pw) >= 8,
        any(c.isupper() for c in pw),
        any(c.isdigit() for c in pw),
        any(c in "!@#$%^&*()-_+" for c in pw),
    ]
    score = sum(checks)          # True counts as 1
    if score <= 1:
        return "weak"
    elif score <= 3:
        return "medium"
    return "strong"


fizzbuzz(15)
print(password_strength("Secret123!"))   # strong

Summary & Quiz

📚 Further Reading

• Python Tutorial — More Control Flow Tools
• Python Reference — Compound Statements
• PEP 8 — Function & Variable Naming

🚀 What's Next?

Your functions are piling up — time to organize them. The next lesson covers modules and packages: how to split code across files, import it cleanly, and tap into Python's vast standard library and PyPI ecosystem.