What Are Dictionary Comprehensions in Python?

Dictionary comprehensions in Python provide a concise and readable way to create dictionaries. Similar to list comprehensions, they allow you to generate dictionaries in a single line of code, making your programs more efficient and easier to understand.

A dictionary comprehension consists of:

• An expression pair (key: value)
• A for loop to iterate over an iterable
• An optional if condition for filtering

Basic Syntax:

{key_expression: value_expression for item in iterable}

Why Use Dictionary Comprehensions?

1. Concise and Readable: Reduces multiple lines of loop-based dictionary creation into a single line.
2. Faster Execution: Often more efficient than traditional loops.
3. Flexible: Supports conditions and transformations.

Simple Dictionary Comprehension Examples

Example 1: Creating a Dictionary from a List

numbers = [1, 2, 3, 4, 5]
squared_dict = {num: num**2 for num in numbers}
print(squared_dict)

Output:

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Example 2: Mapping Names to Their Lengths

names = ["Alice", "Bob", "Charlie"]
name_lengths = {name: len(name) for name in names}
print(name_lengths)

Output:

{'Alice': 5, 'Bob': 3, 'Charlie': 7}

Adding Conditions in Dictionary Comprehensions

You can include if conditions to filter items.

Example 3: Filtering Even Numbers Only

numbers = [1, 2, 3, 4, 5, 6]
even_squares = {num: num**2 for num in numbers if num % 2 == 0}
print(even_squares)

Output:

{2: 4, 4: 16, 6: 36}

Example 4: Using if-else Conditions

numbers = [1, 2, 3, 4, 5]
odd_even = {num: ("Even" if num % 2 == 0 else "Odd") for num in numbers}
print(odd_even)

Output:

{1: 'Odd', 2: 'Even', 3: 'Odd', 4: 'Even', 5: 'Odd'}

Nested Dictionary Comprehensions

You can also use nested loops inside dictionary comprehensions.

Example 5: Creating a Multiplication Table

multiplication_table = {
    i: {j: i * j for j in range(1, 6)} for i in range(1, 6)
}
print(multiplication_table)

Output:

{
    1: {1: 1, 2: 2, 3: 3, 4: 4, 5: 5},
    2: {1: 2, 2: 4, 3: 6, 4: 8, 5: 10},
    3: {1: 3, 2: 6, 3: 9, 4: 12, 5: 15},
    4: {1: 4, 2: 8, 3: 12, 4: 16, 5: 20},
    5: {1: 5, 2: 10, 3: 15, 4: 20, 5: 25}
}

Dictionary Comprehensions vs. For Loops

Traditional For Loop Approach:

numbers = [1, 2, 3, 4, 5]
squared_dict = {}
for num in numbers:
    squared_dict[num] = num**2
print(squared_dict)

Dictionary Comprehension Approach:

squared_dict = {num: num**2 for num in numbers}

Advantages of Dictionary Comprehension:
✔ Fewer lines of code
✔ More readable
✔ Faster execution

Practical Use Cases of Dictionary Comprehensions

1. Converting Two Lists into a Dictionary

keys = ['a', 'b', 'c']
values = [1, 2, 3]
dict_from_lists = {k: v for k, v in zip(keys, values)}
print(dict_from_lists)

Output:

{'a': 1, 'b': 2, 'c': 3}

2. Modifying Keys and Values

original_dict = {'a': 1, 'b': 2, 'c': 3}
modified_dict = {k.upper(): v*2 for k, v in original_dict.items()}
print(modified_dict)

Output:

{'A': 2, 'B': 4, 'C': 6}

3. Filtering Dictionary Items

student_scores = {'Alice': 85, 'Bob': 60, 'Charlie': 72, 'David': 90}
passed_students = {name: score for name, score in student_scores.items() if score >= 70}
print(passed_students)

Output:

{'Alice': 85, 'Charlie': 72, 'David': 90}

Common Mistakes to Avoid

1. Forgetting the key:value Pair:
   ❌ {num for num in range(5)} → This creates a set, not a dictionary.
   ✅ {num: num*2 for num in range(5)}

2. Using Mutable Keys:

   • Dictionary keys must be immutable (e.g., strings, numbers, tuples).
     ❌ {[1,2]: "list"} → Error (lists are mutable).

3. Overcomplicating Logic:

   • If the logic is too complex, a traditional loop may be more readable.

Conclusion

Dictionary comprehensions are a powerful feature in Python that help you create dictionaries efficiently. They improve code readability, reduce execution time, and make dictionary manipulation easier. By mastering dictionary comprehensions, you can write cleaner and more Pythonic code.

Key Takeaways:

✔ Use {key: value for item in iterable} for basic dictionary creation.
✔ Add if conditions to filter items.
✔ Use nested comprehensions for complex dictionaries.
✔ Prefer dictionary comprehensions over loops for simplicity.