Python Comprehensions and Generator Expressions

Comprehensions are a concise, expressive way to build a new list, dictionary, or set from an existing iterable, in a single readable line instead of a multi-line for loop with an accumulator variable. They are one of the most distinctively "Pythonic" features of the language.

Closely related is the generator expression, which uses similar syntax but produces values lazily, one at a time, instead of building the entire collection in memory at once — an important distinction when working with large or infinite sequences.

Why it matters

A comprehension builds a list, dictionary or set from another collection in a single readable line, and Python programmers use them everywhere in place of a loop with append. You need to read them comfortably to understand other people's code, and writing them well is one of the clearest signs of fluency in the language.

List Comprehensions

A list comprehension has the form [expression for item in iterable if condition], where the "if condition" part is optional. It produces a new list by evaluating the expression once for every item in the iterable that satisfies the condition. This replaces the common pattern of creating an empty list and calling .append() inside a for loop.

Dictionary and Set Comprehensions

The same pattern extends to dictionaries and sets using curly braces. A dictionary comprehension, {key_expr: value_expr for item in iterable}, builds a new dictionary. A set comprehension, {expression for item in iterable}, builds a new set and automatically removes duplicates, just like the set() constructor would.

Generator Expressions

A generator expression looks almost identical to a list comprehension but uses parentheses instead of square brackets: (expression for item in iterable). Rather than building the whole result in memory immediately, it returns a generator object that produces each value on demand as you iterate over it, which makes it far more memory-efficient for large datasets or when you only need to consume the values once.

Examples

numbers = [1, 2, 3, 4, 5, 6]

squares = [n ** 2 for n in numbers]
print(squares)

evens_only = [n for n in numbers if n % 2 == 0]
print(evens_only)

square_map = {n: n ** 2 for n in numbers}
print(square_map)

remainders = {n % 3 for n in numbers}
print(remainders)

[1, 4, 9, 16, 25, 36]
[2, 4, 6]
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}
{0, 1, 2}

numbers = [1, 2, 3, 4, 5]

gen = (n ** 2 for n in numbers)
print(type(gen))
print(sum(gen))          # generator is consumed here
print(sum(gen))          # already exhausted, nothing left

<class 'generator'>
55
0

Exercise

Using comprehensions, print the squares of the even numbers from 1 to 10, then a dictionary mapping each word to its length, then the sum of the squares of 1 to 3 computed with a generator expression.

Expected output: [4, 16, 36, 64, 100], {'hi': 2, 'python': 6}, 14 (one per line)

# TODO: list comprehension: squares of the even numbers from 1 to 10

words = ["hi", "python"]
# TODO: dictionary comprehension: word -> length

# TODO: generator expression inside sum(): squares of 1, 2 and 3

print([n * n for n in range(1, 11) if n % 2 == 0])

words = ["hi", "python"]
print({word: len(word) for word in words})

print(sum(n * n for n in range(1, 4)))

Quick quiz

Interview questions