Dictionary Comprehensions

Intermediate ~20 min read

Dictionary comprehensions are the dictionary equivalent of list comprehensions - they let you create and transform dictionaries in a single, elegant line of code. Once you master them, you'll find yourself using them everywhere to write cleaner, more Pythonic code!

Basic Dictionary Comprehension

The syntax is {key_expr: value_expr for item in iterable}. It's like a loop that builds a dictionary one key-value pair at a time.

# Basic Dictionary Comprehensions

# Syntax: {key_expr: value_expr for item in iterable}

# 1. Traditional way (for comparison)
print("=== Traditional Loop ===")
squares_loop = {}
for x in range(6):
    squares_loop[x] = x ** 2
print(f"Using loop: {squares_loop}")

# 2. Dict comprehension - same result, one line!
print("\n=== Dict Comprehension ===")
squares_comp = {x: x ** 2 for x in range(6)}
print(f"Using comprehension: {squares_comp}")

print()

# 3. More examples
print("=== More Examples ===")

# String lengths
words = ["apple", "banana", "cherry"]
lengths = {word: len(word) for word in words}
print(f"Word lengths: {lengths}")

# Index mapping
chars = "hello"
char_index = {char: i for i, char in enumerate(chars)}
print(f"Char indices: {char_index}")

# ASCII values
ascii_map = {char: ord(char) for char in "ABC"}
print(f"ASCII values: {ascii_map}")

print()

# 4. From two lists using zip
print("=== From Two Lists (zip) ===")
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]

name_age = {name: age for name, age in zip(names, ages)}
print(f"Names: {names}")
print(f"Ages: {ages}")
print(f"Zipped: {name_age}")

print()

# 5. From list of tuples
print("=== From List of Tuples ===")
pairs = [("a", 1), ("b", 2), ("c", 3)]
from_pairs = {k: v for k, v in pairs}
print(f"From pairs: {from_pairs}")

Output

Click Run to execute your code

List vs Dict Comprehension: List comprehensions use [] and produce a list. Dict comprehensions use {} with key: value and produce a dictionary. Set comprehensions also use {} but without the colon.

Filtering with Conditions

Add an if clause to filter which items are included in the resulting dictionary. The condition goes at the end of the comprehension.

Pro Tip: Dict comprehensions are perfect for filtering dictionaries. Instead of looping and conditionally adding items, use {k: v for k, v in dict.items() if condition} for clean, readable filtering.

Transforming Keys and Values

Dict comprehensions shine when you need to transform an existing dictionary - modify keys, values, or both. You can even use if-else expressions for conditional transformations.

# Dictionary Comprehensions: Transformations

# Transform existing dictionaries

# 1. Transform values
print("=== Transform Values ===")
prices = {"apple": 1.20, "banana": 0.50, "cherry": 2.00}
print(f"Original prices: {prices}")

# Apply discount (20% off)
discounted = {item: round(price * 0.8, 2) for item, price in prices.items()}
print(f"20% discount: {discounted}")

# Convert to cents
in_cents = {item: int(price * 100) for item, price in prices.items()}
print(f"In cents: {in_cents}")
print()

# 2. Transform keys
print("=== Transform Keys ===")
data = {"name": "Alice", "age": 30, "city": "NYC"}
print(f"Original: {data}")

# Uppercase keys
upper_keys = {k.upper(): v for k, v in data.items()}
print(f"Uppercase keys: {upper_keys}")

# Prefix keys
prefixed = {f"user_{k}": v for k, v in data.items()}
print(f"Prefixed keys: {prefixed}")
print()

# 3. Transform both keys and values
print("=== Transform Both ===")
scores = {"alice": 85, "bob": 90, "charlie": 78}
print(f"Original: {scores}")

# Capitalize names, add grade labels
graded = {name.capitalize(): f"Grade: {score}" for name, score in scores.items()}
print(f"Transformed: {graded}")
print()

# 4. Swap keys and values
print("=== Swap Keys and Values ===")
original = {"a": 1, "b": 2, "c": 3}
swapped = {v: k for k, v in original.items()}
print(f"Original: {original}")
print(f"Swapped: {swapped}")
print()

