Session 30 - Iterators & Generators

Discussion prompt

Before we open Session 30 - Iterators & Generators: without looking back, what was the main idea of Session 29 - Lambdas & Functional Tools, 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

for x in nums: looks like one thing, but Python does two: it asks the collection for an iterator, then pulls values from it one at a time.

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 iter() gets an iterator; next() pulls a value 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 iter and next by hand into the order they have to happen.

1. iter(nums) builds an iterator over the list
2. Each next(it) returns one value and advances
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. The iterator starts positioned before the first item.

Comparison matrix

From iter and next by hand: refill the returns column from what you know. The rest of the table is as it appeared.

Discussion prompt

Explain An iterator is a bookmark 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.

Predict first

The table runs: iter("hi") | iterator over 'h','i' · next(it) | h

In Strings are iterable too, given the rows so far: what is the next one — the row where call is next(it)?

Correct: next(it) | i

Why: The relationship between the columns, not the individual numbers, is what generates the next row. Strings hand back their characters one at a time, in order.

Comparison matrix

From Strings are iterable too: every row here is a choice with a cost. Fill the returns column, then say which row you would actually pick and what you give up for it.

Fill in the blanks

From enumerate hands back an iterator — one line has had its right-hand side removed. Put it back.

letters = ["a", "b"]
it = iter(enumerate(letters))
print(next(it))
print(next(it))

Why: it is what everything below it consumes, so the wrong expression here fails later and somewhere else. Each next(it) yields a (index, value) tuple.

Annotate

Walk the callouts on enumerate hands back an iterator. Each one is a place this is easy to get subtly wrong.

• Each next(it) yields a (index, value) tuple.
• Verified by execution: (0, 'a'), then (1, 'b'). The tools you already use are iterators underneath.

Draw it

Draw what An iterator's own iter() is itself 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.

Sort into buckets

Every line below is part of the definition of iterator or of StopIteration — one or the other, never both. Put each where it belongs.

iterator

An object that produces values one at a time and remembers its position.; it has no length and no going back.

StopIteration

The signal an iterator raises to say 'I am empty'.; Calling next() on a used-up iterator raises it.

b1

An object that produces values one at a time and remembers its position. You advance it with next(); it has no length and no going back.

b2

The signal an iterator raises to say 'I am empty'. Calling next() on a used-up iterator raises it.

Fill in the blanks

One next() too many, with the scaffolding fading: two lines are gone now — fill both.

nums = [10, 20]
it = iter(nums)
print(next(it))
print(next(it))
print(next(it))

Why: Reproducing these unaided, rather than reading them, is what tells you the method has transferred. The first two calls give 10 and 20; the third finds nothing left.

Discussion prompt

Rewrite for by hand — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.

Hint: It starts with: Each pass pulls one value

Step through it

Step through Rewrite for by hand one row at a time. What is driving the change, and what would the row after the last one be?

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

Match the pairs

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

• t1. iterator
• t2. StopIteration
• t3. generator

• d1. An object that produces values one at a time and remembers its position. You advance it with next(); it has no length and no going back.
• d2. The signal an iterator raises to say 'I am empty'. Calling next() on a used-up iterator raises it.
• d3. An iterator built from a function that uses yield. Each yield hands back one value and pauses the function until the next value is requested.

Why: These are the working definitions of iterator, StopIteration, generator as Session 30 - Iterators & Generators uses them. Pairing them correctly is the test of whether you could state each one with the slide switched off.

Step through it

Step through A count-up generator 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: i is 1
2. Step 2: i is 2
3. Step 3: i is 3
4. Step 4: i is 4

Fill in the blanks

From The generator object, up close — one line has had its right-hand side removed. Put it back.

def count_up_to(n):
i = 1
while i <= n:
yield i
i += 1

g = count_up_to(3)
print(g)
print(next(g))
print(next(g))

Why: g is what everything below it consumes, so the wrong expression here fails later and somewhere else. Nothing in the body has run yet - g is just a paused iterator.

Discussion prompt

Watch it pause and resume — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.

Hint: It starts with: gen() runs nothing yet

Annotate

In Watch it pause and resume, before reading the notes: mark where the time actually goes. Which line dominates?

• The 'start' line does not print at call time - the body is frozen.
• Prints start, then yields 1 and pauses right there.
• Prints 'resumed once', then yields 2 and pauses. 'resumed twice' never runs - we stopped pulling.

Step through it

