IntermediatePython · 33 min

Control Flow: Intermediate

Airbnb's booking system must validate dozens of conditions before confirming any reservation, including calendar availability, payment authorization, identity verification, age restrictions, and local legal requirements, and it uses Python's short-circuit evaluation and guard clauses to stop checking the moment any one condition fails. Rather than running every check regardless of outcome, the system exits at the first failure, saving computation and returning a precise error to the user instantly. This approach keeps the booking code flat and readable, with each validation rule standing alone as a clear guard rather than buried inside nested if-else blocks. The patterns you learn in this lesson are exactly how engineers at Airbnb keep complex multi-condition logic maintainable as regulations and business rules continue to evolve.

Guard Clauses

Daily Life
Interviews

Reject bad inputs before they cause bugs

A guard clause is a conditional statement at the beginning of a function or code block that checks for invalid or edge cases and exits early. Instead of nesting your main logic inside an if block, you check for the "bad" cases first and handle them immediately. This keeps your main logic at the top level of indentation.
The term "guard" comes from the idea that these clauses guard the main logic from invalid inputs. They stand at the entrance and turn away anything that should not proceed.

The Problem: Deep Nesting

Consider code that validates multiple conditions before proceeding. Without guard clauses, you end up with deeply nested code that is hard to follow:
# Without guard clauses - deeply nested
def process_user_deeply_nested(user):
if user is not None:
if user.get("active"):
if user.get("verified"):
if user.get("balance", 0) > 0:
return "Processing: " + user.get("name")
else:
return "Error: No balance"
else:
return "Error: Not verified"
else:
return "Error: Inactive"
else:
return "Error: No user"
# Test it
user = {"name": "Alice", "active": True, "verified": True, "balance": 100}
print(process_user_deeply_nested(user))
>>>Output
Processing: Alice
Notice how the main logic (processing the user) is buried four levels deep. Each condition pushes the happy path further to the right. This is often called the "arrow anti-pattern" because the code forms an arrow shape.

Refactoring: Guard Clauses

Guard clauses invert the conditions and return early for invalid cases. The main logic stays at the base indentation level:
# With guard clauses - flat and readable
def process_user(user):
# Guard clauses handle edge cases first
if user is None:
return "Error: No user"
if not user.get("active"):
return "Error: Inactive"
if not user.get("verified"):
return "Error: Not verified"
if user.get("balance", 0) <= 0:
return "Error: No balance"
# Main logic at base indentation
return "Processing: " + user.get("name")
# Test with various users
valid = {"name": "Alice", "active": True, "verified": True, "balance": 100}
inactive = {"name": "Bob", "active": False, "verified": True, "balance": 50}
print(process_user(valid))
print(process_user(inactive))
print(process_user(None))
>>>Output
Processing: Alice
Error: Inactive
Error: No user
Each guard clause is independent and easy to understand. You can read them from top to bottom: "If no user, error. If inactive, error. If not verified, error. If no balance, error. Otherwise, process."
The guard clause pattern follows a consistent sequence that keeps your main logic clean and readable:
01
Identify bad input
List every edge case that should prevent normal processing
02
Check and exit early
Each guard tests one condition and returns immediately if it fails
03
Write main logic
After all guards pass, write the happy path at the base indentation

Guard Clauses Everywhere

You can apply the guard clause pattern even when not using functions, by continuing to the next iteration or breaking early:
records = [
{"id": 1, "value": 100},
{"id": 2, "value": None},
{"id": 3, "value": -50},
{"id": 4, "value": 200},
]
valid_records = []
for record in records:
# Guard: skip if value is None
if record.get("value") is None:
print("Skipping record", record["id"], "- no value")
continue
# Guard: skip negative values
if record["value"] < 0:
print("Skipping record", record["id"], "- negative value")
continue
# Main logic: process valid record
valid_records.append(record)
print("Valid records:", len(valid_records))
>>>Output
Skipping record 2 - no value
Skipping record 3 - negative value
Valid records: 2
TIP
Guard clauses work best when you have many conditions to check. If you only have one or two simple conditions, a regular if-else might be clearer.
Fill in the Blank

