Produces an iterator that computes x**2 for each element x in the iterable data on demand.

Express a lazy transformation (squaring) of an iterable, emphasizing memory efficiency.

When you need to apply a simple transformation to an iterable and feed it directly into another function that consumes iterables (e.g., sum, any, all) without materializing an intermediate list.

Used inside function calls that accept iterables (sum, max, min, any, all, list, tuple, set, dict, zip, map, filter, itertools.chain), in comprehensions, or as part of larger generator chains.

(expression for variable in iterable)

(expression for variable in iterable)

expression: any Python expression (e.g., x**2); variable: any valid variable name; iterable: any iterable object (list, tuple, range, generator, file object, etc.).

• sum
• max
• min
• any
• all
• list
• tuple
• set
• dict
• zip
• map
• filter
• itertools.chain

• expression can be any expression (e.g.
• x+1
• x*2
• f(x))
• variable can be any identifier
• iterable can be any iterable (range
• list
• generator
• file object
• etc.).

Forgotten parentheses when the generator expression is the sole argument (e.g., sum[x**2 for x in data] is invalid); confusing with list comprehension syntax [x**2 for x in data]; using the iteration variable after the generator is exhausted; assuming the generator can be reused after exhaustion.

List comprehension [x**2 for x in data] (eager list); map(lambda x: x**2, data); itertools.map(lambda x: x**2, data); using an explicit for loop to build a list.

May confuse generator expression syntax with list comprehension brackets; forgetting that a generator expression used as the sole argument still needs parentheses unless it is the only argument; assuming the generator can be rewound or reused after it has been exhausted.

• generator expressions

Lazy evaluation means values are produced on-demand, saving memory for large iterables; the generator cannot be rewound or reused without recreating it.

Signals intent to compute lazily, often for performance or memory efficiency; conveys familiarity with Pythonic idioms.

Think of a generator expression as a lazy assembly line: each item is built only when the next station asks for it, saving memory by producing values just‑in‑time.

Parentheses are required unless the generator expression is the sole argument to a function call.

Consider using itertools.map or a list comprehension if eager evaluation is needed; replace with a dedicated function for more complex expressions.