Step through A running-total generator 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 10
2. Step 2: n is 20
3. Step 3: n is 30

Step through it

Step through A generator without a loop one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: yield # is 1
2. Step 2: yield # is 2
3. Step 3: yield # is 3

Predict first

A generator expression in action is about to be worked. State your hypothesis first: which rule or definition decides this one, and what is the first move it forces? Then watch whether the example agrees with you.

Correct: The parentheses make a generator, not a list

Why: Printing it shows a generator object, not [1, 4, 9, 16].

A hypothesis you wrote down is falsifiable; a vague sense of how it will go is not. If the example opens somewhere else, that gap is the thing worth chasing.

Put in order

Put the moves of Different types, same values into the order they have to happen.

1. Round brackets give a generator; square give a list
2. A generator expression can feed a function directly
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. The only difference in the source is the bracket, but the types differ.

Comparison matrix

From Filtering in a generator expression: refill the kept? column from what you know. The rest of the table is as it appeared.

Discussion prompt

Measure the memory gap — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.

Hint: It starts with: The list stores a million integers

Fill in the blanks

From An endless count-up, stopped by break — one line has had its right-hand side removed. Put it back.

def count_from(start):
n = start
while True:
yield n
n += 1

g = count_from(10)
for x in g:
if x > 13:
break
print(x)

Why: g is what everything below it consumes, so the wrong expression here fails later and somewhere else. The generator would yield forever - but it only advances when the loop pulls.

Step through it

Step through An endless count-up, stopped by break 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: x is 10
2. Step 2: x is 11
3. Step 3: x is 12
4. Step 4: x is 13
5. Step 5: x is 14

Discussion prompt

Explain Conveyor belt, not warehouse 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 A generator is single-use 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.

Predict first

The table runs: first loop | 0, 1, 4 · second loop | (nothing)

In The second loop is empty, given the rows so far: what is the next one — the row where loop is after?

Correct: after | done

Why: The relationship between the columns, not the individual numbers, is what generates the next row. It pulls 0, 1, 4 and leaves the generator at the end.

Step through it

Step through The second loop is empty one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: loop is first loop
2. Step 2: loop is second loop
3. Step 3: loop is after

Discussion prompt

list() twice tells the same story — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.

Hint: It starts with: The first list() collects everything

Put in order

Put the moves of Summing the same generator twice into the order they have to happen.

1. The first sum() consumes all five values
2. The second sum() adds nothing
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. It pulls 0, 1, 2, 3, 4 and leaves g empty.

Draw it

Draw what Summing the same generator twice 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.

Discussion prompt

To iterate again, either call the generator function again for a fresh one, or build a list once and loop over that list as many times as you like.

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:

Storing the generator, then passing over it twice.

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

Correct: sum works (5), but by then g is exhausted, so max() sees no values and raises ValueError: max() iterable argument is empty.

Build a fresh generator for each pass (or store a list).

Why: sum works (5), but by then g is exhausted, so max() sees no values and raises ValueError: max() iterable argument is empty.

Discussion prompt

The rule this trap just fixed:

Build a fresh generator for each pass (or store a list).

Now break it on purpose. Build a case that violates it and follow the consequences until something visibly fails. Where does the failure first show up — and would you have noticed it if you had not been looking?

Hint: The dangerous rules are the ones whose violation still produces an answer. If yours fails loudly, try to find one that fails quietly.

Predict first

A student writes this, and it looks reasonable:

Pulling more values than the generator has.

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

Correct: After 'a' and 'b' the generator is empty, so next() raises.

Give next() a default, or just use a for loop.

Why: After 'a' and 'b' the generator is empty, so next() raises. CPython prints a traceback ending in StopIteration and the program crashes.

Annotate

Walk the callouts on Trap: calling next() past the end. Each one is a place this is easy to get subtly wrong.

• After 'a' and 'b' the generator is empty, so next() raises. CPython prints a traceback ending in StopIteration and the program crashes.
• The second argument is a fallback for 'empty'. Real output: a, b, done - no crash. A for loop handles the ending for you automatically.

Predict first

A student writes this, and it looks reasonable:

Trying to produce many values with return.

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

Correct: With no yield, this is an ordinary function.

yield each value so the function keeps going.

Why: With no yield, this is an ordinary function. return i stops everything and hands back a single value, so you get 0 - not all the evens.

Sort into buckets

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

Holds up

