Q: What yield does

A function containing yield becomes a generator function. Calling it returns a generator object without running any code. Each call to next() on that object resumes execution until the next yield, which hands the yielded value back to the caller. The payoff is lazy evaluation: you can generate a billion values one at a time without ever holding them all in memory.

Q: Iterating an exhausted generator twice

A generator object can only be iterated once. The first list(g) consumes both yields and exhausts the generator. The second list(g) starts iterating an already-exhausted generator, which immediately raises StopIteration, so list() sees an empty sequence and returns []. This is a common trap when you store a generator and try to reuse it.

Q: yield from flattens nested iterables

yield from delegates to another iterable, yielding each of its elements one at a time to the caller. For each sublist, yield from sublist is equivalent to writing 'for item in sublist: yield item'. The result is a fully flattened sequence. Without yield from you would get each inner list as a single yielded value instead of its individual elements.

Q: Why generators are memory-efficient

A generator produces values on demand - it computes the next value only when next() is called and immediately discards the previous one. At any moment it holds only the current value and the function's local variables (the 'local state' that lets it resume where it left off). This is the defining advantage of generators over building a full list: you can process sequences far larger than available RAM.

Q: Calling a generator function does not run its body

Calling a generator function returns a generator object immediately without executing any of the function body. The body only starts running on the first next() call. So 'created' prints first, then next(g) enters the function and prints 'running' before hitting the first yield, which produces 1.

Q: Generator expression

sum(x*x for x in range(1000000)) uses a generator expression - it produces one value at a time and never allocates a million-element list. sum([x*x for x in range(1000000)]) builds the entire list first, then sums it - same result, much higher peak memory. The syntax is nearly identical: swap the brackets for parentheses (or just omit them when the expression is the only argument to a function call).

Q: __iter__ and __next__

Any object that implements both methods is an iterator. Python's for loop calls iter(obj) first to get the iterator, then repeatedly calls next() until StopIteration is raised. An iterable (like a list) implements __iter__ to return a fresh iterator, but the iterator itself also implements __iter__ returning self - that's what lets you use an iterator directly in a for loop. Generators implement both automatically, which is why they work seamlessly in loops.

Question 1

iter() and next() on a list

Accepted Answer

iter() returns an iterator that tracks a position inside the list. Each call to next() advances that position by one and returns the current value. The iterator starts at index 0, so the first next() gives 10 and the second gives 20. The original list is unchanged - only the iterator's cursor moves.

Question 2

What signals exhaustion in the iterator protocol

Accepted Answer

The iterator protocol uses StopIteration as the signal that the sequence is exhausted. A for loop catches this exception automatically and exits cleanly - you never see it as an error in normal iteration. Returning None would be ambiguous because None is a valid value a generator might legitimately yield.

Question 3

Basic generator function output

Accepted Answer

A generator function pauses at each yield and resumes from that point on the next iteration. Here the loop runs while i < 3, yielding i=0, i=1, i=2, then the while condition fails and StopIteration is raised. Because the range is 0 to n-1 (not inclusive of n), the value 3 is never yielded.

Question 4

What yield does

Accepted Answer

A function containing yield becomes a generator function. Calling it returns a generator object without running any code. Each call to next() on that object resumes execution until the next yield, which hands the yielded value back to the caller. The payoff is lazy evaluation: you can generate a billion values one at a time without ever holding them all in memory.

Question 5

Iterating an exhausted generator twice

Accepted Answer

A generator object can only be iterated once. The first list(g) consumes both yields and exhausts the generator. The second list(g) starts iterating an already-exhausted generator, which immediately raises StopIteration, so list() sees an empty sequence and returns []. This is a common trap when you store a generator and try to reuse it.

Question 6

yield from flattens nested iterables

Accepted Answer

yield from delegates to another iterable, yielding each of its elements one at a time to the caller. For each sublist, yield from sublist is equivalent to writing 'for item in sublist: yield item'. The result is a fully flattened sequence. Without yield from you would get each inner list as a single yielded value instead of its individual elements.

Question 7

Why generators are memory-efficient

Accepted Answer

A generator produces values on demand - it computes the next value only when next() is called and immediately discards the previous one. At any moment it holds only the current value and the function's local variables (the 'local state' that lets it resume where it left off). This is the defining advantage of generators over building a full list: you can process sequences far larger than available RAM.

Question 8

Calling a generator function does not run its body

Accepted Answer

Calling a generator function returns a generator object immediately without executing any of the function body. The body only starts running on the first next() call. So 'created' prints first, then next(g) enters the function and prints 'running' before hitting the first yield, which produces 1.

Question 9

Generator expression

Accepted Answer

sum(x*x for x in range(1000000)) uses a generator expression - it produces one value at a time and never allocates a million-element list. sum([x*x for x in range(1000000)]) builds the entire list first, then sums it - same result, much higher peak memory. The syntax is nearly identical: swap the brackets for parentheses (or just omit them when the expression is the only argument to a function call).

Question 10

__iter__ and __next__

Accepted Answer

Any object that implements both methods is an iterator. Python's for loop calls iter(obj) first to get the iterator, then repeatedly calls next() until StopIteration is raised. An iterable (like a list) implements __iter__ to return a fresh iterator, but the iterator itself also implements __iter__ returning self - that's what lets you use an iterator directly in a for loop. Generators implement both automatically, which is why they work seamlessly in loops.

Question 11

Infinite generator with selective next() calls

Accepted Answer

The generator starts at n=5. The first next(gen) yields 5 and increments n to 6. The next two next(gen) calls are not printed - they yield 6 and 7, advancing n to 8. The fourth next(gen) yields 8, which is what gets printed. Each call to next() moves the generator forward regardless of whether the result is used, so unprinted calls still consume values.

Question 12

Mixing next() with a for loop on the same iterator

Accepted Answer

iter() and the for loop share the same iterator object. The manual next(it) call advances the cursor past 'header', consuming it. When the for loop then iterates it, it picks up exactly where next() left off - at 'row1' - and continues to exhaustion. This pattern is the idiomatic way to skip a header row in a file or CSV without loading everything into a list first.

Question 13

Iterables vs iterators - the key distinction

Accepted Answer

The iterator protocol has two roles. An iterable only needs __iter__, which returns a fresh iterator each time - lists, tuples, and strings are iterables. An iterator must also implement __next__ and typically returns itself from __iter__. This is why you can loop over a list multiple times (each loop calls iter() to get a new iterator) but can only loop over a generator once (it is its own iterator and can't be rewound).

Iterators & Generators