Learn What Types of Comprehensions Exist in Python: Absolute Beginners Tutorial

Python has four types of comprehensions: list, dictionary, set, and generator. Each one follows the same core pattern but produces a different kind of object. This tutorial covers all four — syntax, behavior, performance characteristics, and when each is the right choice.

What Is a Comprehension?

A comprehension is a way to build a new collection from an existing iterable — a list, a range, a string, a dictionary, or anything else Python can loop over. Instead of writing a for loop that appends values into an empty collection, you express the entire operation inside a pair of brackets or braces.

Every comprehension follows the same template:

# Generic comprehension shape
[expression for item in iterable]
[expression for item in iterable if condition]

The expression produces the output value. The for item in iterable part drives the loop. The optional if condition acts as a filter. The enclosing brackets or braces determine what type of object you get back.

List Comprehensions[ ]

A list comprehension produces a list. You wrap the expression in square brackets [ ]. The result is exactly what you would get from a for loop that builds a list with append() — the difference is that a comprehension expresses the whole operation as one statement rather than three or four.

The for-loop equivalent

# Traditional for loop — builds a list of squares
squares = []
for n in range(6):
    squares.append(n ** 2)

print(squares)  # [0, 1, 4, 9, 16, 25]

Written as a list comprehension

squares = [n ** 2 for n in range(6)]
print(squares)  # [0, 1, 4, 9, 16, 25]

Adding a filter condition

Place an if clause after the for clause to keep only items that match a condition.

# Keep only even numbers
evens = [n for n in range(10) if n % 2 == 0]
print(evens)  # [0, 2, 4, 6, 8]

# Keep words longer than 3 characters
words = ["hi", "hello", "hey", "howdy"]
long_words = [w for w in words if len(w) > 3]
print(long_words)  # ['hello', 'howdy']

"This PEP describes a proposed syntactical extension to Python, list comprehensions." — PEP 202, Python Software Foundation

# Python 3 — loop variable does NOT exist outside the comprehension
squares = [n ** 2 for n in range(6)]
# print(n)  # NameError: name 'n' is not defined

Dictionary Comprehensions{k: v}

A dictionary comprehension produces a dict. You use curly braces { } and write a key: value expression separated by a colon. Dictionary comprehensions were proposed in PEP 274 and became part of Python in versions 2.7 and 3.0.

# Map each word to its length
words = ["apple", "fig", "banana"]
word_lengths = {w: len(w) for w in words}
print(word_lengths)
# {'apple': 5, 'fig': 3, 'banana': 6}

You can filter with if here too. The condition goes after the for clause, exactly like in a list comprehension.

# Invert a dict — swap keys and values
original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
print(inverted)
# {1: 'a', 2: 'b', 3: 'c'}

# Keep only items where the value is greater than 1
filtered = {k: v for k, v in original.items() if v > 1}
print(filtered)
# {'b': 2, 'c': 3}

Set Comprehensions{ }

A set comprehension produces a set. It looks like a dictionary comprehension but contains only one expression — no colon. Because the result is a set, duplicate values are automatically removed and the order is not guaranteed.

# Collect unique first letters from a list of words
words = ["apple", "avocado", "banana", "blueberry", "apricot"]
first_letters = {w[0] for w in words}
print(first_letters)
# {'a', 'b'}  — duplicates removed automatically

# Lowercase all tags, removing duplicates
tags = ["Python", "python", "PYTHON", "code", "Code"]
clean_tags = {t.lower() for t in tags}
print(clean_tags)
# {'python', 'code'}

Generator Expressions( )

A generator expression produces a generator object. It uses parentheses ( ) instead of brackets or braces. Unlike a list comprehension, it does not compute all values upfront. It produces values one at a time, only when the next one is requested. For large sequences this can eliminate the memory cost of storing the entire result set. Generator expressions were introduced in PEP 289, accepted for Python 2.4.

# List comprehension — all values in memory at once
squares_list = [n ** 2 for n in range(1_000_000)]   # ~8 MB (list of pointers) + object overhead

# Generator expression — computes values on demand
squares_gen = (n ** 2 for n in range(1_000_000))     # tiny

# You can iterate a generator just like a list
for val in squares_gen:
    pass  # values are produced one at a time

# Common use: pass a generator directly to a function
total = sum(n ** 2 for n in range(10))
print(total)  # 285

When you pass a generator expression directly to a function that accepts an iterable — like sum(), max(), or any() — the extra pair of parentheses can be dropped. The function call's parentheses serve double duty.

Under the Hood

These are the mechanics that introductory material usually skips. Understanding them will change how you read and write comprehensions.

How CPython actually executes a list comprehension

