Session 17 - Comprehensions

Discussion prompt

Before we open Session 17 - Comprehensions: without looking back, what was the main idea of Session 16 - Sets & Set Operations, and what could you do by the end of it that you could not do before?

Hint: One sentence for the idea, one for the skill. If the second one is blank, that is the part to revisit.

Discussion prompt

A list comprehension walks a sequence and collects one new value per item - all inside a pair of square brackets.

That is stated as though it always holds. Do one of two things: produce a case where it fails, or say precisely what rules such a case out. "It just does" is not on the menu.

Hint: Hunt at the extremes first — zero, one, negative, empty, equal. If every extreme survives, the reason they survive is the proof.

Discussion prompt

Explain Read it as expression, then for by analogy to something with no Python Fundamentals in it at all — a queue, a recipe, a map, a bank balance, whatever fits. Then say where your analogy breaks.

Hint: An analogy that never breaks is not an analogy, it is the same idea wearing a hat. Find the seam — that is the part that is actually new.

Put in order

Put the moves of Squares of 0 to 4 into the order they have to happen.

1. The loop walks n over 0,1,2,3,4
2. Each n contributes n * n to the new list
3. Read the output

Why: These are the moves of the worked example in the order it makes them, and each one is set up by the one before it. range(5) yields those five values, one at a time.

Comparison matrix

From Squares of 0 to 4: refill the **n * n** column from what you know. The rest of the table is as it appeared.

Predict first

The table runs: 1 | 2 | [2] · 2 | 4 | [2, 4] · 3 | 6 | [2, 4, 6] · 4 | 8 | [2, 4, 6, 8]

In Double every number, given the rows so far: what is the next one — the row where n is 5?

Correct: 5 | 10 | [2, 4, 6, 8, 10]

Why: The relationship between the columns, not the individual numbers, is what generates the next row. The iterable does not have to be a range - any list works.

Comparison matrix

From Double every number: every row here is a choice with a cost. Fill the **n * 2** column, then say which row you would actually pick and what you give up for it.

Discussion prompt

Explain The expression can be anything to a student a year behind you. No notation, no jargon they have not met — and it still has to be true.

Hint: If your explanation needs a symbol they have never seen, you are describing the notation rather than the idea.

Fill in the blanks

From Length of each word — one line has had its right-hand side removed. Put it back.

words = ["hi", "there", "you"]
lengths = [len(w) for w in words]
print(lengths)

Why: lengths is what everything below it consumes, so the wrong expression here fails later and somewhere else. You can call any function on the item to build each result.

Step through it

Step through Length of each word one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: w is "hi"
2. Step 2: w is "there"
3. Step 3: w is "you"

Draw it

Draw what The first letter of each name just did — the shape of it, not the line-by-line working. One picture, labels only where you need them. Then check it against the steps: anything you could not draw is a step you followed rather than understood.

Annotate

Walk the callouts on The loop version first. Each one is a place this is easy to get subtly wrong.

• squares starts empty; each pass appends n * n.
• Verified by execution: [0, 1, 4, 9, 16] - the same result as the comprehension.

Sort into buckets

Every line below is part of the definition of list comprehension or of filter clause — one or the other, never both. Put each where it belongs.

list comprehension

A compact expression that builds a list; [expression for item in iterable].; It runs the expression once per item and collects the results.

filter clause

The optional if cond at the end of a comprehension.; When it is false the item is skipped entirely - nothing is added for it.

b1

A compact expression that builds a list: [expression for item in iterable]. It runs the expression once per item and collects the results.

b2

The optional if cond at the end of a comprehension. When it is false the item is skipped entirely - nothing is added for it.

Step through it

Step through Keep the even numbers and watch the numbers move. Now imagine the input ten times bigger: which column is the one that stops this being practical?

1. Step 1: n is 4
2. Step 2: n is 7
3. Step 3: n is 10
4. Step 4: n is 3
5. Step 5: n is 8

Sort into buckets

These are the pieces of Session 17 - Comprehensions, out of order. Put each one back under the part of the lesson it belongs to.

Building a List in One Line

A comprehension builds a list from another sequence; Read it as expression, then for; Squares of 0 to 4

From Loop to Comprehension

The accumulate-in-a-loop pattern; The loop version first; Not every loop should convert

Filtering with if

Add if to keep only some items; Keep the even numbers; Only the passing scores

s1

Building a List in One Line is where Session 17 - Comprehensions puts A comprehension builds a list from another sequence, Read it as expression, then for, Squares of 0 to 4. Knowing which part of the lesson a problem belongs to is most of knowing which method to reach for.

s2