> A function receives a value that might be None. Pick what the guard clause should do when it detects invalid input.

def process(value):
    if value is None:
        
    return value * 2
Guard clauses make the contract of a function explicit. When you list preconditions at the top, any reader immediately knows what the function requires before it will do anything meaningful.
The "return early" style keeps the happy path at the leftmost indentation level. This also makes it easy to add new guards later without restructuring the entire function body.

In loops, guard clauses use continue instead of return to skip invalid records while keeping the loop running. This pattern is common in data pipelines where you want to process as many records as possible and quarantine the bad ones.

Chained Comparisons

Daily Life
Interviews

Validate ranges with readable expressions

Python allows you to chain comparison operators in a way that reads naturally. Instead of writing x > 5 and x < 10, you can write 5 < x < 10. This matches how you would express ranges in mathematics and makes your code more readable.

Basic Chained Comparisons

You can chain any comparison operators together. Python evaluates them left to right, and all comparisons must be true for the entire expression to be true:
x = 15
# Instead of: x > 10 and x < 20
if 10 < x < 20:
print(x, "is between 10 and 20 (exclusive)")
# Instead of: x >= 10 and x <= 20
if 10 <= x <= 20:
print(x, "is between 10 and 20 (inclusive)")
# Chain more than two comparisons
y = 5
if 0 < y < 10 < x < 20:
print("Both y and x are in their expected ranges")
# Works with variables on all sides
low = 10
high = 20
if low < x < high:
print(x, "is between", low, "and", high)
>>>Output
15 is between 10 and 20 (exclusive)
15 is between 10 and 20 (inclusive)
Both y and x are in their expected ranges
15 is between 10 and 20

The expression 10 < x < 20 is equivalent to 10 < x and x < 20, but shorter and more readable. Python evaluates x only once.

Chained comparisons are especially useful in data validation, where you frequently need to confirm values fall within acceptable ranges:
a < x < ba <= x <= ba == b == ca < b < c
a < x < b
Exclusive
Value between, not equal
a <= x <= b
Inclusive
Value between or on edge
a == b == c
All equal
Every value is identical
a < b < c
Sorted order
Values are ascending left

Practical Range Checking

Chained comparisons are perfect for validating that values fall within expected ranges:
def validate_percentage(value):
"""Validate percentage."""
if 0 <= value <= 100:
return "Valid percentage"
return "Invalid: must be 0-100"
def validate_age(age):
"""Validate age."""
if 0 < age < 150:
return "Valid age"
return "Invalid age"
def categorize_temperature(temp):
"""Categorize temperature."""
if temp < 32:
return "freezing"
elif 32 <= temp < 50:
return "cold"
elif 50 <= temp < 70:
return "cool"
elif 70 <= temp < 85:
return "warm"
else:
return "hot"
print(validate_percentage(75))
print(validate_percentage(150))
print(categorize_temperature(65))
>>>Output
Valid percentage
Invalid: must be 0-100
cool

Chaining Comparisons

You can also chain equality operators, which is useful for checking if multiple values are equal:
a = 5
b = 5
c = 5
# Check if all three are equal
if a == b == c:
print("All three values are equal")
# Check if sorted in order
x = 1
y = 2
z = 3
if x < y < z:
print("Values are in ascending order")
if x <= y <= z:
print("Values are in non-descending order")
# Mix of operators
score = 85
if 80 <= score < 90:
print("Grade: B")
>>>Output
All three values are equal
Values are in ascending order
Values are in non-descending order
Grade: B
Debug Challenge

> This percentage validator has a condition that can never be True. Fix the logic so invalid values are caught correctly.

Logic error: the elif condition can never be True. A number cannot be both less than 0 AND greater than or equal to 100.

Chained comparisons are especially easy to get wrong when combining inequality operators. The safest approach is to read the chain aloud as a mathematical expression: "Is value at least 0 and at most 100?" maps directly to "0 <= value <= 100".
When the valid range is clear, an else clause handles everything outside it without needing a second chained comparison. Trying to express the invalid range as its own chain often leads to a condition that can never be satisfied.

