Python If Else: Syntax and Common Mistakes
Practical guide to Python if/else syntax, conditional expressions, list comprehensions, and common pitfalls.
Writing a conditional statement in Python is straightforward: the if keyword runs a block when a condition is true, and the optional else clause runs a block when it is false. This article explains the core syntax, common usage patterns, and the mistakes that appear in real Python code.
Basic If-Else Syntax
A minimal if/else block looks like this:
temperature = 25 if temperature > 20: print('Warm day') else: print('Cold day')
The condition can be any expression that Python can evaluate as truthy or falsy. The block after the colon is indented; all lines with the same indentation form the block. The else clause is optional. If you omit it, the program simply does nothing when the condition is false.
Conditions are not limited to comparisons. You can use any expression that returns a value, such as a function call or a boolean variable. Python's truthiness rules determine the outcome: False, zero, None, empty strings, and empty containers such as lists, tuples, sets, and dictionaries are falsy; most other values are truthy.
Using Elif for Multiple Conditions
When you need to handle more than two outcomes, use elif, which is a contraction of else if. The conditions are evaluated in order, and the first one that is true triggers its block. Once a condition matches, the remaining elif and else blocks are skipped.
score = 85 if score >= 90: grade = 'A' elif score >= 80: grade = 'B' elif score >= 70: grade = 'C' else: grade = 'F'
This is more readable than nesting multiple if statements. The elif chain also makes the order of evaluation explicit, which is important when conditions are not mutually exclusive. In the example above, a score of 85 first fails score >= 90, then passes score >= 80, so the grade is B. If you reorder the conditions, the result can change.
Nested Conditionals and Readability
Sometimes a condition depends on another condition. You can nest if blocks, but deep nesting quickly becomes hard to read. Consider this example:
user_logged_in = True is_admin = False if user_logged_in: if is_admin: print('Admin panel') else: print('User dashboard') else: print('Please log in')
The logic is correct, but the indentation level grows with each nesting. When possible, flatten the structure using logical operators. The same behavior can be expressed with and and not:
if user_logged_in and is_admin: print('Admin panel') elif user_logged_in: print('User dashboard') else: print('Please log in')
This version is easier to scan because the conditions are aligned. Use nesting only when a condition genuinely requires a separate context, such as when you need to access a variable that is defined only after an outer check passes.
Ternary Expressions: One-Line Conditionals
Python provides a conditional expression, often called the ternary operator, that lets you write a simple if/else in a single line. The syntax is:
value_if_true if condition else value_if_false
For example:
status = 'active' if user.is_active else 'inactive'
This is concise and works well for assignments where both branches are simple expressions. It is not a replacement for full if/else blocks. If you need to execute multiple statements or perform complex logic, use the regular block form. Overusing the ternary operator can hurt readability, especially when the condition or branch expressions are long.
Common Mistakes and Pitfalls
Several mistakes appear frequently in Python code that uses conditionals. The most common is forgetting the colon at the end of the if or else line. Without it, Python raises a SyntaxError. Another frequent issue is inconsistent indentation. Python uses indentation to define blocks, so mixing tabs and spaces or varying the indentation level can cause an IndentationError or, for ambiguous tab/space mixtures, a TabError.
A logical mistake is using the assignment operator = instead of the equality operator == in a condition. For example:
if user = 'admin': # Wrong: assignment, not comparison pass
This raises a SyntaxError in Python because = is an assignment statement, not an expression. To compare two values, use ==.
Another pitfall is relying on truthiness without understanding it. An empty list, empty string, or 0 is falsy, so a condition like if my_list: is true only when the list contains at least one element. This is often desired, but it can be surprising when you expect a None check to behave like a general falsy check. Use is None when you specifically need to test for None rather than a falsy value.
Short-Circuit Evaluation
The logical operators and and or short-circuit: they stop evaluating as soon as the result is determined. This behavior is important for correctness. For example:
if user is not None and user.is_active: # do something
If user is None, the first condition is false, so Python does not evaluate user.is_active. This prevents an AttributeError. The same principle applies to or: if the first operand is true, the second is never evaluated.
Short-circuiting can also avoid unnecessary work when a later condition is expensive, such as a database query or complex computation. However, the main benefit is usually correctness. Placing the cheaper or guarding condition first is a common and recommended pattern.
Using Conditionals in List Comprehensions
List comprehensions can incorporate conditionals in two main ways. The first is a filter at the end, which keeps only elements that satisfy a condition:
numbers = [1, 2, 3, 4, 5] even = [n for n in numbers if n % 2 == 0]
The second is a conditional expression at the beginning, which transforms each element based on a condition:
labels = ['even' if n % 2 == 0 else 'odd' for n in numbers]
These two forms are easy to confuse. The filter if appears after the for clause and removes items; the conditional expression appears before the for clause and applies to every item. Using them together is possible but can reduce readability. For example, to keep only even numbers and label them, you could write:
labels = ['even' for n in numbers if n % 2 == 0]
This comprehension filters first, then applies the expression to the remaining items. Understanding the distinction helps you write comprehensions that behave as intended and avoid subtle bugs where you accidentally filter instead of transform.