Python - Generator Expressions

Python provides a shorter and simpler way to create generators called a Generator Expression.

A Generator Expression is a compact way to create a Generator Object using a single expression.

It does not generate and store all values immediately. Instead, each value is generated only when it is requested.

Generator Expressions are similar to List Comprehensions, but they use parentheses () instead of square brackets [].

Like Generator Functions, Generator Expressions generate values one at a time using lazy evaluation.

Part	Description
expression	The operation performed on each element.
item	The variable representing each element of the iterable.
iterable	The sequence or collection being processed.
()	Parentheses are used to create a Generator Expression.

The expression creates a Generator Object.

The values from 1 to 5 are not immediately stored in memory as a complete collection. Instead, they are generated one at a time when requested.

The exact memory address shown in the Generator Object may be different each time the program runs.

A Generator Expression can be directly used with a for loop. The loop retrieves one value at a time and automatically stops when the Generator is exhausted.

1
2
3
4
5

A Generator Expression can include an if condition. The condition determines which elements should be generated.

Generator Expressions can also transform string data.

['RAHUL', 'AMIT', 'NEHA', 'POOJA']

List Comprehension	Generator Expression
Uses square brackets [].	Uses parentheses ().
Creates a List.	Creates a Generator Object.
Generates all values immediately.	Generates values only when requested.
Stores all values in memory.	Produces values one at a time.
Suitable for smaller collections.	Suitable for large sequences.
Values can be accessed repeatedly.	Values are consumed during iteration.
Supports indexing.	Does not support direct indexing.

Consider the following List Comprehension:

[1, 4, 9, 16, 25]

The equivalent Generator Expression uses parentheses instead of square brackets:

at 0x...>
[1, 4, 9, 16, 25]

The main advantage of Generator Expressions is memory efficiency.

A List Comprehension creates all values and stores them in memory immediately. A Generator Expression creates values only when they are requested.

For a small collection, the difference may not be noticeable. However, when processing millions of values, Generator Expressions can significantly reduce memory usage.

The Generator Expression represents one million square values.

However, all one million values are not created and stored at once. Only the requested values are generated.

This is why Generator Expressions are useful for processing large sequences.

The first list(numbers) consumes all values from the Generator.

After that, the Generator Object is exhausted, so the second conversion produces an empty list.

To generate the sequence again, a new Generator Expression must be created.

Generator Expressions work directly with other built-in functions such as max() and min().

25
1

When a Generator Expression is passed as the only argument to a function, an additional pair of parentheses is not required.

The functions consume the generated values and calculate the total, maximum, or minimum.

Generator Function	Generator Expression
Defined using def.	Created using expression syntax.
Uses the yield keyword.	Does not explicitly use yield.
Can contain multiple statements.	Contains a single expression.
Suitable for complex generator logic.	Suitable for simple generator logic.
Returns a Generator Object.	Creates a Generator Object.
Supports lazy evaluation.	Supports lazy evaluation.

• Short and concise syntax.
• Memory efficient.
• Supports lazy evaluation.
• Useful for processing large sequences.
• Works directly with functions such as sum(), min(), and max().
• Does not require defining a separate Generator Function for simple operations.

• Values are consumed only once.
• Does not support direct indexing.
• Not suitable for complex multi-statement logic.
• A new Generator Expression must be created after the previous Generator is exhausted.
• Converting the complete Generator into a list removes its main memory-saving advantage.