Chained comparisons only work in one direction. Python evaluates a < x < b left to right, so a < x and x < b. If you reverse the direction inconsistently, like a < x and x >= b combined, you may accidentally overlap or leave gaps in your range logic.

Pattern Matching with match-case

Daily Life
Interviews

Dispatch on value patterns cleanly

Python 3.10 introduced match-case, also known as structural pattern matching. It provides a cleaner way to handle multiple conditions compared to long if-elif-else chains. The match statement compares a value against several patterns and executes the code for the first matching pattern.

Basic match-case Syntax

The match keyword is followed by the value to match, then case clauses define patterns to match against:

def get_day_type(day):
match day:
case "Saturday" | "Sunday":
return "weekend"
case "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday":
return "weekday"
case _:
return "unknown"
print(get_day_type("Saturday"))
print(get_day_type("Wednesday"))
print(get_day_type("Holiday"))
>>>Output
weekend
weekday
unknown

The | operator matches multiple patterns (like "or"). The underscore _ is a wildcard that matches anything, like a default case.

Matching Values

Match-case is excellent for handling discrete values like status codes, commands, or types:
def handle_http_status(code):
match code:
case 200:
return "OK"
case 201:
return "Created"
case 400:
return "Bad Request"
case 401:
return "Unauthorized"
case 403:
return "Forbidden"
case 404:
return "Not Found"
case 500:
return "Internal Server Error"
case _:
return "Unknown Status"
print(handle_http_status(200))
print(handle_http_status(404))
print(handle_http_status(418))
>>>Output
OK
Not Found
Unknown Status

Matching with Guards

You can add an if clause after a pattern to add additional conditions. This is called a guard:

def categorize_number(n):
match n:
case 0:
return "zero"
case n if n < 0:
return "negative"
case n if n % 2 == 0:
return "positive even"
case _:
return "positive odd"
print(categorize_number(0))
print(categorize_number(-5))
print(categorize_number(8))
print(categorize_number(7))
>>>Output
zero
negative
positive even
positive odd
Guards let you add conditions that go beyond simple value matching. The pattern variable (n in this case) captures the matched value for use in the guard and the block.
Match-case supports several pattern types. Each serves a different matching strategy:
LiteralWildcardCaptureGuardOR |
Literal
Exact values
Matches a specific number
Wildcard
Catch-all _
Default if nothing else
Capture
Bind variable
Stores value for later use
Guard
if condition
Adds extra boolean check
OR |
Alternatives
Matches any of the options

Matching Sequences

Match-case can destructure sequences like lists and tuples, matching both structure and content. This is powerful for parsing data structures where the shape of the data determines how to handle it. Pattern matching automatically extracts values from the matched structure and binds them to variables:
def describe_point(point):
match point:
case (0, 0):
return "origin"
case (x, 0):
return "on x-axis at " + str(x)
case (0, y):
return "on y-axis at " + str(y)
case (x, y):
return "point at (" + str(x) + ", " + str(y) + ")"
case _:
return "not a point"
print(describe_point((0, 0)))
print(describe_point((5, 0)))
print(describe_point((0, 3)))
print(describe_point((2, 4)))
>>>Output
origin
on x-axis at 5
on y-axis at 3
point at (2, 4)
•Use match-case When
  • Many discrete values to handle
  • Pattern matching on structure
  • Command/event dispatching
  • Cleaner than long elif chains
•Use if-elif When
  • Complex boolean conditions
  • Only 2-3 conditions
  • Range-based comparisons
  • Python version < 3.10
Fill in the Blank

> A command classifier uses match-case. Pick the correct pattern for the default case that catches unrecognized commands.

def classify(command):
    match command:
        case "start":
            return "Starting"
        case "stop":
            return "Stopping"
        case :
            return "Unknown"
print(classify("restart"))

The wildcard pattern _ is the match-case equivalent of the else clause. Always include it to handle unexpected values gracefully rather than silently returning None when no case matches.

