What is the difference between "list comprehension" and "generator expression" in Python?

In Python, both list comprehensions and generator expressions are used to create iterable sequences based on existing sequences or other iterable objects. However, they have some key differences:


  • List Comprehensions: List comprehensions eagerly create and return a new list containing all the generated elements. The entire list is created in memory at once.
  • Generator Expressions: Generator expressions lazily generate and yield elements one at a time as they are requested. They don't create a new list in memory but provide an iterator that generates elements on the fly.

Memory Usage:

  • List Comprehensions: List comprehensions can consume a significant amount of memory when creating large lists, as the entire list is stored in memory.
  • Generator Expressions: Generator expressions are more memory-efficient, as they generate elements on-demand and don't store the entire sequence in memory. They generate elements one at a time, allowing for efficient memory utilization.


  • List Comprehensions: List comprehensions produce a new list that can be iterated over multiple times. Once the list is created, it remains the same, and you can iterate over it multiple times.
  • Generator Expressions: Generator expressions produce an iterator that can be iterated over once. Once the elements are generated and consumed, they are not stored or retained. To iterate over the sequence again, you need to create a new generator expression.

Use Cases:

  • List Comprehensions: List comprehensions are suitable when you need to generate a list of values and plan to use it multiple times or perform operations that require random access to elements.
  • Generator Expressions: Generator expressions are suitable when you need to generate a sequence of values and plan to use it once or perform operations that can be done sequentially without the need for random access to elements.

Here's an example to illustrate the difference between list comprehensions and generator expressions:

# Example with list comprehension
numbers_list = [x for x in range(10)]
print(numbers_list)  # Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Example with generator expression
numbers_generator = (x for x in range(10))
print(numbers_generator)  # Output: <generator object <genexpr> at 0x000001>

# Using list() to convert generator to list
numbers_list_from_generator = list(numbers_generator)
print(numbers_list_from_generator)  # Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In the first example, a list comprehension is used to create a new list numbers_list containing numbers from 0 to 9. The entire list is created in memory and printed as [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].

In the second example, a generator expression is used to create a generator object numbers_generator that will lazily generate numbers from 0 to 9. The generator object itself is printed as <generator object <genexpr> at 0x000001>, indicating that it is an iterator. The elements are not generated or stored yet.

To consume the elements of the generator, we can convert it to a list using list(numbers_generator), as shown in the third example. The generator is iterated over once, generating the numbers on-demand, and the resulting list [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] is printed.

To summarize, list comprehensions eagerly create a new list, while generator expressions lazily generate elements on-demand. List comprehensions consume more memory but allow random access to elements and multiple iterations. Generator expressions are memory-efficient, provide lazy evaluation, and are suitable for one-time use or sequential operations.

Related Questions You Might Be Interested