for x in nums: looks like one thing, but Python does two: it asks the collection for an iterator, then pulls values from it one at a time.; iter(collection) hands back an iterator. next(iterator) returns the next value and moves the position forward one step.; Picture a bookmark sitting in a book. next() reads the current page and nudges the bookmark forward one page.

Breaks

Storing the generator, then passing over it twice.; Pulling more values than the generator has.

sound

These are stated as this lesson states them — each one survives the edge cases Session 30 - Iterators & Generators 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 30 - Iterators & Generators 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 Generator expression or list comprehension? 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. 5 then 6 (correct)
• B. 5 then 5
• C. 6 then 7
• D. [5, 6, 7]

Answer: A

Why: iter() starts before the first item; each next() returns the next value and advances, so you get 5 then 6. Verified by execution.

Why B tempts people

next() advances the position, so the second call cannot return 5 again - it moves on to 6.

Why C tempts people

The first next() returns 5, not 6 - the iterator begins at the first item.

Why D tempts people

next() returns one value at a time, not the whole list.

Check your understanding

What happens on the third next(it)?

• A. It raises StopIteration (correct)
• B. It returns None
• C. It returns 2 again
• D. It restarts and returns 1

Answer: A

Why: After 1 and 2 the iterator is empty, so the third next() raises StopIteration - CPython prints a traceback ending in that line. Verified by execution.

Why B tempts people

next() does not return None when empty; it raises StopIteration (only next(it, default) would return a fallback).

Why C tempts people

An iterator never repeats a value - it only moves forward.

Why D tempts people

Iterators do not reset; there is no going back to the start.

Check your understanding

What does this print?

• A. <class 'generator'> (correct)
• B. <class 'list'>
• C. <class 'tuple'>
• D. [0, 1, 4, 9]

Answer: A

Why: Round brackets around a comprehension make a generator expression, so its type is generator, not list. Verified by execution.

Why B tempts people

Square brackets would make a list; these are round brackets, so it is a generator.

Why C tempts people

Round brackets here are a generator expression, not a tuple - a tuple would need actual values, e.g. (0, 1, 4).

Why D tempts people

type() reports the kind of object, and the generator has not been expanded into a list anyway.

Check your understanding

What does the whole program print?

• A. 3 then end (correct)
• B. 3, again 1, again 2, end
• C. 3 then 3
• D. It raises StopIteration

Answer: A

Why: sum(g) pulls 1 and 2 (total 3) and exhausts g, so the for loop finds nothing and its body never runs; only 'end' follows. Verified by execution.

Why B tempts people

The generator is already drained by sum(g), so the for loop yields nothing - 'again' never prints.

Why C tempts people

sum(g) prints 3 once; the loop adds no output, so 3 is not printed twice.

Why D tempts people

A for loop catches StopIteration silently - looping over an empty generator is safe, not an error.

Comparison matrix

From Check: the second loop: every row here is a choice with a cost. Fill the output column, then say which row you would actually pick and what you give up for it.

Check your understanding

What is the full output, in order?

• A. a, 1, b, 2 (correct)
• B. a, b, c, 1, 2
• C. a, 1, b, 2, c
• D. 1, 2

Answer: A

Why: First next runs 'a' then yields 1; second next resumes, runs 'b' then yields 2. 'c' never runs because we stop pulling after two. Verified by execution.

Why B tempts people

The body does not run all at once - it pauses at each yield, interleaving prints with the yielded values.

Why C tempts people

'c' comes after the second yield; since we only pull twice, that line is never reached.

Why D tempts people

The print lines inside the generator also run, so 'a' and 'b' appear alongside 1 and 2.

Comparison matrix

From Check: pause and resume: refill the prints column from what you know. The rest of the table is as it appeared.

Check your understanding

What does this print?

• A. 0 (correct)
• B. 0 1 2 3 4
• C. a generator object
• D. [0, 1, 2, 3, 4]

Answer: A

Why: There is no yield, so this is a normal function. return i fires on the first pass (i = 0) and ends the function, handing back 0. Verified by execution.

Why B tempts people

return stops the function immediately, so only the first value is ever produced, not all five.

Why C tempts people

Without a yield anywhere, the function is not a generator - it returns a plain value.

Why D tempts people

To collect all values you would need yield plus list(); return gives a single value.

Draw it

One page, no notation unless you need it: draw how these connect — How for Really Works · The StopIteration Signal · Generators with yield · Pause and Resume · Generator Expressions · The Memory Win. Put an arrow wherever one of them is what makes another possible, and label the arrow with why.