The | operator in match-case lets you group values that share the same handling. This is cleaner than a long elif chain with many == comparisons when several inputs lead to the same outcome.

Match-case was introduced in Python 3.10, so it is not available in older environments. In data pipelines running on legacy infrastructure, if-elif chains remain the appropriate alternative.
Python Quiz

> Classify a day as weekend or weekday using pattern matching. Pick the keyword that starts pattern matching, and the operator that combines alternative patterns in a single case.

def day_type(day):
     day:
        case "Sat"  "Sun":
            return "weekend"
        case _:
            return "weekday"
print(day_type("Sat"))
match
if
switch
|
&
Match-case reads naturally when each case corresponds to a meaningful category. The structure forces you to be explicit about every value the code handles, which makes exhaustive handling of a set of inputs clearer than a scattered chain of elif statements.
Guard clauses inside match cases (using "if" after the pattern) let you add conditions that go beyond simple value equality. This keeps complex logic organized inside a single match block rather than spreading it across nested if statements.

When you find yourself writing a long elif chain that compares one variable against many literal values, that is usually a signal to consider replacing it with match-case for improved readability and intent clarity.

Conditional Assignment

Daily Life
Interviews

Assign values based on conditions inline

Conditional assignment lets you assign a value to a variable based on a condition, all in a single line. This is also called a ternary expression or conditional expression. It makes your code more concise when you need to choose between two values.

Ternary Expression Syntax

The syntax is: value_if_true if condition else value_if_false. The condition goes in the middle:

age = 20
# Instead of:
# if age >= 18:
# status = "adult"
# else:
# status = "minor"
# Use conditional expression:
status = "adult" if age >= 18 else "minor"
print("Status:", status)
# More examples
score = 85
grade = "pass" if score >= 60 else "fail"
print("Grade:", grade)
temperature = 25
weather = "warm" if temperature > 20 else "cool"
print("Weather:", weather)
>>>Output
Status: adult
Grade: pass
Weather: warm

The conditional expression evaluates the condition first. If True, it returns the value before if. If False, it returns the value after else.

Using in Function Calls

Conditional expressions are especially useful when passing arguments to functions or building strings:
items = ["apple", "banana", "cherry"]
empty_list = []
# Use in function calls
print("Items:" if items else "No items")
print("Items:" if empty_list else "No items")
# Building messages
count = 5
message = str(count) + " item" + ("s" if count != 1 else "")
print(message)
count = 1
message = str(count) + " item" + ("s" if count != 1 else "")
print(message)
# Choose which function result to use
x = -5
result = abs(x) if x < 0 else x
print("Result:", result)
>>>Output
Items:
No items
5 items
1 item
Result: 5

Nested Conditionals

You can nest conditional expressions, but this quickly becomes hard to read. Use with caution:
score = 75
# Nested conditional expression - hard to read!
grade = "A" if score >= 90 else "B" if score >= 80 else "C" if score >= 70 else "F"
print("Grade:", grade)
# Better: use regular if-elif for more than 2 choices
# or split into multiple lines for readability:
grade = (
"A" if score >= 90 else
"B" if score >= 80 else
"C" if score >= 70 else
"F"
)
print("Grade (formatted):", grade)
>>>Output
Grade: C
Grade (formatted): C
TIP
Limit conditional expressions to simple two-way choices. If you have more than two options or complex conditions, use regular if-elif-else for clarity.
Ternary expressions are powerful but easy to misuse. Follow these guidelines to keep your conditional assignments readable:
✓Do
  • Use for simple two-way value selection
  • Keep both values short and clear
  • Split long expressions across lines
  • Use parentheses for nested ternaries
✗Don't
  • Chain more than two ternaries
  • Put side effects inside ternaries
  • Use when logic is complex
  • Sacrifice readability for brevity

Default Values with or

A common pattern uses or to provide default values. If the left side is falsy (None, empty, 0, False), the right side is used:

