Run code only when conditions are true

The if statement is the most fundamental control flow construct. It evaluates a condition, and if that condition is true, it executes the indented code block that follows. If the condition is false, the code block is skipped entirely.

The word "if" means exactly what it does in English: "if this is true, do that." Python checks the condition, and only runs the indented code when the condition evaluates to True.

An if statement consists of the keyword if, followed by a condition, followed by a colon :. The code to execute when true must be indented (typically 4 spaces):

The condition in an if statement must evaluate to a boolean value (True or False). Comparison operators naturally produce boolean results:

Notice that equality comparison uses == (two equals signs), not = (single equals, which is assignment). This is a common source of errors.

== Equal to

True when both sides have the same value

!= Not equal

True when the two sides differ in value

> and < Ordering

Checks if left is strictly greater or less than right

>= and <= Inclusive

Includes the boundary value in the comparison

Python evaluates any value as True or False in a conditional context. Empty collections, zero, None, and empty strings are "falsy" (treated as False). Everything else is "truthy" (treated as True). This allows concise conditions:

items = []
if ___itemsnot itemsitems == None:
    print("empty")
else:
    print("has items")

Python's truthy and falsy rules make conditions concise. Checking if items: is shorter and clearer than if len(items) > 0:, and it handles None gracefully as well since None is also falsy.

The in operator is one of the most readable ways to check membership. Using status in valid_statuses communicates intent clearly compared to a long chain of equality comparisons.

Choose between two code paths

Often you need to choose between two alternatives: do one thing if a condition is true, or do something else if it's false. The else clause provides this "otherwise" path. The else block executes only when the if condition is False.

The else keyword comes after the if block, at the same indentation level as if, followed by a colon:

The modulo operator % returns the remainder after division. If a number divided by 2 has remainder 0, it is even; otherwise it is odd.

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

number = 8
if number % 2 = 0:
  print("even")
else:
  print("odd")

Route logic through multiple branches

When you have more than two possibilities, use elif (short for "else if"). An elif clause lets you check additional conditions when the previous conditions were False. You can chain as many elif clauses as needed.

Each elif has its own condition. Python checks conditions from top to bottom and executes the first block whose condition is True:

score = 75
if score >= 90:
    grade = "A"
___elifelse ifif score >= 80:
    grade = "B"
else:
    grade = "C"
print(grade)

The elif keyword is Python's way of linking conditions into a single chain. Unlike separate if statements, only one branch in an if-elif-else chain will ever run, which prevents duplicate logic from accidentally executing.

Order matters in elif chains. Python stops at the first true condition, so placing broader conditions before narrower ones can cause logic errors. Always arrange conditions from most specific to most general.

When you have more than five or six elif branches, consider replacing the chain with a dictionary lookup. Dictionaries are O(1) and easier to extend than long chains where conditions must be checked in sequence.

Combine conditions with boolean logic

Often a single comparison is not enough. You need to check multiple conditions together. Python provides logical operators to combine conditions: and requires all conditions to be true, or requires at least one condition to be true, and not inverts a condition.

The and operator returns True only if BOTH conditions are True. If either condition is False, the entire expression is False. This is essential for validation where multiple requirements must all be met. For example, a user might need to be both logged in AND have permission to access a resource. A transaction might need to be both under the limit AND from a verified account:

All conditions connected by and must be True for the block to execute. You can chain multiple and operators together.

The or operator returns True if AT LEAST ONE condition is True. It only returns False if all conditions are False:

Only one condition needs to be True for the entire expression to be True. The user is a moderator, so they have elevated privileges even though they are not an admin or owner.

The not operator inverts a boolean value. True becomes False, and False becomes True:

Operator precedence: not is evaluated first, then and, then or. When in doubt, use parentheses to make your intent explicit.

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

day = "Saturday"
if day == "Saturday" or "Sunday":
  print("Weekend")
else:
  print("Weekday")

Every operand of or must be a complete boolean expression. Writing day == "Saturday" or "Sunday" is a common mistake because Python reads "Sunday" as a standalone truthy value rather than as a second comparison target.

Short-circuit evaluation means Python stops evaluating or as soon as it finds a truthy value. For and, it stops at the first falsy value. Understanding this behavior helps you order conditions for both correctness and efficiency.

temp = 72
sunny = False
if temp > 70 ___ sunny:
    plan = "beach"
elif temp > 70 ___ sunny:
    plan = "park"
else:
    plan = "home"
print(plan)

The and and or operators let you express requirements precisely. and is for situations where all conditions must be satisfied simultaneously; or is for situations where meeting any one of several criteria is sufficient.

Logical operators are evaluated in a fixed order of precedence: not first, then and, then or. Using parentheses to override this order makes your intent clear and prevents hard-to-spot logic bugs.

Compound conditions are the building blocks of data filtering. Almost every query, validation rule, and business logic check you write will combine simple comparisons using and, or, and not.

Trace how Python picks which lines run

Nested conditionals can often be rewritten using and. Choose based on whether you need different else blocks at each level:

Python uses short-circuit evaluation for and and or operators. This means Python stops evaluating as soon as it knows the final result. With and, if the first condition is False, Python does not evaluate the second. With or, if the first condition is True, Python does not evaluate the second. This is both an optimization and a safety feature:

value = ""
fallback = "default"
result = value ___ fallback
print(___(result))

This example combines if/elif/else for categorization with a separate if for flagging. Notice how the large transaction check is independent of the type categorization, so it uses a separate if statement rather than being nested inside the type checks.

The last mistake is particularly tricky. day == "Saturday" or "Sunday" evaluates as (day == "Saturday") or "Sunday". Since "Sunday" is a non-empty string (truthy), the condition is always True.