What does yield do?
Not return. Pause.

Step by step:

gen = generates()
→ The body does NOT run.
→ Returns a generator object.
→ No 'start' printed yet.

print(next(gen))
→ Runs until the first yield.
→ Prints 'start'.
→ Yields 1.
→ Pauses. Saves state.
→ next() returns 1.

print(next(gen))
→ Resumes from after the first yield.
→ Prints 'middle'.
→ Yields 2.
→ Pauses.
→ next() returns 2.

print(next(gen))
→ Resumes.
→ Prints 'end'.
→ Yields 3.
→ Pauses.
→ next() returns 3.

next(gen) (4th time)
→ Resumes from after the third yield.
→ Function body ends.
→ Raises StopIteration.

Key insight:
Calling generates() does not run the body.
Calling next(gen) does, one step at a time.

This is why generators are called "lazy."
They don't compute anything until you ask.

Compare to return:
returns() runs the whole body.
Only the first return runs.
The rest is unreachable.

A function with any yield becomes a generator
function. Calling it returns a generator,
not the yielded value. Even if the yield is
inside an if branch that never executes.

def f():
if False:
yield 1
return 42

f() # returns , not 42

To get 42, you'd have to iterate the generator
or access its StopIteration.value.

Three cases where generators win:

1. Large datasets
❌ List: builds the whole thing in memory.
✅ Generator: one item at a time.

For 10 million integers:
List: ~400 MB
Generator: a few hundred bytes

The generator is O(1) in memory.
The list is O(n).

2. Lazy evaluation — partial consumption
❌ List: computes every item even if you
only need the first 3.
✅ Generator: computes only what you consume.

for item in gen:
if condition:
break
The rest of the sequence is never computed.

3. Streaming data
❌ List: must load the whole file / stream
before processing.
✅ Generator: process line by line, chunk by
chunk, as data arrives.

Useful for: log files, CSV parsing, network
responses, database cursors.

When NOT to use generators:

❌ You need random access (gen[5])
❌ You need len() (no len on generators)
❌ You need to iterate multiple times
❌ The sequence is small (list is simpler)
❌ You need to slice (gen[1:3] doesn't work)

For small data, a list is clearer.
For large or streaming data, a generator.
Use the right tool for the size.

⚠️ Generators can be iterated only once:
gen = (x for x in range(3))
list(gen) # [0, 1, 2]
list(gen) # [] — exhausted

To iterate again: gen = (x for x in range(3))
(create a new generator) or list(gen) to
cache the values.

The syntax difference:

List: [expr for x in iterable]
Generator: (expr for x in iterable)

Same expression. Brackets vs parentheses.
Completely different behavior:

List: eager, builds all, can reuse
Generator: lazy, one at a time, one-shot

The performance win:

sum([x * x for x in range(10000)])
→ Builds a 10,000-item list
→ Sums it
→ Discards the list

sum(x * x for x in range(10000))
→ Iterates lazily
→ Sums each item as it's produced
→ No list is ever built

For 10,000 items, the difference is small.
For 10 million items, the generator uses
KB and the list uses 100+ MB.

Rule of thumb:
Use a generator expression when passing
directly to sum, any, all, max, min,
or a for loop that breaks.
Use a list when you need the list.

The parentheses rule:

Single argument — parens optional
sum(x for x in nums) # OK
sum((x for x in nums)) # OK, explicit

Multiple arguments — parens required
sum((x for x in nums), 0) # parens needed

No other argument — parens optional
for x in (x for x in nums): # parenthesized
...
for x in x for x in nums: # SyntaxError

Use parentheses when in doubt.
They're never wrong.

⚠️ Generator expressions are one-shot too:
gen = (x for x in range(3))
list(gen) # [0, 1, 2]
list(gen) # []

Same exhausted behavior as generator
functions.