# Get name or use default
user_name = None
display_name = user_name or "Anonymous"
print(display_name)
# Get from dict with fallback
config = {"timeout": 30}
timeout = config.get("timeout") or 60
retries = config.get("retries") or 3
print("Timeout:", timeout)
print("Retries:", retries)
# Careful with 0 - it's falsy!
value = 0
result = value or 100 # This returns 100, not 0!
print("Result:", result)
# Use "is not None" for values that might be 0
value = 0
result = value if value is not None else 100
print("Safe result:", result)
>>>Output
Anonymous
Timeout: 30
Retries: 3
Result: 100
Safe result: 0
Fill in the Blank

> The value is 0, which is valid but falsy. Pick the ternary condition that correctly preserves 0 instead of replacing it.

value = 0
result = value if  else 100
print(result)

The or default pattern is convenient but dangerous when 0, False, or empty string are valid values. Switching to an explicit is not None check makes the intent unambiguous and prevents hard-to-find data loss bugs.

Ternary expressions work best for straightforward two-option assignments. When the condition or either value is long, split the expression across lines with parentheses to preserve readability.
Conditional assignment keeps related logic together on one line rather than spreading a simple value choice across four lines of if-else. This makes code scanning faster when you are reviewing a function's outputs at a glance.

Edge Case Handling

Daily Life
Interviews

Handle None, empty, and boundary inputs

Edge cases are inputs or situations at the boundaries of what your code handles: empty collections, zero values, negative numbers, None values, and extreme values. Robust code anticipates and handles these cases explicitly. Failure to handle edge cases is one of the most common sources of bugs.

Common Edge Cases

Here are the most common edge cases you should always consider:
None / null values
None / null values
Missing or unset data that causes crashes when accessed
Empty collections
Empty collections
Lists, strings, and dicts with zero elements
Zero values
Zero values
Division by zero, zero-length strings, index zero edge cases
Negative numbers
Negative numbers
When only positive values are expected by the logic
Boundary values
Boundary values
First and last elements, min and max limits
Invalid types
Invalid types
A string where an integer was expected, or vice versa

Handling None Values

None represents the absence of a value. Always check for None before using a value that might not exist:

def get_length(items):
# Guard against None
if items is None:
return 0
return len(items)
print(get_length([1, 2, 3]))
print(get_length(None))
# Using "is" for None
value = None
# Check for None
if value is None:
print("Value is None")
if value == None:
print("Value equals None")
# if not value: # Risky
>>>Output
3
0
Value is None
Value equals None

Always use is None rather than == None. The is operator checks identity, which is what you want for None.

Handling Empty Collections

Empty lists, strings, and dicts are falsy in Python, but you should often handle them explicitly:
def calculate_average(numbers):
# Guard against empty list
if not numbers:
return 0
return sum(numbers) / len(numbers)
print(calculate_average([10, 20, 30]))
print(calculate_average([]))
def get_first(items):
# Guard against empty
if not items:
return None
return items[0]
print(get_first(["a", "b", "c"]))
print(get_first([]))
# Check before accessing
data = {"users": []}
if data.get("users"):
print("Has users")
else:
print("No users")
>>>Output
20.0
0
a
None
No users
Python Quiz

> Guard against division by zero by checking the denominator first. Pick the comparison that detects zero, and the division operator that returns a float.

def safe_divide(a, b):
    if b  0:
        return 0
    return a  b
print(safe_divide(10, 0))
print(safe_divide(10, 2))
==
!=
>=
/
//
Division by zero and index-out-of-range errors are among the most common runtime crashes in data pipelines. A single guard clause at the start of a function is all it takes to make these errors safe and explicit.

None checks deserve special attention. Unlike other edge cases, None can appear anywhere a value is expected: from missing dictionary keys, unset function parameters, and failed lookups. Checking is None before use is a habit that pays off in reliability.

Combining None and empty-collection guards in the right order matters. If you call len(items) before checking items is None, you will get a TypeError before your None guard even has a chance to run.

Debug Challenge

> This function crashes on empty lists and None inputs. Add guard clauses so it handles edge cases safely.

IndexError: list index out of range (for empty list) and TypeError (for None)

Boundary Conditions

