Python Dictionary Comprehensions: Complete Guide

Dictionary comprehensions provide a concise way to create dictionaries in Python. This guide covers everything from basic syntax to advanced patterns for efficient dictionary creation and transformation.

Basic Dictionary Comprehensions #

Simple Key-Value Creation #

Create dictionaries with comprehension syntax:

🐍 Try it yourself

Output:

Click "Run Code" to see the output

Filtering with Conditions #

Add conditional logic to dictionary comprehensions:

🐍 Try it yourself

Output:

Click "Run Code" to see the output

Advanced Dictionary Comprehensions #

Transforming Existing Dictionaries #

Modify existing dictionaries efficiently:

🐍 Try it yourself

Output:

Click "Run Code" to see the output

Conditional Value Assignment #

Use conditional expressions in comprehensions:

🐍 Try it yourself

Output:

Click "Run Code" to see the output

Real-World Applications #

Data Processing Examples #

Practical dictionary comprehension use cases:

🐍 Try it yourself

Output:

Click "Run Code" to see the output

Configuration and Mapping #

Dictionary comprehensions for configuration management:

🐍 Try it yourself

Output:

Click "Run Code" to see the output

Working with Multiple Data Sources #

Combining Lists into Dictionaries #

Create dictionaries from multiple iterables:

🐍 Try it yourself

Output:

Click "Run Code" to see the output

CSV-like Data Processing #

Process structured data with dictionary comprehensions:

🐍 Try it yourself

Output:

Click "Run Code" to see the output

Performance Considerations #

Efficiency Comparisons #

Compare different dictionary creation methods:

🐍 Try it yourself

import timeit

# Test data
keys = [f"key_{i}" for i in range(1000)]
values = list(range(1000))

# Traditional loop
def create_with_loop():
    result = {}
    for key, value in zip(keys, values):
        result[key] = value ** 2
    return result

# Dictionary comprehension
def create_with_comprehension():
    return {key: value ** 2 for key, value in zip(keys, values)}

# Using dict() constructor
def create_with_dict():
    return dict((key, value ** 2) for key, value in zip(keys, values))

# Performance comparison
time_loop = timeit.timeit(create_with_loop, number=1000)
time_comp = timeit.timeit(create_with_comprehension, number=1000)
time_dict = timeit.timeit(create_with_dict, number=1000)

print(f"Traditional loop: {time_loop:.6f} seconds")
print(f"Dict comprehension: {time_comp:.6f} seconds")
print(f"Dict constructor: {time_dict:.6f} seconds")

# Verify results are equal
r1, r2, r3 = create_with_loop(), create_with_comprehension(), create_with_dict()
print(f"Results equal: {r1 == r2 == r3}")

Output:

Click "Run Code" to see the output

Memory Usage #

Understand memory implications:

🐍 Try it yourself

Output:

Click "Run Code" to see the output

Advanced Patterns #

Nested Dictionary Comprehensions #

Create complex nested structures:

🐍 Try it yourself

# Nested dictionary comprehensions

# Create multiplication table
size = 5
multiplication_table = {
    i: {j: i * j for j in range(1, size + 1)}
    for i in range(1, size + 1)
}

print("Multiplication table:")
for i, row in multiplication_table.items():
    print(f"  {i}: {row}")

# Matrix-like structure
matrix_dict = {
    f"row_{i}": {f"col_{j}": i * j for j in range(3)}
    for i in range(3)
}

print("\nMatrix structure:")
for row_key, row_data in matrix_dict.items():
    print(f"  {row_key}: {row_data}")

# Complex nested filtering
students_data = {
    'Alice': {'math': 85, 'science': 92, 'english': 78},
    'Bob': {'math': 90, 'science': 88, 'english': 85},
    'Charlie': {'math': 75, 'science': 80, 'english': 90}
}

# Filter subjects where student scored > 85
high_scores = {
    student: {
        subject: score 
        for subject, score in subjects.items() 
        if score > 85
    }
    for student, subjects in students_data.items()
}

print("\nHigh scores (>85):")
for student, scores in high_scores.items():
    if scores:  # Only show students with high scores
        print(f"  {student}: {scores}")

Output:

Click "Run Code" to see the output

Set and Dictionary Comprehensions Combined #

Use both comprehension types together:

🐍 Try it yourself

# Combined set and dictionary comprehensions

# Data analysis example
data = [
    ('Alice', 'Math', 85),
    ('Bob', 'Science', 92),
    ('Alice', 'Science', 88),
    ('Charlie', 'Math', 90),
    ('Bob', 'Math', 87),
    ('Charlie', 'Science', 85)
]

