Why does a generator expression use less list-like syntax but yield values later?

The punctuation signals a different result. A list comprehension makes a list right away; a generator expression returns an iterator that produces transformed values as they are needed. The Python documentation illustrates this with the same .strip() transformation: (line.strip() for line in line_list) is a generator expression, while [line.strip() for line in line_list] is a list comprehension. [S1]

Here is the same idea with numbers:

numbers = [1, 2, 3]
list_result = [number * 2 for number in numbers]
generator_result = (number * 2 for number in numbers)

print(list_result)              # [2, 4, 6]
print(list(generator_result))    # [2, 4, 6]

The bracketed version has already collected its transformed values in a list. The parenthesized version has not built that list; asking list(...) to consume it is what collects the produced values.

As values are requested from the iterator. Creating generator_result gives you an iterator, not a completed collection of doubled numbers. In the example, list(generator_result) requests the values and collects them. This deferred production is useful when you want to pass values along for consumption instead of immediately assembling a list. The expression still uses the same number * 2 transformation as the list comprehension. [S1]

A simple way to remember the sequence is: define the generator, then consume it. If you only create the expression and never consume the iterator, the expression does not collect the transformed values into a list.

Use a list comprehension when the result you want is a list available immediately:

squared = [number * number for number in numbers]

Use a generator expression when an iterator that supplies values as needed suits the next step:

squared_values = (number * number for number in numbers)

To collect the generator's values, convert it with list(squared_values). That consumes the iterator and creates a list; it does not change the fact that the generator expression itself did not create a list when it was defined. [S1]

Deferred production is not a blanket performance guarantee. The documentation explains the difference in value production and result type; it does not establish that every generator expression is cost-free or that its input iterable is never evaluated at creation. [S1]

Ask what shape of result the next part of your code needs. If it needs a list now, use brackets. If it can consume an iterator and you want values produced as they are requested, use parentheses. For example, change [line.strip() for line in line_list] to (line.strip() for line in line_list) only when an iterator is appropriate for how the result will be used—not just to make the code look shorter. Both forms express the same transformation pattern, but return different kinds of results. [S1]