Pages

Topics

Tools

↑↓navigate↵openescclose
All guides

Python List Comprehension Multiple Conditions

Use multiple conditions in Python list comprehensions: filter with chained if clauses, transform with if-else expressions, and avoid common syntax errors.

~3 min readPython
#list comprehension#conditional logic#python syntax#filtering
A diagram showing a Python list comprehension pipeline where items pass through two stacked condition gates before being transformed into an output list.

Python list comprehensions combine iteration, filtering, and transformation into a single expression. When you need to apply multiple conditions in a Python list comprehension, the syntax has two distinct forms that behave very differently: multiple if clauses that filter items, and an if-else expression that transforms each value. Mixing them up produces code that either filters when you meant to transform, or raises a SyntaxError when the conditional expression lands in the wrong position.

The Two Kinds of Conditions in a Comprehension

A list comprehension has this general shape:

python
[expression for item in iterable if condition]

The if condition part is a filter. It keeps items for which the condition is true and discards the rest. You can chain several if clauses:

python
numbers = range(1, 101) result = [n for n in numbers if n % 2 == 0 if n % 3 == 0]

This keeps numbers divisible by both 2 and 3, which means 6, 12, 18, and so on. Multiple if clauses combine with logical AND. You can write the same filter as a single predicate:

python
result = [n for n in numbers if n % 2 == 0 and n % 3 == 0]

Both forms produce identical results. The chained version reads like a sequence of filters; the and version reads like one combined predicate. The choice is mostly about readability, not behavior.

Using if-else to Transform Values

The other form uses a conditional expression in the output position:

python
values = [-5, 3, -2, 7, 0] result = [x if x > 0 else 0 for x in values]

Here x if x > 0 else 0 is evaluated for every item. Positive values pass through unchanged; everything else becomes 0. This is a transformation, not a filter. The resulting list keeps its original length.

The conditional expression is a full Python expression, so it can be combined with other operations or nested:

python
result = ["even" if x % 2 == 0 else "odd" for x in range(10)]

Why Position Determines Behavior

The filter if appears after the for clause. The conditional expression appears in the output position, before the for. Placing a conditional expression after for is a syntax error:

python
# SyntaxError: invalid syntax result = [x for x in values if x > 0 else 0]

The parser expects if to introduce a filter there, not a ternary. If you need both a filter and a transformation, you combine the two forms:

python
values = [-5, 3, -2, 7, 0] result = [x * 10 if x > 0 else x for x in values if x != 0]

Reading order matters: the trailing if x != 0 filters first, then the leading x * 10 if x > 0 else x transforms whatever remains. The filter runs before the output expression, so the transformation only ever sees items that survived.

Multiple for Clauses with Conditions

Nested loops in a comprehension follow the same order as nested for statements:

python
matrix = [[1, 2], [3, 4]] flat = [n for row in matrix for n in row if n % 2 == 0]

The for row in matrix loop runs first, then for n in row, then the filter. You can attach conditions at either level:

python
pairs = [(a, b) for a in range(3) for b in range(3) if a != b if a + b > 2]

Because a condition is evaluated when its dependent loop variables are bound, both a and b are available in each filter. The evaluation order is the same as a nested loop: the first loop variable changes slowest, and each filter runs as soon as its dependent variables are bound.

Readability Limits

A comprehension with two for clauses and two conditions is already hard to scan. Add a conditional expression and the line becomes dense:

python
result = [x if x > 0 else -x for row in matrix for x in row if x != 0 if abs(x) < 10]

This is correct Python, but a reader has to parse the output expression, two loops, and two filters in a single line. When the logic grows past that point, a regular loop is usually clearer:

python
result = [] for row in matrix: for x in row: if x != 0 and abs(x) < 10: result.append(x if x > 0 else -x)

The loop version makes the evaluation order explicit and leaves room for comments. It also supports break, continue, and statements that a comprehension cannot contain. A comprehension is not always the better tool; it is the more compact tool.

Performance and Memory Considerations

A list comprehension builds the entire list in memory before any consumer sees it. For large inputs, that allocation can dominate runtime. A generator expression keeps the same filtering and transformation logic but yields items lazily:

python
gen = (x * 10 if x > 0 else x for x in values if x != 0)

The syntax differs only in the brackets. The generator avoids building the full list, which matters when the result is consumed by a loop, sum(), any(), or another function that processes items one at a time. If you need the actual list, for indexing, repeated iteration, or passing to a function that requires a sequence, the list comprehension is the right choice.

The filter also short-circuits per item: an item that fails the first condition is never evaluated against later conditions, and the output expression never runs for it. That ordering is worth keeping in mind when some conditions are more expensive to evaluate than others. Placing a cheap condition before an expensive one can reduce the number of expensive evaluations, whether you use a comprehension or a generator expression.

Try matching browser tools

All tools

Small utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.

All Python guides

More in Python

All Python guides

The guides filed next to this one in Python, in library order.