List comprehensions — `[expr for x in iterable if condition]`

WHY does this feature exist?

Intuition The motivation (WHY)

Building lists is the single most common thing you do in code. Without comprehensions you write a 4-line ritual every time:

result = []          # 1. make empty list
for x in iterable:   # 2. loop
    if condition:    # 3. filter
        result.append(expr)  # 4. transform + store

This is verbose, easy to get wrong (forgot to initialise? wrong indent?), and hides the intent (you want a new list) behind mechanics (loops, appends). Comprehensions collapse that whole pattern into one expression that says WHAT you want, not HOW to push items one by one.

WHAT is the exact anatomy?

The four moving parts, in reading order vs execution order:

Part	Name	Role
`expr`	output expression	what goes INTO the new list (computed last per item)
`for x in iterable`	the loop	where items come from (runs first)
`if condition`	filter (optional)	keep `x` only if `True`

![[1.2.34-List-comprehensions-—-`[expr-for-x-in-iterable-if-condition]`.png]]

HOW to derive it from the loop (do this once, never memorise)

Worked example Derivation: from loop → comprehension

Goal: squares of even numbers from 0 to 9.

Step 1 — write the honest loop.

result = []
for x in range(10):
    if x % 2 == 0:
        result.append(x**2)

Why this step? It states intent unambiguously and is impossible to misread.

Step 2 — identify the 3 ingredients.

expr = x**2 (what we append)
iterable = range(10)
condition = x % 2 == 0 Why this step? The comprehension is just these three slots filled in.

Step 3 — pour them into the template [expr for x in iterable if condition].

result = [x**2 for x in range(10) if x % 2 == 0]
# → [0, 4, 16, 36, 64]

Why this step? Same logic, zero boilerplate. The append + init disappear.

More worked examples

Worked example 1. Transform only (no filter)

words = ["apple", "fig", "kiwi"]
lengths = [len(w) for w in words]   # [5, 3, 4]

Why this step? No if, so every item is kept; expr = len(w) does the transform.

Worked example 2. Filter only (expr == the item itself)

nums = [3, -1, 4, -5, 9]
positives = [n for n in nums if n > 0]   # [3, 4, 9]

Why this step? expr is just n, so we copy items unchanged — the comprehension acts as a pure filter. This is the comprehension version of "keep what passes the test".

Worked example 3.

if/else — the TERNARY version (different position!)

nums = [3, -1, 4, -5]
signs = [n if n > 0 else 0 for n in nums]   # [3, 0, 4, 0]

Why this step? Here if...else is part of expr (a conditional expression that must return a value), so it goes ==BEFORE the for==. The filtering if goes AFTER the for. See the mistake below.

Worked example 4. Nested iterables (flatten a grid)

grid = [[1, 2], [3, 4], [5, 6]]
flat = [cell for row in grid for cell in row]   # [1,2,3,4,5,6]

Why this step? Two fors read outer-to-inner, top-to-bottom — exactly like nested loops: for row in grid: then for cell in row:. The leftmost for is the outermost loop.

Flashcards

What is the general template of a list comprehension?

[expr for x in iterable if condition]

In execution order, which part runs first: expr, for, or if?

The for (pick x), then if (filter), then expr (compute). Reading order ≠ execution order.

Where does the filter if (no else) go in a comprehension?

After the for: [x for x in xs if cond].

Where does the conditional if/else (ternary) go?

Before the for, as part of expr: [a if cond else b for x in xs].

Rewrite [x**2 for x in range(4)] as a loop.

r=[]; for x in range(4): r.append(x**2) → [0,1,4,9].

What does [c for row in grid for cell in row]-style multi-for mean?

Nested loops; leftmost for is the outermost loop, read top-to-bottom.

What is the value of [n for n in [-1,2,-3] if n>0]?

[2] (filters out negatives, keeps items unchanged).

Is the if condition part required?

No, it is optional; without it every item is included.

Recall Feynman: explain it to a 12-year-old

Imagine a conveyor belt of apples. A list comprehension is a tiny factory: the belt brings each apple (for apple in belt), a guard throws away the rotten ones (if apple is good), and a machine turns each remaining apple into apple juice (expr = juice). At the end you get a new box of apple juice. You didn't have to write "take empty box, walk to belt, check apple, drop juice in box" four times — you just described the factory in one sentence and Python built it for you.

Connections

For loops — the comprehension is sugar over a for loop.
Conditional expressions (ternary) — a if cond else b used inside expr.
Dictionary and set comprehensions — same idea with {} instead of [].
Generator expressions — (...) lazy version that doesn't build the whole list.
map() and filter() — functional equivalents of transform and filter.
range() and iterables — what feeds the for x in iterable slot.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

List comprehension ek shortcut hai naya list banane ka. Normally tum empty list banate ho, phir for loop chalate ho, if se filter karte ho, aur append karte ho — 4 lines. Comprehension yeh sab ek line me kar deta hai: [expr for x in iterable if condition]. Padho aise: "har x ke liye jo iterable me hai, agar condition sach hai, toh expr daal do".

Sabse important baat: reading order aur execution order alag hai. Likha pehle expr jaata hai, par chalta pehle for hai — Python pehle x uthata hai, phir if se check karta hai, tabhi expr compute karta hai. Yaad rakhne ke liye loop ko mann me wapas khol lo: loop → filter → append.

Do tarah ke if hote hain, yahan log confuse hote hain. Filter if (bina else) for ke baad aata hai — yeh decide karta hai item rakhna hai ya nahi: [x for x in xs if x>0]. Ternary if/else for ke pehle aata hai (kyunki yeh expr ka part hai) — yeh decide karta hai kaunsi value daalni hai: [x if x>0 else 0 for x in xs]. Mnemonic: "Choose-before, Cut-after".

Kab use karein? Jab transform ya filter simple ho, tab comprehension clean aur fast hai (loop C me chalta hai). Lekin agar bahut saare nested if, ya print/side-effects ho, toh normal for loop hi behtar — code padhne layak rehna chahiye.

![[audio/1.2.34-List-comprehensions-—-`[expr-for-x-in-iterable-if-condition]`.mp3]]

List comprehensions — `[expr for x in iterable if condition]`

WHY does this feature exist?

WHAT is the exact anatomy?

HOW to derive it from the loop (do this once, never memorise)

More worked examples

Flashcards

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — Introduction to Programming (Python)

Connections