Pay special attention to boundary values: the first and last elements, minimum and maximum values:
def safe_divide(a, b):
# Guard against division by zero
if b == 0:
return None
return a / b
print(safe_divide(10, 2))
print(safe_divide(10, 0))
def get_element(items, index):
# Guard against out-of-bounds
if index < 0 or index >= len(items):
return None
return items[index]
data = [10, 20, 30]
print(get_element(data, 1))
print(get_element(data, 10))
print(get_element(data, -5))
>>>Output
5.0
None
20
None
None

Defensive Programming

A defensive programming approach handles edge cases at the start of every function:
def process_records(records):
"""Process a list of records safely."""
# 1. Handle None
if records is None:
print("Error: records is None")
return []
# 2. Handle wrong type
if not isinstance(records, list):
print("Error: records must be a list")
return []
# 3. Handle empty
if len(records) == 0:
print("Warning: no records to process")
return []
# 4. Main logic - records is non-empty
processed = []
for record in records:
if record is not None:
processed.append(str(record).upper())
return processed
print(process_records(["a", "b", "c"]))
print(process_records(None))
print(process_records("not a list"))
print(process_records([]))
>>>Output
['A', 'B', 'C']
Error: records is None
[]
Error: records must be a list
[]
Warning: no records to process
[]

Putting It All Together

Let us combine the patterns from this lesson into a realistic example. This data validation function uses guard clauses, chained comparisons, conditional expressions, and proper edge case handling:
def validate_user_record(record):
"""Validate a user record with comprehensive checks."""
# Guard: handle None input
if record is None:
return {"valid": False, "error": "Record is None"}
# Guard: check required fields exist
required = ["name", "email", "age"]
for field in required:
if field not in record:
return {"valid": False, "error": "Missing " + field}
# Validate name (non-empty string)
name = record["name"]
if not name or not isinstance(name, str):
return {"valid": False, "error": "Invalid name"}
# Validate email (contains @)
email = record["email"]
if not email or "@" not in email:
return {"valid": False, "error": "Invalid email"}
# Validate age (reasonable range)
age = record["age"]
if not 0 < age < 150:
return {"valid": False, "error": "Invalid age"}
# Determine user category
category = (
"minor" if age < 18 else
"adult" if age < 65 else
"senior"
)
return {
"valid": True,
"name": name.strip(),
"email": email.lower(),
"age": age,
"category": category
}
# Test with various inputs
tests = [
{"name": "Alice", "email": "alice@example.com", "age": 25},
{"name": "", "email": "test@test.com", "age": 30},
{"name": "Bob", "email": "invalid", "age": 40},
{"name": "Carol", "email": "carol@test.com", "age": 200},
None,
]
for test in tests:
result = validate_user_record(test)
if result["valid"]:
print("Valid:", result["name"], "-", result["category"])
else:
print("Invalid:", result["error"])
>>>Output
Valid: Alice - adult
Invalid: Invalid name
Invalid: Invalid email
Invalid: Invalid age
Invalid: Record is None
This function demonstrates several intermediate control flow patterns working together. Guard clauses at the top handle invalid inputs immediately. Chained comparisons validate the age range naturally. A conditional expression assigns the user category concisely. The function returns early for each error case, keeping the success path at the end. This structure makes the code self-documenting and easy to maintain as requirements evolve.

Data Processing Flow

Here is another practical example showing how to filter and transform a dataset using the patterns from this lesson. This kind of batch processing is common in ETL pipelines and data validation systems:
# Process a batch of transaction records
transactions = [
{"id": 1, "amount": 150, "type": "purchase", "status": "completed"},
{"id": 2, "amount": -50, "type": "refund", "status": "completed"},
{"id": 3, "amount": 0, "type": "purchase", "status": "pending"},
{"id": 4, "amount": 500, "type": "purchase", "status": "completed"},
{"id": 5, "amount": None, "type": "unknown", "status": "error"},
]
valid_total = 0
invalid_count = 0
for tx in transactions:
# Guard: skip if amount is invalid
amount = tx.get("amount")
if amount is None or amount <= 0:
invalid_count += 1
continue
# Guard: only process completed transactions
if tx.get("status") != "completed":
continue
# Categorize by amount
size = "large" if amount >= 200 else "small"
valid_total += amount
print("Processed tx", tx["id"], ":", amount, "(" + size + ")")
print("---")
print("Valid total:", valid_total)
print("Invalid count:", invalid_count)
>>>Output
Processed tx 1 : 150 (small)
Processed tx 4 : 500 (large)
---
Valid total: 650
Invalid count: 2
This data processing loop uses guard clauses with continue to skip invalid records, keeping the main processing logic clean and readable. Each guard clause handles one type of invalid data, making it easy to understand and modify the validation rules. The pattern scales well to complex pipelines with many validation steps, as each check remains independent and testable.

