How Do Dictionary Comprehensions Work?

A dictionary comprehension builds a dict from an iterable in a single expression. The syntax is {key: value for item in iterable if condition}.

words = ["apple", "banana", "cherry", "date"]

# Key and value derived from the same item
lengths = {word: len(word) for word in words}
print(lengths)              # {'apple': 5, 'banana': 6, 'cherry': 6, 'date': 4}

# Filter as you go
only_long = {word: len(word) for word in words if len(word) > 5}
print(only_long)            # {'banana': 6, 'cherry': 6}

# Key and value from different places
pairs = [("a", 1), ("b", 2)]
print({key: value for key, value in pairs})    # {'a': 1, 'b': 2}

The long-word filter leaves banana and cherry, since apple is five characters and date is four.

The key expression and the value expression are independent, so you can build a dictionary from pairs, transform the values, or reverse the key and the value. A common pattern is inverting a dictionary: {value: key for key, value in original.items()}.

Two details. Later duplicates win — if the iterable contains the same key twice, the last value is the one that ends up in the dictionary. And the key must be hashable, so building a dict with a list as the key raises a TypeError.

The comparison with the alternatives is worth making. Building the same thing in a loop means writing an empty dict, then a for statement with an assignment inside it — three lines instead of one, and the comprehension is faster because it avoids the repeated dictionary method lookups.

A dictionary comprehension is an expression that creates a dictionary from an iterable. It has the form {key: value for item in iterable}, with an optional if clause at the end to filter items out. It was added in Python 2.7 and works in every supported version of Python 3.

It is the dictionary equivalent of a list comprehension, and it replaces the loop-and-assign pattern. Building a word-length map the long way takes an empty dictionary, a for statement and an assignment on the next line. The comprehension does the same thing in one expression, and it is faster because the loop runs in dedicated bytecode rather than as a Python-level loop with repeated dictionary method lookups.

There are also things the comprehension expresses more clearly. When you need to transform the value, invert a dictionary or drop entries, the expression says exactly what it does: {word: len(word) for word in words if len(word) > 5} reads as a sentence. The loop version buries the same three ideas in the body.

The one place a loop is better is when the body needs statements — a try block, a conditional that spans several lines, or a break. A comprehension is an expression, so it cannot contain statements, and a very long comprehension is harder to read than a loop with a clear body. The rule of thumb is that if the comprehension would need to wrap over several lines, split it up or use a loop.

One behaviour to be aware of: if the same key appears more than once in the iterable, the last value wins, because each assignment overwrites the previous one.