When CPython compiles a list comprehension, it does not call list.append() in a loop. The compiler generates a dedicated bytecode instruction called LIST_APPEND, which pushes a value directly onto a list object held on the evaluation stack — bypassing the full Python attribute lookup for append. The bytecode path is shorter and involves fewer Python-level operations, which is why list comprehensions measurably outperform manually written append loops on large inputs.

You can inspect this yourself. Run import dis; dis.dis("[x*2 for x in range(5)]") in a Python session and look for the LIST_APPEND instruction in the output. The equivalent for sets is SET_ADD, and for dicts it is MAP_ADD. Generator expressions emit YIELD_VALUE instead, which is how lazy evaluation is wired into the bytecode.

import dis

# Inspect the bytecode of a list comprehension
dis.dis("[x * 2 for x in range(5)]")

# Key instruction to look for in the output:
#   LIST_APPEND  — pushes the expression result directly onto the list
#   (no attribute lookup for .append, no method call overhead)

# For comparison, dis a manual loop:
dis.dis("""
result = []
for x in range(5):
    result.append(x * 2)
""")
# Notice LOAD_ATTR for 'append' and CALL — extra overhead every iteration

The walrus operator inside comprehensions (Python 3.8+)

Python 3.8 introduced the walrus operator :=, also called the assignment expression. You can use it inside a comprehension to compute a value once and use it in both the filter condition and the output expression — without computing it twice.

This matters when the expression inside the comprehension is expensive — a function call, a regex match, a database lookup. Without := you must either compute it twice or restructure the whole thing as a loop.

import math

# Without walrus: math.sqrt() is called twice for each item
results_bad = [math.sqrt(n) for n in range(20) if math.sqrt(n) > 3]

# With walrus: math.sqrt() is called once per item, result reused
results_good = [root for n in range(20) if (root := math.sqrt(n)) > 3]

print(results_good)
# [3.1622..., 3.3166..., 3.4641..., ...] — values > 3, computed only once each

# Note: the walrus target (root) leaks into the enclosing scope — intentionally.
# This is the ONE exception to Python 3's comprehension scoping rule.
print(root)  # accessible here — last value assigned by := inside the comprehension

Building a dict from two lists with zip()

A common dict comprehension pattern is building a mapping from two parallel lists. The built-in zip() function pairs items from two iterables, and a dict comprehension turns those pairs into key-value entries. When you also need to transform the keys or values — not just pair them — the comprehension form is the right tool; dict(zip(...)) cannot do that in one expression.

keys   = ["host", "port", "timeout"]
values = ["localhost", 8080, 30]

config = {k: v for k, v in zip(keys, values)}
print(config)
# {'host': 'localhost', 'port': 8080, 'timeout': 30}

# dict() with zip achieves the same thing and is slightly more concise
config_alt = dict(zip(keys, values))

# The comprehension form wins when you need to transform keys or values on the way in
config_upper = {k.upper(): v for k, v in zip(keys, values)}
# {'HOST': 'localhost', 'PORT': 8080, 'TIMEOUT': 30}

How generator expressions implement the iterator protocol

Every generator expression returns an object that implements Python's iterator protocol: it has both __iter__() and __next__() methods. Calling __next__() runs the generator's bytecode until the next YIELD_VALUE instruction, then suspends execution and returns the value. The generator remembers its position between calls — the local variables, the loop counter, the current frame — all held in a suspended frame object on the heap. This is why generators are memory-efficient: only one value is in play at any time, and the rest of the sequence has not been computed yet.

gen = (x ** 2 for x in range(5))

# A generator IS its own iterator
print(gen is iter(gen))   # True

# Manually step through it with next()
print(next(gen))   # 0
print(next(gen))   # 1
print(next(gen))   # 4

# The for loop calls next() for you until StopIteration is raised
for val in gen:
    print(val)   # 9, then 16 — picks up where next() left off

# Exhausted generators raise StopIteration on the next next() call
# next(gen)  # StopIteration — the generator is spent

Common Questions

The following questions address specific behaviors that come up when writing real comprehensions. Each one has a concrete answer.

Can you use a comprehension with a string?

Yes. A string is an iterable of characters, so any comprehension can loop over one directly. This works anywhere you would otherwise iterate character by character in a loop.

# List comprehension over a string
chars = [c.upper() for c in "hello"]
print(chars)   # ['H', 'E', 'L', 'L', 'O']

# Filter only alphabetic characters from messy input
clean = [c for c in "h3ll0 w0rld!" if c.isalpha()]
print(clean)   # ['h', 'l', 'l', 'w', 'r', 'l', 'd']

# Set comprehension — collect unique characters (order not guaranteed)
unique = {c for c in "mississippi"}
print(unique)  # {'m', 'i', 's', 'p'}

Can the expression call a function?