From Loop to Comprehension is where Session 17 - Comprehensions puts The accumulate-in-a-loop pattern, The loop version first, Not every loop should convert. Knowing which part of the lesson a problem belongs to is most of knowing which method to reach for.

s3

Filtering with if is where Session 17 - Comprehensions puts Add if to keep only some items, Keep the even numbers, Only the passing scores. Knowing which part of the lesson a problem belongs to is most of knowing which method to reach for.

Step through it

Step through Square only the even numbers one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: n is 1
2. Step 2: n is 2
3. Step 3: n is 3
4. Step 4: n is 4
5. Step 5: n is 6

Fill in the blanks

From A number-to-square lookup — one line has had its right-hand side removed. Put it back.

nums = [1, 2, 3, 4]
squares = **{n: n * n for n in nums}**
print(squares)

Why: squares is what everything below it consumes, so the wrong expression here fails later and somewhere else. The key is n; the value is n * n computed from the same n.

Match the pairs

Match each term to the definition this lesson gave it — not the one you would guess from the word.

• t1. list comprehension
• t2. filter clause
• t3. dict comprehension
• t4. set comprehension

• d1. A compact expression that builds a list: [expression for item in iterable]. It runs the expression once per item and collects the results.
• d2. The optional if cond at the end of a comprehension. When it is false the item is skipped entirely - nothing is added for it.
• d3. Builds a dictionary: {key: value for item in iterable}. The colon separates the key expression from the value expression.
• d4. Builds a set: {expression for item in iterable}. Like a list comprehension but the result keeps only distinct values.

Why: These are the working definitions of list comprehension, filter clause, dict comprehension, set comprehension as Session 17 - Comprehensions uses them. Pairing them correctly is the test of whether you could state each one with the slide switched off.

Comparison matrix

From Distinct squares: refill the set so far column from what you know. The rest of the table is as it appeared.

Sort into buckets

Sort these by len(w), from memory, without looking back at The distinct word lengths. Telling them apart on the spot is the skill; the table is only where the answer happens to be written down.

1

"a"

2

"bb"; "cc"

3

"ddd"

g1

len(w) is "1" for "a" — that is what the table on "The distinct word lengths" records, and it is the single property separating this group from the rest.

g2

len(w) is "2" for "bb", "cc" — that is what the table on "The distinct word lengths" records, and it is the single property separating this group from the rest.

g3

len(w) is "3" for "ddd" — that is what the table on "The distinct word lengths" records, and it is the single property separating this group from the rest.

Predict first

The table runs: [1, 2] | 1 | no | [] · [1, 2] | 2 | yes | [2] · [3, 4] | 4 | yes | [2, 4]

In Flatten and filter at once, given the rows so far: what is the next one — the row where row is [5, 6]?

Correct: [5, 6] | 6 | yes | [2, 4, 6]

Why: The relationship between the columns, not the individual numbers, is what generates the next row. Each n is tested after both loops pick it out.

Step through it

Step through Flatten and filter at once one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: row is [1, 2]
2. Step 2: row is [1, 2]
3. Step 3: row is [3, 4]
4. Step 4: row is [5, 6]

Discussion prompt

Explain Comprehensions are for building collections to a student a year behind you. No notation, no jargon they have not met — and it still has to be true.

Hint: If your explanation needs a symbol they have never seen, you are describing the notation rather than the idea.

Discussion prompt

Explain If you cannot read it, write the loop by analogy to something with no Python Fundamentals in it at all — a queue, a recipe, a map, a bank balance, whatever fits. Then say where your analogy breaks.

Hint: An analogy that never breaks is not an analogy, it is the same idea wearing a hat. Find the seam — that is the part that is actually new.

Fill in the blanks

From The same labels, spelled out as a loop — one line has had its right-hand side removed. Put it back.

prices = [10, 25, 5, 40]
labels = []
for p in prices:
if p >= 20:
labels.append("expensive")
else:
labels.append("cheap")
print(labels)

Why: prices is what everything below it consumes, so the wrong expression here fails later and somewhere else. When the logic might grow, the loop gives it room to breathe.

Draw it

Draw what The same labels, spelled out as a loop just did — the shape of it, not the line-by-line working. One picture, labels only where you need them. Then check it against the steps: anything you could not draw is a step you followed rather than understood.

Predict first

A student writes this, and it looks reasonable:

You expect the loop variable to survive, like it does after a for loop.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: The comprehension has its own private scope, so n is gone the moment it finishes - the last print crashes.

Use the list you built - or a real for loop if you truly need the variable afterward.

Why: The comprehension has its own private scope, so n is gone the moment it finishes - the last print crashes.

Annotate