# 5. Conditional transformation (if-else in expression)
print("=== Conditional Transform ===")
numbers = {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
# Double evens, triple odds
transformed = {k: v*2 if v % 2 == 0 else v*3 for k, v in numbers.items()}
print(f"Original: {numbers}")
print(f"Double evens, triple odds: {transformed}")

Output

Click Run to execute your code

Duplicate Keys Warning: If your key expression produces duplicate keys, later values will overwrite earlier ones silently! For example, {x % 2: x for x in range(5)} results in {0: 4, 1: 3} because keys 0 and 1 get overwritten multiple times.

Practical Use Cases

Dictionary comprehensions are incredibly useful for real-world tasks like creating lookup tables, parsing config strings, inverting dictionaries, and grouping data.

# Practical Dictionary Comprehension Examples

# 1. Create lookup table
print("=== Lookup Table ===")
employees = ["Alice", "Bob", "Charlie", "Diana"]
# Create ID lookup (index as ID)
employee_ids = {name: f"EMP-{i+1:03d}" for i, name in enumerate(employees)}
print(f"Employee IDs: {employee_ids}")
print()

# 2. Invert a dictionary (swap keys/values)
print("=== Invert Dictionary ===")
country_codes = {"US": "United States", "UK": "United Kingdom", "CA": "Canada"}
code_lookup = {name: code for code, name in country_codes.items()}
print(f"Country codes: {country_codes}")
print(f"Code lookup: {code_lookup}")
print()

# 3. Count occurrences
print("=== Count Occurrences ===")
text = "hello world"
char_count = {char: text.count(char) for char in set(text)}
print(f"Text: '{text}'")
print(f"Char counts: {char_count}")
print()

# 4. Group by property
print("=== Group by First Letter ===")
words = ["apple", "banana", "apricot", "blueberry", "cherry", "avocado"]
# First item of each starting letter
first_of_letter = {word[0]: word for word in words}  # Later values overwrite
print(f"First of each letter: {first_of_letter}")
print()

# 5. Parse environment-style strings
print("=== Parse Config String ===")
config_str = "host=localhost;port=8080;debug=true"
config = {pair.split("=")[0]: pair.split("=")[1]
          for pair in config_str.split(";")}
print(f"Config string: {config_str}")
print(f"Parsed config: {config}")
print()

# 6. Create nested structure
print("=== Nested Structure ===")
users = ["alice", "bob", "charlie"]
user_profiles = {
    user: {"username": user, "email": f"{user}@example.com", "active": True}
    for user in users
}
print("User profiles:")
for name, profile in user_profiles.items():
    print(f"  {name}: {profile}")
print()

# 7. Merge and transform
print("=== Merge Two Dicts with Transform ===")
defaults = {"timeout": 30, "retries": 3, "debug": False}
overrides = {"timeout": 60, "debug": True}
# Merge with overrides taking precedence
merged = {**defaults, **overrides}
print(f"Defaults: {defaults}")
print(f"Overrides: {overrides}")
print(f"Merged: {merged}")

Output

Click Run to execute your code

Common Mistakes

1. Forgetting the colon between key and value

# Wrong - missing colon creates a set!
result = {x for x in range(5)}  # Set: {0, 1, 2, 3, 4}

# Correct - use key: value
result = {x: x**2 for x in range(5)}  # Dict: {0:0, 1:1, ...}

2. Not handling duplicate keys

# Unexpected - later values overwrite earlier
words = ["apple", "ant", "bear"]
first_letter = {word[0]: word for word in words}
print(first_letter)  # {'a': 'ant', 'b': 'bear'} - apple lost!

# If you need all values, use a list
from collections import defaultdict
d = defaultdict(list)
for word in words:
    d[word[0]].append(word)
print(dict(d))  # {'a': ['apple', 'ant'], 'b': ['bear']}

3. Overcomplicating with too much logic

# Hard to read - too complex
result = {k: (v*2 if v > 5 else v*3 if v > 2 else v)
          for k, v in data.items() if k not in exclude}

# Better - break into steps or use regular loop
result = {}
for k, v in data.items():
    if k not in exclude:
        if v > 5:
            result[k] = v * 2
        elif v > 2:
            result[k] = v * 3
        else:
            result[k] = v

4. Using unhashable expressions as keys

# Wrong - lists can't be dictionary keys
d = {[i]: i for i in range(3)}  # TypeError!

# Correct - use tuples instead
d = {(i,): i for i in range(3)}  # Works!

Exercise: Word Lengths

Task: Create a dictionary mapping words to their lengths.

Requirements:

Use dictionary comprehension
Key = word, Value = length of word

Output

Click Run to execute your code

Show Solution

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

# Dict comprehension: word -> length
word_lengths = {word: len(word) for word in words}
print(f"Word lengths: {word_lengths}")
# Output: {'apple': 5, 'banana': 6, 'cherry': 6, 'date': 4}

Summary

Basic: {key: value for item in iterable}
Filter: {k: v for k, v in dict.items() if condition}
Transform: {k.upper(): v*2 for k, v in dict.items()}
From lists: {k: v for k, v in zip(keys, values)}
Conditional value: {k: (v if cond else x) for k, v in items}
Watch for: Duplicate keys (later overwrites earlier)
Readability: If too complex, use a regular loop

What's Next?

Now let's learn about Nested Data Structures - how to work with lists of dictionaries, dictionaries of lists, and other complex combinations that you'll encounter constantly in real-world Python programming!

Previous Dictionaries

Next Nested Structures

Basic Dictionary Comprehension

Filtering with Conditions

Transforming Keys and Values

Practical Use Cases

Common Mistakes

1. Forgetting the colon between key and value

2. Not handling duplicate keys

3. Overcomplicating with too much logic

4. Using unhashable expressions as keys

Exercise: Word Lengths

Summary

What's Next?

Enjoying these tutorials?