Yes. The output expression in a comprehension can be any valid Python expression — including a function call. This makes comprehensions useful for applying the same transformation to every item in a collection without writing out a full loop body.

import math

# Call a built-in function as the expression
roots = [math.sqrt(n) for n in range(1, 6)]
print(roots)
# [1.0, 1.414..., 1.732..., 2.0, 2.236...]

# Call a custom function
def grade(score):
    return "pass" if score >= 60 else "fail"

scores = [72, 45, 88, 55, 91]
results = [grade(s) for s in scores]
print(results)
# ['pass', 'fail', 'pass', 'fail', 'pass']

What happens when the iterable is empty?

A comprehension over an empty iterable returns an empty collection of the matching type. The loop simply never executes — no error, no special case.

items = []

print([x * 2 for x in items])      # []
print({x: x ** 2 for x in items})  # {}
print({x for x in items})           # set()

gen = (x for x in items)
print(list(gen))                       # []  — generator is immediately exhausted

What is the difference between an if filter and an if-else expression?

An if placed after the for clause is a filter — it controls which items from the iterable are processed at all. An if-else expression placed inside the output expression is a conditional transform — every item passes through, but its output value branches based on the condition. Position determines meaning.

numbers = [-3, -1, 0, 2, 5]

# if AFTER for — filter: keeps only positive numbers, shorter list
positives = [n for n in numbers if n > 0]
print(positives)  # [2, 5]

# if-else INSIDE expression — transform: same length, every item is mapped
clamped = [n if n > 0 else 0 for n in numbers]
print(clamped)    # [0, 0, 0, 2, 5]

# You can combine both: transform positives, keep all, clamp negatives to zero
# (the if-else is part of the expression; the trailing if is still a filter)
# Example: clamp negatives, then filter out zeros
result = [n if n > 0 else 0 for n in numbers if n >= 0]
print(result)     # [0, 2, 5]  — negatives removed by filter, 0 passed through transform

Can you nest comprehensions?

A nested comprehension uses more than one for clause. The clauses are read left to right, in the same order as the equivalent nested for loops would be written. The most common use is flattening a list of lists into a single list.

# Equivalent nested for loops
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

flat_loop = []
for row in matrix:
    for x in row:
        flat_loop.append(x)

# The same thing as a nested list comprehension
# Read the for clauses left-to-right: outer loop first, inner loop second
flat = [x for row in matrix for x in row]
print(flat)   # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Adding a filter: keep only even values while flattening
evens = [x for row in matrix for x in row if x % 2 == 0]
print(evens)  # [2, 4, 6, 8]

What happens with duplicate keys in a dict comprehension?

When a dict comprehension produces the same key more than once, the last value assigned to that key silently overwrites all earlier ones. No error is raised. This is the same behavior as a regular dict literal with repeated keys, and it can cause silent data loss when the source data contains duplicates.

# Input has repeated names — only the last score per name survives
records = [("alice", 88), ("bob", 74), ("alice", 95)]
scores = {name: score for name, score in records}
print(scores)
# {'alice': 95, 'bob': 74}   — alice's first score (88) is silently lost

# If you need to preserve all values, collect them into a list instead
from collections import defaultdict
all_scores = defaultdict(list)
for name, score in records:
    all_scores[name].append(score)
print(dict(all_scores))
# {'alice': [88, 95], 'bob': [74]}

How to Write Each Type (Step by Step)

All four comprehension types share the same skeleton. The only structural change between them is the outer delimiter — square brackets, curly braces with a colon, curly braces without a colon, or parentheses. The steps below build each type from a common starting point.

Step 1 — Start with a list comprehension

# [expression for item in iterable]
doubled = [x * 2 for x in range(5)]
# [0, 2, 4, 6, 8]

Step 2 — Add an optional filter

# [expression for item in iterable if condition]
doubled_evens = [x * 2 for x in range(10) if x % 2 == 0]
# [0, 4, 8, 12, 16]

Step 3 — Change brackets to curly braces + colon for a dict

# {key_expr: value_expr for item in iterable}
doubled_dict = {x: x * 2 for x in range(5)}
# {0: 0, 1: 2, 2: 4, 3: 6, 4: 8}

Step 4 — Change brackets to curly braces (no colon) for a set

# {expression for item in iterable}
doubled_set = {x * 2 for x in range(5)}
# {0, 2, 4, 6, 8}  — a set (unordered, unique values)

Step 5 — Change brackets to parentheses for a generator

# (expression for item in iterable)
doubled_gen = (x * 2 for x in range(5))
print(list(doubled_gen))
# [0, 2, 4, 6, 8]  — generator consumed into a list for display

Comparison: All Four Types

The diagram and accordion below compare the four types side by side. Use them as a reference when deciding which form to write.

Check Your Understanding