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.

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:
[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:
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:
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:
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:
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:
# 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:
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:
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:
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:
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:
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:
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 toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.