# Get unique students and subjects
students = {student for student, _, _ in data}
subjects = {subject for _, subject, _ in data}

print("Students:", students)
print("Subjects:", subjects)

# Create grade matrix
grade_matrix = {
    student: {
        subject: next(
            (score for s, sub, score in data if s == student and sub == subject),
            0  # Default score if not found
        )
        for subject in subjects
    }
    for student in students
}

print("\nGrade matrix:")
for student, grades in grade_matrix.items():
    print(f"  {student}: {grades}")

# Calculate averages
student_averages = {
    student: sum(grades.values()) / len(grades)
    for student, grades in grade_matrix.items()
}

print("\nStudent averages:")
for student, avg in student_averages.items():
    print(f"  {student}: {avg:.1f}")

Output:

Click "Run Code" to see the output

Best Practices #

Readability Guidelines #

Write clear and maintainable dictionary comprehensions:

🐍 Try it yourself

Output:

Click "Run Code" to see the output

When to Use Dictionary Comprehensions #

Guidelines for appropriate usage:

🐍 Try it yourself

# When to use dict comprehensions

# ✅ Good use cases:

# 1. Simple transformations
original = {'a': 1, 'b': 2, 'c': 3}
doubled = {k: v * 2 for k, v in original.items()}
print("✅ Simple transformation:", doubled)

# 2. Filtering with simple conditions
numbers = range(10)
even_squares = {n: n**2 for n in numbers if n % 2 == 0}
print("✅ Simple filtering:", even_squares)

# 3. Converting between data structures
pairs = [('x', 1), ('y', 2), ('z', 3)]
coord_dict = {k: v for k, v in pairs}
print("✅ Structure conversion:", coord_dict)

# ❌ Better to avoid dict comprehensions for:

# 1. Complex logic (use regular loops)
def complex_processing():
    result = {}
    for item in range(10):
        if item % 2 == 0:
            value = item ** 2
            if value > 10:
                result[f"item_{item}"] = {"value": value, "category": "high"}
            else:
                result[f"item_{item}"] = {"value": value, "category": "low"}
    return result

complex_result = complex_processing()
print("❌ Complex logic better as regular function")

# 2. When you need error handling
def safe_conversion(data):
    result = {}
    for key, value in data:
        try:
            result[key] = int(value)
        except ValueError:
            result[key] = 0
    return result

test_data = [('a', '1'), ('b', 'invalid'), ('c', '3')]
safe_result = safe_conversion(test_data)
print("❌ Error handling needs regular loops:", safe_result)

Output:

Click "Run Code" to see the output

Summary #

Dictionary comprehensions are powerful for:

✅ Simple transformations of existing dictionaries
✅ Filtering with straightforward conditions
✅ Converting between data structures
✅ Creating mappings from iterables
✅ One-liner solutions for simple problems

Avoid dictionary comprehensions for:

❌ Complex nested logic
❌ Error handling requirements
❌ Multi-step processing
❌ When readability suffers

Conclusion #

Dictionary comprehensions provide an elegant way to create and transform dictionaries in Python. Use them for simple, readable transformations while falling back to traditional loops for complex logic. Remember that code clarity should always take precedence over brevity.

PyGuide

PyGuide

Python Dictionary Comprehensions: Complete Guide

Basic Dictionary Comprehensions #

Simple Key-Value Creation #

🐍 Try it yourself

Filtering with Conditions #

🐍 Try it yourself

Advanced Dictionary Comprehensions #

Transforming Existing Dictionaries #

🐍 Try it yourself

Conditional Value Assignment #

🐍 Try it yourself

Real-World Applications #

Data Processing Examples #

🐍 Try it yourself

Configuration and Mapping #

🐍 Try it yourself

Working with Multiple Data Sources #

Combining Lists into Dictionaries #

🐍 Try it yourself

CSV-like Data Processing #

🐍 Try it yourself

Performance Considerations #

Efficiency Comparisons #

🐍 Try it yourself

Memory Usage #

🐍 Try it yourself

Advanced Patterns #

Nested Dictionary Comprehensions #

🐍 Try it yourself

Set and Dictionary Comprehensions Combined #

🐍 Try it yourself

Best Practices #

Readability Guidelines #

🐍 Try it yourself

When to Use Dictionary Comprehensions #

🐍 Try it yourself

Summary #

Conclusion #