Generator Expressions and Lazy Evaluation

🎯 Learning Objectives

After this lesson, you will be able to:

Build a generator expression from an existing iterable, with optional filtering.
Use a generator expression with sum(), any(), or all() without creating an intermediate list.
Explain how a generator produces values on demand instead of storing the full results immediately.
Recognize when a generator has been consumed and avoid accidentally reusing it.

Short Explanation

A list comprehension creates a list of results immediately:

Python

adjusted = [score + 5 for score in scores]

A generator expression uses parentheses instead of brackets. It describes values to be produced when an iterator requests them, rather than creating the result list right away:

Python

adjusted = (score + 5 for score in scores)

Use this when an operation can process values one by one—for example sum(), any(), or all(). You can pass the expression directly into a function. For a single generator argument, the outer generator parentheses can often be omitted: sum(x * 2 for x in values).

Unlike a list, a generator is single-pass. After you consume it, iterating over the same generator again yields no values. If you need the values multiple times, use a list comprehension, materialize the generator with list(), or create a new generator for each pass.

any() and all() may stop early: any() stops at the first truthy item, and all() stops at the first falsy item. The rules for empty inputs remain the same as the previous lesson (any is false; all is true). Generator expressions are especially natural for one-pass checks.

Start Practice

Clean Code Examples

1. Sum calculated values without a temporary list

Python

base_prices = [12, 20, 8]
total = sum(price * 2 for price in base_prices)
print(f"Total: {total}")

Output:

TEXT

Total: 80

The multiplication is evaluated as sum() requests each item; no separate doubled-price list is needed.

2. Filter while aggregating

Python

readings = [18, -1, 24, 0]
valid_total = sum(value for value in readings if value >= 0)
print(valid_total)

Output:

TEXT

The if keeps invalid negative readings out of the calculation while preserving a valid zero.

3. Check values without building a boolean list

Python

labels = ["ready", "paused", "ready"]
has_pause = any(label == "paused" for label in labels)
print(f"Paused: {has_pause}")

Output:

TEXT

Paused: True

any() can finish as soon as the generator supplies one match.

4. A generator is exhausted after one pass

Python

values = (part.upper() for part in ["a", "b"])
print(list(values))
print(list(values))

Output:

TEXT

['A', 'B']
[]

The second pass is empty because values was consumed. Use a list if both passes must contain results.

Quick Reference

Need	Preferred approach
Keep results for reuse	`[expression for item in items]`
Process results once	`(expression for item in items)`
Aggregate values	`sum(expression for item in items)`
Check at least one match	`any(predicate for item in items)`
Check every value	`all(predicate for item in items)`
Reuse results later	Materialize with `list(...)`, or recreate the generator

⚠️ Common Mistakes

Do not assume a generator holds a reusable collection like a list.
Do not reuse a consumed generator for a second independent calculation.
Do not treat all() on an empty generator as proof that a batch contained checks.
Do not build an intermediate list only to immediately pass it to sum(), any(), or all() when a generator is clearer.