Chained Comparisons

Here is a more comprehensive example showing how chained comparisons simplify range-based validation and categorization in data pipelines:
def analyze_metrics(metrics):
"""Analyze performance metrics with range-based categorization."""
results = []
for metric in metrics:
name = metric["name"]
value = metric["value"]
# Categorize using chained comparisons
if value < 0:
status = "error"
message = "Negative value detected"
elif 0 <= value < 50:
status = "critical"
message = "Below acceptable threshold"
elif 50 <= value < 80:
status = "warning"
message = "Room for improvement"
elif 80 <= value <= 100:
status = "healthy"
message = "Within normal range"
else:
status = "error"
message = "Value exceeds maximum"
results.append({
"name": name,
"status": status,
"message": message
})
return results
# Test the analyzer
metrics = [
{"name": "CPU Usage", "value": 75},
{"name": "Memory", "value": 92},
{"name": "Disk Space", "value": 45},
{"name": "Network", "value": 88},
]
for result in analyze_metrics(metrics):
print(result["name"] + ":", result["status"], "-", result["message"])
>>>Output
CPU Usage: warning - Room for improvement
Memory: healthy - Within normal range
Disk Space: critical - Below acceptable threshold
Network: healthy - Within normal range
The chained comparisons make the range logic immediately clear. Reading "50 <= value < 80" is more intuitive than "value >= 50 and value < 80". This clarity is especially valuable when you return to code after months and need to quickly understand the boundaries. Python evaluates the expression efficiently, checking each comparison in sequence and stopping as soon as one fails.

Guard Clauses: API Handlers

Guard clauses are particularly valuable in functions that handle API requests or user input, where many things can go wrong. Here is a realistic example of a user registration handler:
def register_user(request):
"""Handle user registration with comprehensive validation."""
# Guard: request must exist
if request is None:
return {"error": "No request data", "code": 400}
# Guard: required fields
if "email" not in request:
return {"error": "Email is required", "code": 400}
if "password" not in request:
return {"error": "Password is required", "code": 400}
# Guard: email format
email = request["email"]
if "@" not in email or "." not in email.split("@")[-1]:
return {"error": "Invalid email format", "code": 400}
# Guard: password strength
password = request["password"]
if len(password) < 8:
return {"error": "Password must be at least 8 characters", "code": 400}
if password.lower() == password:
return {"error": "Password must contain uppercase letters", "code": 400}
# Guard: check if email already exists (simulated)
existing_users = ["alice@example.com", "bob@example.com"]
if email.lower() in existing_users:
return {"error": "Email already registered", "code": 409}
# Success case - all guards passed
return {
"success": True,
"message": "User registered successfully",
"email": email.lower(),
"code": 201
}
# Test with various inputs
test_requests = [
{"email": "new@example.com", "password": "SecurePass123"},
{"email": "invalid-email", "password": "Test1234"},
{"email": "alice@example.com", "password": "Test1234"},
{"email": "test@example.com", "password": "short"},
]
for req in test_requests:
result = register_user(req)
if result.get("success"):
print("OK:", result["message"])
else:
print("Error:", result["error"])
>>>Output
OK: User registered successfully
Error: Invalid email format
Error: Email already registered
Error: Password must be at least 8 characters
Each guard clause handles one specific validation failure. The function reads from top to bottom like a checklist: "If no request, error. If no email, error. If email invalid, error." This structure makes it easy to add new validations or modify existing ones without affecting other parts of the function. The pattern also makes testing straightforward, as each guard clause can be tested independently with inputs designed to trigger it.
Well-structured control flow makes code easier to read, test, and maintain.
❯❯❯PUTTING IT ALL TOGETHER

