Control Flow

if / elif / else

Python uses indentation — not braces — to delimit blocks. The conditional is written without parentheses (though they're allowed).

score = 87

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"

print(f"Grade: {grade}")  # Grade: B

Conditional Expressions (Ternary)

status = "adult" if age >= 18 else "minor"

# Chainable, but only do this for short, clear cases
label = "hot" if t > 30 else "warm" if t > 20 else "cool"

Chained Comparisons

Python lets you chain comparison operators naturally — closer to math than to other languages.

if 0 <= x < 100:           # equivalent to 0 <= x AND x < 100
    ...

if a == b == c:             # all three equal
    ...

Boolean Operators and Truthiness

Python's and, or, and not are short-circuit operators. They return one of their operands — not necessarily a bool.

# Short-circuit: stop evaluating once the result is known
if user and user.is_active:
    ...                          # safe — user.is_active not checked if user is None

# Return-the-operand semantics
print(None or "default")    # 'default'
print("hi" and "bye")      # 'bye'
print("" or "fallback")     # 'fallback'

Falsy Values Recap

These are falsy: False, None, 0, 0.0, "", [], (), {}, set(). Everything else is truthy. Use this idiomatically:

if items:                       # Pythonic — not `if len(items) > 0:`
    process(items)

if name:                        # tests non-empty string
    greet(name)

for Loops

Python's for iterates over any iterable — list, tuple, string, dict, set, generator, file, range, anything implementing __iter__. There is no C-style for (i=0; i<n; i++).

# Iterate over a list
for name in ["Alice", "Bob", "Carol"]:
    print(f"Hello, {name}")

# Iterate with range() — equivalent of C-style loop
for i in range(5):              # 0, 1, 2, 3, 4
    print(i)

for i in range(1, 10, 2):       # 1, 3, 5, 7, 9 (start, stop, step)
    print(i)

# Iterate over a string — gives characters
for ch in "hi":
    print(ch)

# Iterate over a dict — gives keys by default
user = {"name": "Alice", "age": 30}
for key in user:
    print(key, user[key])

# Often clearer: iterate over .items()
for key, value in user.items():
    print(f"{key}: {value}")

enumerate and zip

Two indispensable built-ins for clearer loops.

# enumerate — index + value, no manual counter
for i, name in enumerate(names, start=1):
    print(f"{i}. {name}")

# zip — iterate two (or more) iterables in lock-step
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# zip stops at shortest. Use strict=True (3.10+) to error on mismatch.
for a, b in zip(xs, ys, strict=True):
    ...

while Loops

Use while when you don't know how many iterations you'll need. For known counts, prefer for.

count = 0
while count < 5:
    print(count)
    count += 1

# Loop until a condition
while True:
    line = input("> ")
    if line == "quit":
        break
    process(line)

break, continue, and the loop-else clause

# break exits the loop entirely
for i in range(100):
    if found(i):
        break

# continue skips to the next iteration
for n in numbers:
    if n < 0:
        continue            # skip negatives
    process(n)

# Loop else — runs only if the loop completed without break
for n in numbers:
    if n == target:
        print("found")
        break
else:
    print("not found")        # only reached if no break

match (Python 3.10+)

Structural pattern matching is much more than a switch statement. It can destructure tuples, dicts, lists, and class instances, bind names, and apply guards.

Basic match

def http_response(status: int) -> str:
    match status:
        case 200:
            return "OK"
        case 301 | 302:                  # OR pattern
            return "Redirect"
        case 404:
            return "Not Found"
        case _:                          # wildcard / default
            return "Unknown"

Destructuring Patterns

def describe(point):
    match point:
        case (0, 0):
            return "origin"
        case (x, 0):                     # binds x
            return f"on x-axis at {x}"
        case (0, y):
            return f"on y-axis at {y}"
        case (x, y) if x == y:           # guard clause
            return f"diagonal at ({x}, {y})"
        case (x, y):
            return f"({x}, {y})"

Class Patterns

from dataclasses import dataclass

@dataclass
class Circle:
    radius: float

@dataclass
class Rectangle:
    width: float
    height: float

def area(shape) -> float:
    match shape:
        case Circle(radius=r):
            return 3.14159 * r * r
        case Rectangle(width=w, height=h):
            return w * h

Comprehensions

Comprehensions build collections in one expression. They're more concise — and usually faster — than the equivalent for loop with append.

List Comprehensions

# Build a list of squares
squares = [n * n for n in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# With a filter
evens = [n for n in range(20) if n % 2 == 0]

# Nested
matrix = [[1, 2], [3, 4]]
flat = [n for row in matrix for n in row]
# [1, 2, 3, 4]

Dict and Set Comprehensions

# Dict comprehension
lookup = {n: n * n for n in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Set comprehension — deduplicates automatically
unique_lengths = {len(w) for w in words}

Generator Expressions

Same syntax but with parentheses — produces a lazy generator instead of materializing a list. Use them when feeding a function that consumes an iterable.

# No intermediate list — streams values
total = sum(n * n for n in range(1_000_000))

# Compare with list comp — builds 1M-element list first (wastes memory)
total = sum([n * n for n in range(1_000_000)])

Exception Flow (preview)

Exceptions are a form of control flow. We cover them in depth in the Exceptions tutorial, but the basic shape:

try:
    n = int(user_input)
except ValueError as e:
    print(f"not a number: {e}")
else:
    print(f"got {n}")             # runs only if no exception
finally:
    print("done")                  # always runs

Quick Reference