Control Flow: Intermediate

Reject bad inputs before they cause bugs

def process(value):
    if value is None:
        ___return 0passprint("error")
    return value * 2

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.

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.

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

value = 85
if 0 <= value <= 100:
  print("Valid")
elif 0 > value >= 100:
  print("Invalid")

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.

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.

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

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

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

def classify(command):
    match command:
        case "start":
            return "Starting"
        case "stop":
            return "Stopping"
        case ____"other"default:
            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.

def day_type(day):
    ___ day:
        case "Sat" ___ "Sun":
            return "weekend"
        case _:
            return "weekday"
print(day_type("Sat"))

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.

Assign values based on conditions inline

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

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

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

value = 0
result = value if ___value is not Nonevaluevalue != 0 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.

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.

None / null values

Missing or unset data that causes crashes when accessed

Empty collections

Lists, strings, and dicts with zero elements

Zero values

Division by zero, zero-length strings, index zero edge cases

Negative numbers

When only positive values are expected by the logic

Boundary values

First and last elements, min and max limits

Invalid types

A string where an integer was expected, or vice versa

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

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

def safe_divide(a, b):
    if b ___ 0:
        return 0
    return a ___ b
print(safe_divide(10, 0))
print(safe_divide(10, 2))

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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

def get_first(items):
  return items[0]

print(get_first([10, 20]))
print(get_first([]))
print(get_first(None))