Walk the callouts on Trap: the comprehension variable does not leak. Each one is a place this is easy to get subtly wrong.

• The comprehension has its own private scope, so n is gone the moment it finishes - the last print crashes.
• Real output: 4. A for-loop variable survives after the loop; a comprehension variable does not. Do not rely on a comprehension to hand you its variable.

Discussion prompt

Because the name stays inside, a comprehension can never accidentally clobber a variable you already have. n outside is safe.

That is stated as though it always holds. Do one of two things: produce a case where it fails, or say precisely what rules such a case out. "It just does" is not on the menu.

Hint: Hunt at the extremes first — zero, one, negative, empty, equal. If every extreme survives, the reason they survive is the proof.

Predict first

A student writes this, and it looks reasonable:

Using a comprehension just to print - throwing the result away.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: It prints ann then bob, but also collects each print's return value.

If you only want the side effect, write a plain for loop.

Why: It prints ann then bob, but also collects each print's return value. result is a useless list of None that wasted memory.

Annotate

In Trap: a comprehension only for side effects, before reading the notes: mark where the time actually goes. Which line dominates?

• It prints ann then bob, but also collects each print's return value. result is a useless list of None that wasted memory.
• Real output: ann then bob, with no leftover list. Rule of thumb: a comprehension is for the value it returns - if you ignore that value, use a loop.

Predict first

A student writes this, and it looks reasonable:

Cramming two loops and a filter into one dense line.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: It works - output [2, 3, 2, 6, 3, 6] - yet a reader has to untangle three clauses on one line to see what it does.

Spell the nesting out as loops when it gets busy.

Why: It works - output [2, 3, 2, 6, 3, 6] - yet a reader has to untangle three clauses on one line to see what it does.

Sort into buckets

Some of these hold up and some are the exact mistakes this lesson is built to prevent. Sort them.

Holds up

A list comprehension walks a sequence and collects one new value per item - all inside a pair of square brackets.; The shape is [expr for x in it]. The for x in it part is the loop; expr is what you keep each time.; The part before for is just an expression evaluated for each item. It can call a function, index a string, do math - whatever produces the value you want to keep.

Breaks

You expect the loop variable to survive, like it does after a for loop.; Using a comprehension just to print - throwing the result away.

sound

These are stated as this lesson states them — each one survives the edge cases Session 17 - Comprehensions puts it through.

flawed

Each of these is lifted from a trap in this deck: reasonable-sounding, and wrong in a way that only shows up once you rely on it.

Discussion prompt

Outside this lesson: where does Session 17 - Comprehensions actually turn up? Name one concrete situation — a job, a piece of software someone ships, a decision somebody has to make — and say which part of Comprehension or loop? is doing the work in it.

Hint: Vague is the failure mode here. "Engineering" is not a situation; "deciding whether this build is fast enough to ship" is.

Check your understanding

What does this print?

• A. ['CAT', 'DOG', 'BIRD'] (correct)
• B. ['cat', 'dog', 'bird']
• C. 'CATDOGBIRD'
• D. [3, 3, 4]

Answer: A

Why: The expression w.upper() runs on each word and the results are collected in order, giving ['CAT', 'DOG', 'BIRD']. Verified by execution.

Why B tempts people

w.upper() changes each word to uppercase; the originals are not kept.

Why C tempts people

A comprehension builds a list, not one joined string - each result is a separate element.

Why D tempts people

That would be [len(w) for w in words]; the expression here is .upper(), not len().

Check your understanding

What does this print?

• A. [4, 5] (correct)
• B. [3, 4]
• C. [2, 3, 4, 5]
• D. [4, 5, 2, 3]

Answer: A

Why: Only 3 and 4 pass n > 2; each then becomes n + 1, giving [4, 5]. The filter drops 1 and 2 entirely. Verified by execution.

Why B tempts people

These are the surviving inputs (3 and 4) before the + 1 expression is applied.

Why C tempts people

The filter n > 2 removes 1 and 2, so not every item is transformed.

Why D tempts people

Filtered-out items are skipped, not added on afterward - the result stays in original order.

Step through it

Step through Check: filter clause and watch the numbers move. Now imagine the input ten times bigger: which column is the one that stops this being practical?

1. Step 1: n is 1
2. Step 2: n is 2
3. Step 3: n is 3
4. Step 4: n is 4

Check your understanding

What does this print?

• A. {1: 10, 2: 20, 3: 30} (correct)
• B. [10, 20, 30]
• C. {10, 20, 30}
• D. {1: 1, 2: 2, 3: 3}

Answer: A

Why: Each x becomes a key with value x * 10, so the dict is {1: 10, 2: 20, 3: 30}. The colon marks a dict comprehension. Verified by execution.

