In [x for row in rows if row for x in row], what does the if clause filter?

## Where an if attaches A comprehension is a sequence of clauses: the first is always a `for`, and each later clause is either another `for` or an `if`. The transliteration rule is the same one that governs nesting — read left to right and write each clause inside the previous one, with `if` becoming a plain `if` statement. So: ```python result = [x for row in rows if row for x in row] ``` becomes: ```python result = [] for row in rows: if row: # runs once per row for x in row: result.append(x) ``` and moving the test to the end: ```python result = [x for row in rows for x in row if x > 2] ``` becomes: ```python result = [] for row in rows: for x in row: if x > 2: # runs once per item result.append(x) ``` The `if` does **not** filter the finished list, and it does **not** always apply to the output expression. It applies at whatever loop depth it is written at. ## What placement changes Three things at once, and it is worth separating them in an interview answer. **Which values are tested.** An outer-level test sees the sublist; an inner-level test sees the item. These are different objects, so the predicate itself is usually different code, not the same code moved. **How much work happens.** A guard on the outer clause can eliminate a whole sublist and everything the inner loop would have done with it. If the inner iterable is produced by a call, an outer guard also prevents that call from happening for skipped rows — which matters when the call is expensive, opens a resource, or can raise. **What is even legal.** A clause may only use names bound by clauses to its left. Writing `[x for row in rows if x > 2 for x in row]` fails, because `x` is bound by a clause further right; on CPython 3.14 the error is an `UnboundLocalError`, which is a subclass of `NameError`. The correct reading order is therefore also the binding order. ## Multiple if clauses Any number of `if` clauses may appear, at any depth, and consecutive ones at the same depth read as a chain of nested tests — equivalent to combining them with `and`, evaluated left to right with short-circuiting. Two separate clauses are often clearer than one long boolean expression, especially when the second test is only safe once the first has passed: ```python [x for row in rows if row if len(row) < 100 for x in row] ``` ## Ordering a guard before a dependent iterable The strongest practical use of an outer-level `if` is as a guard for the clause to its right. Because clauses are evaluated in written order, a test placed before a `for` clause runs before that clause's iterable expression is evaluated at all. That gives comprehensions the same short-circuit shape as a guarded nested loop: check the sublist is present and well-formed, then iterate it. ## The readability ceiling Once a comprehension carries two `for` clauses and two `if` clauses, the one-line form has stopped paying for itself. The transliteration is still mechanical, but a reader now has to perform it mentally to answer a simple question such as which values are being tested. The honest senior answer names a threshold — commonly one `for` plus one `if`, or two `for` clauses with a single guard — and moves anything past it into a named generator function or an explicit loop, where each level of nesting has its own line and can carry a comment. ## What interviewers are probing This question is not trivia about syntax placement. It checks whether the candidate has the transliteration rule available, because everything else — which values a test sees, what work is skipped, why one arrangement fails to run — falls straight out of that rule. A candidate who answers by rewriting the comprehension as nested statements has demonstrated the skill; a candidate who has merely memorised that the filter goes at the end has not, and will place a per-row guard in the wrong position the first time a sublist can be empty.