> You are a data engineer at Adyen building a transaction routing script that directs payments to different processing paths based on currency, amount, and risk score. The script must reject invalid inputs early, validate numeric bounds, dispatch by currency type, assign fee tiers conditionally, and handle missing or zero-value fields without crashing.

Guard clauses return early when currency is None or amount <= 0 so invalid transactions never reach the routing logic below.
Chained comparisons like 0 < amount <= 10000 validate that a transaction amount falls within an accepted processing band in one expression.
match-case dispatches each currency string to its corresponding processor path, with the wildcard _ case catching any unsupported currency.
Conditional assignment sets fee_tier = "premium" if risk_score > 80 else "standard" in one line, and edge case handling guards against a None risk_score with is None.
KEY TAKEAWAYS
Guard clauses exit early for invalid cases, keeping main logic at base indentation
Chained comparisons like a < x < b are more readable than using "and" for range checks
match-case provides cleaner multi-way branching than long elif chains (Python 3.10+)
Use _ as the wildcard/default case in match statements
Conditional expressions x if condition else y assign values based on conditions in one line
Always handle edge cases: None values, empty collections, zero, and boundaries
Use is None rather than == None for None checks
The "or" operator provides default values but treats 0 and "" as falsy

Writing cleaner conditional logic

Category
Python
Difficulty
intermediate
Duration
33 minutes
Challenges
0 hands-on challenges

Topics covered: Guard Clauses, Chained Comparisons, Pattern Matching with match-case, Conditional Assignment, Edge Case Handling

Lesson Sections

  1. Guard Clauses (concepts: pyGuardClauses)

    A guard clause is a conditional statement at the beginning of a function or code block that checks for invalid or edge cases and exits early. Instead of nesting your main logic inside an if block, you check for the "bad" cases first and handle them immediately. This keeps your main logic at the top level of indentation. The term "guard" comes from the idea that these clauses guard the main logic from invalid inputs. They stand at the entrance and turn away anything that should not proceed. The P

  2. Chained Comparisons (concepts: pyBooleanOps)

    Basic Chained Comparisons You can chain any comparison operators together. Python evaluates them left to right, and all comparisons must be true for the entire expression to be true: Chained comparisons are especially useful in data validation, where you frequently need to confirm values fall within acceptable ranges: Practical Range Checking Chained comparisons are perfect for validating that values fall within expected ranges: Chaining Comparisons You can also chain equality operators, which i

  3. Pattern Matching with match-case (concepts: pyMatchCase)

    Basic match-case Syntax Matching Values Match-case is excellent for handling discrete values like status codes, commands, or types: Matching with Guards Guards let you add conditions that go beyond simple value matching. The pattern variable (n in this case) captures the matched value for use in the guard and the block. Match-case supports several pattern types. Each serves a different matching strategy: Matching Sequences Match-case can destructure sequences like lists and tuples, matching both

  4. Conditional Assignment (concepts: pyTernary)

    Conditional assignment lets you assign a value to a variable based on a condition, all in a single line. This is also called a ternary expression or conditional expression. It makes your code more concise when you need to choose between two values. Ternary Expression Syntax Using in Function Calls Conditional expressions are especially useful when passing arguments to functions or building strings: Nested Conditionals You can nest conditional expressions, but this quickly becomes hard to read. U

  5. Edge Case Handling (concepts: pyGuardClauses)

    Common Edge Cases Here are the most common edge cases you should always consider: Handling None Values Handling Empty Collections Empty lists, strings, and dicts are falsy in Python, but you should often handle them explicitly: Division by zero and index-out-of-range errors are among the most common runtime crashes in data pipelines. A single guard clause at the start of a function is all it takes to make these errors safe and explicit. Boundary Conditions Pay special attention to boundary value