Why B tempts people

Curly braces with a colon build a dict, not a list; and the keys are kept too.

Why C tempts people

That is a set of the values - but the colon here means key: value, so it is a dict.

Why D tempts people

The value expression is x * 10, not x, so the values are 10, 20, 30.

Step through it

Step through Check: dict comprehension one row at a time. One of these columns never changes — find it, and say why it cannot.

1. Step 1: x is 1
2. Step 2: x is 2
3. Step 3: x is 3

Check your understanding

What does this print?

• A. {1, 2, 3} (correct)
• B. {1, 2, 2, 3}
• C. [1, 2, 2, 3]
• D. {'a': 1, 'bb': 2, 'cc': 2, 'ddd': 3}

Answer: A

Why: The lengths are 1, 2, 2, 3, but a set stores each value once, so the duplicate 2 collapses to give {1, 2, 3}. Verified by execution.

Why B tempts people

A set cannot hold the same value twice - the repeated 2 is stored only once.

Why C tempts people

Curly braces with a bare expression build a set, not a list.

Why D tempts people

With no colon this is a set of lengths, not a dict mapping words to lengths.

Sort into buckets

Sort these by len(w), from memory, without looking back at Check: set comprehension. Telling them apart on the spot is the skill; the table is only where the answer happens to be written down.

1

"a"

2

"bb"; "cc"

3

"ddd"

g1

len(w) is "1" for "a" — that is what the table on "Check: set comprehension" records, and it is the single property separating this group from the rest.

g2

len(w) is "2" for "bb", "cc" — that is what the table on "Check: set comprehension" records, and it is the single property separating this group from the rest.

g3

len(w) is "3" for "ddd" — that is what the table on "Check: set comprehension" records, and it is the single property separating this group from the rest.

Check your understanding

What happens on the last line?

• A. NameError: name 'n' is not defined (correct)
• B. It prints 2
• C. It prints 4
• D. It prints [0, 1, 4]

Answer: A

Why: A comprehension has its own private scope, so n does not exist outside it; print(n) raises NameError: name 'n' is not defined. Verified by execution.

Why B tempts people

That would be the last value if n leaked like a for-loop variable - but comprehension variables do not leak.

Why C tempts people

4 is the last square, but n itself is undefined afterward, so nothing prints.

Why D tempts people

The list is stored in squares, not in n; n is out of scope entirely.

Eliminate the wrong options

After 1 and 2 are printed, what is the final line?

3 of these 4 are wrong. Strike them one at a time, and say what rules each one out before you strike the next. The survivor is the answer.

• A. [None, None]
• B. [1, 2]
• C. None
• D. []

Survives elimination: A

Why: print shows each value but returns None, and the comprehension collects those return values, so out is [None, None]. This is why a side-effect-only comprehension should be a loop. Verified by execution.

Check your understanding

After 1 and 2 are printed, what is the final line?

• A. [None, None] (correct)
• B. [1, 2]
• C. None
• D. []

Answer: A

Why: print shows each value but returns None, and the comprehension collects those return values, so out is [None, None]. This is why a side-effect-only comprehension should be a loop. Verified by execution.

Why B tempts people

The comprehension collects what print RETURNS (None), not the values passed to it.

Why C tempts people

out is a list built by the comprehension, not a single None - it has one entry per item.

Why D tempts people

The comprehension runs twice and appends a result each time, so the list is not empty.

Comparison matrix

From Check: side effect result: every row here is a choice with a cost. Fill the print(x) shows column, then say which row you would actually pick and what you give up for it.

Check your understanding

What does this print?

• A. [1, 2, 3, 4, 5, 6] (correct)
• B. [[1, 2, 3], [4, 5, 6]]
• C. [1, 4, 2, 5, 3, 6]
• D. [6, 5, 4, 3, 2, 1]

Answer: A

Why: The outer loop picks each row, the inner loop yields each number, so the rows are flattened in order into [1, 2, 3, 4, 5, 6]. Verified by execution.

Why B tempts people

Flattening removes the inner brackets - the result is one flat list, not a list of lists.

Why C tempts people

The loops are not interleaved column by column; the whole first row comes before the second.

Why D tempts people

Nothing reverses the order - items are collected exactly as the loops visit them.

Comparison matrix

From Check: flatten with nested iteration: refill the n values column from what you know. The rest of the table is as it appeared.

Draw it

One page, no notation unless you need it: draw how these connect — Building a List in One Line · From Loop to Comprehension · Filtering with if · Dict Comprehensions · Set Comprehensions · Nested Iteration. Put an arrow wherever one of them is what makes another possible, and label the arrow with why.