Python Dictionary Comprehension Explained with Examples | Complete Beginner Guide

In the previous lesson, you learned how to use Python dictionary methods to retrieve, update, and manage dictionary data efficiently. While dictionaries can be created and modified using loops, Python provides a shorter and more elegant way to create dictionaries called dictionary comprehension.

Dictionary comprehension allows you to create dictionaries in a single line of code by combining loops and expressions. It makes programs shorter, easier to read, and often more efficient. Dictionary comprehensions are widely used in data analysis, machine learning, automation, web development, and data transformation.

In this lesson, you will learn what dictionary comprehension is, why it is useful, understand its syntax, compare it with traditional loops, and explore practical real-world examples.

Learning Objectives

After completing this lesson, you will be able to:

• Understand dictionary comprehension.
• Create dictionaries using comprehension syntax.
• Compare dictionary comprehensions with traditional loops.
• Write concise and readable Python code.
• Apply dictionary comprehensions in practical programs.
• Avoid common beginner mistakes.

Understanding Dictionary Comprehension

Dictionary comprehension is a compact way to create dictionaries using a single expression. Instead of writing multiple lines with a for loop, you can generate an entire dictionary in one statement.

It follows the same idea as list comprehension but produces a dictionary consisting of key-value pairs.

Why Use Dictionary Comprehension?

Dictionary comprehensions are useful because they reduce code, improve readability, and simplify data transformation.

Common applications include:

• Creating lookup tables.
• Converting lists into dictionaries.
• Generating student marks.
• Transforming API data.
• Creating configuration dictionaries.
• Processing datasets.

Dictionary Comprehension Syntax

{
    key: value
    for item in iterable
}

The expression before the for keyword defines the key and value that will be stored in the dictionary.

Creating Your First Dictionary Comprehension

squares = {
    number: number ** 2
    for number in range(1, 6)
}

print(squares)

Output

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

Each number becomes the key, while its square becomes the corresponding value.

Creating a Dictionary from a List

students = [
    "Rahul",
    "Priya",
    "Amit"
]

attendance = {
    student: "Present"
    for student in students
}

print(attendance)

Output

{
 'Rahul': 'Present',
 'Priya': 'Present',
 'Amit': 'Present'
}

Creating a Dictionary from Numbers

numbers = {
    value: value * 10
    for value in range(1, 6)
}

print(numbers)

Output

{
 1: 10,
 2: 20,
 3: 30,
 4: 40,
 5: 50
}

Dictionary Comprehension vs Traditional Loop

Using a Traditional Loop

squares = {}

for number in range(1, 6):
    squares[number] = number ** 2

print(squares)

Output

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

Using Dictionary Comprehension

squares = {
    number: number ** 2
    for number in range(1, 6)
}

print(squares)

Output

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

Both programs produce the same result, but dictionary comprehension requires fewer lines of code.

Practical Examples

Example 1: Student Marks

students = [
    "Rahul",
    "Priya",
    "Amit"
]

marks = {
    student: 90
    for student in students
}

print(marks)

Output

{
 'Rahul': 90,
 'Priya': 90,
 'Amit': 90
}

Example 2: Product Prices

products = [
    "Laptop",
    "Mouse",
    "Keyboard"
]

prices = {
    product: 1000
    for product in products
}

print(prices)

Output

{
 'Laptop': 1000,
 'Mouse': 1000,
 'Keyboard': 1000
}

Execution Flow

Consider the following program.

numbers = {
    value: value ** 2
    for value in range(1, 4)
}

print(numbers)

Execution Steps

1. Python starts iterating through the range(1, 4).
2. The first value becomes the dictionary key.
3. The expression value ** 2 becomes the dictionary value.
4. The process repeats for every number.
5. The completed dictionary is returned.

Output

{
 1: 1,
 2: 4,
 3: 9
}

Common Beginner Mistakes

• Using square brackets instead of curly braces.
• Forgetting the colon between the key and value.
• Placing the for loop before the key-value expression.
• Creating duplicate keys unintentionally.
• Using dictionary comprehension for complex logic that is easier to understand with a normal loop.

Chunk Summary

In this section, you learned what Python dictionary comprehension is, why it is useful, its syntax, and how it compares with a traditional for loop. You also explored practical examples, execution flow, and common beginner mistakes. In the next section, you will learn how to use conditional dictionary comprehensions with if and if...else, filter dictionaries, transform keys and values, and apply these techniques in real-world Python programs.

In the previous section, you learned how to create dictionaries using dictionary comprehension. You also compared dictionary comprehensions with traditional for loops and saw how they simplify code. Dictionary comprehensions become even more powerful when combined with conditions, allowing you to filter data and transform keys or values while creating dictionaries.

In this section, you will learn how to use if and if...else statements inside dictionary comprehensions, filter dictionary data, transform keys and values, and apply these techniques to practical real-world examples.

Conditional Dictionary Comprehension

Conditional dictionary comprehensions allow you to include or modify dictionary elements based on specific conditions.

The most common approaches are:

• Using if for filtering.
• Using if...else for assigning different values.

Using if in Dictionary Comprehension

The if condition filters elements before they are added to the dictionary.

Syntax

{
    key: value
    for item in iterable
    if condition
}

Example

even_squares = {
    number: number ** 2
    for number in range(1, 11)
    if number % 2 == 0
}

print(even_squares)

Output

{
 2: 4,
 4: 16,
 6: 36,
 8: 64,
 10: 100
}

Only even numbers satisfy the condition and become part of the dictionary.

Using if...else in Dictionary Comprehension

The if...else expression assigns different values based on a condition.

Syntax

{
    key: value_if_true if condition else value_if_false
    for item in iterable
}

Example

grades = {
    marks: "Pass" if marks >= 40 else "Fail"
    for marks in [25, 40, 55, 32, 90]
}

print(grades)

Output

{
 25: 'Fail',
 40: 'Pass',
 55: 'Pass',
 32: 'Fail',
 90: 'Pass'
}

Filtering Dictionaries

You can create a new dictionary by selecting only the items that satisfy a condition.

Example

students = {
    "Rahul": 92,
    "Priya": 85,
    "Amit": 35,
    "Neha": 78
}

passed_students = {
    name: marks
    for name, marks in students.items()
    if marks >= 40
}

print(passed_students)

Output

{
 'Rahul': 92,
 'Priya': 85,
 'Neha': 78
}

Transforming Dictionary Values

Dictionary comprehensions can modify values while keeping the same keys.

prices = {
    "Laptop": 50000,
    "Mouse": 800,
    "Keyboard": 1500
}

discounted_prices = {
    product: price * 0.9
    for product, price in prices.items()
}

print(discounted_prices)

Output

{
 'Laptop': 45000.0,
 'Mouse': 720.0,
 'Keyboard': 1350.0
}

Transforming Dictionary Keys

You can also transform dictionary keys while preserving the values.

students = {
    "rahul": 92,
    "priya": 85,
    "amit": 90
}

formatted = {
    name.title(): marks
    for name, marks in students.items()
}

print(formatted)

Output

{
 'Rahul': 92,
 'Priya': 85,
 'Amit': 90
}

Practical Examples

Example 1: Tax Calculation

salaries = {
    "Rahul": 50000,
    "Priya": 60000,
    "Amit": 45000
}

tax = {
    name: salary * 0.10
    for name, salary in salaries.items()
}

print(tax)

Output

{
 'Rahul': 5000.0,
 'Priya': 6000.0,
 'Amit': 4500.0
}

Example 2: Attendance Status

attendance = {
    "Rahul": 92,
    "Priya": 68,
    "Amit": 81
}

status = {
    name: "Eligible" if percent >= 75 else "Not Eligible"
    for name, percent in attendance.items()
}

print(status)

Output

{
 'Rahul': 'Eligible',
 'Priya': 'Not Eligible',
 'Amit': 'Eligible'
}

Example 3: Even Numbers

numbers = {
    number: number ** 2
    for number in range(1, 11)
    if number % 2 == 0
}

print(numbers)

Output

{
 2: 4,
 4: 16,
 6: 36,
 8: 64,
 10: 100
}

Execution Flow

Consider the following program.

numbers = {
    value: value ** 2
    for value in range(1, 6)
    if value % 2 == 1
}

print(numbers)

Execution Steps

1. Python starts iterating through range(1, 6).
2. Each value is checked using the if condition.
3. Only odd numbers satisfy the condition.
4. The square of each accepted number becomes the dictionary value.
5. The completed dictionary is returned.

Output

{
 1: 1,
 3: 9,
 5: 25
}

Common Beginner Mistakes

• Placing the if condition before the for loop.
• Confusing filtering if with conditional if...else expressions.
• Using duplicate keys unintentionally.
• Writing complex logic inside a single dictionary comprehension.
• Using dictionary comprehension when a normal loop would be easier to understand.

Chunk Summary

In this section, you learned how to use conditional dictionary comprehensions with if and if...else, filter dictionaries, transform keys and values, and apply these techniques in practical Python programs. You also explored execution flow and common beginner mistakes. In the next section, you will learn nested dictionary comprehensions, create dictionaries using zip() and enumerate(), explore real-world applications, and review best practices and performance tips.

In the previous section, you learned how to create conditional dictionary comprehensions using if and if...else expressions. You also learned how to filter dictionary data and transform keys and values. Dictionary comprehension becomes even more powerful when combined with functions such as zip() and enumerate(), allowing you to create dictionaries from multiple iterables efficiently.

In this section, you will learn advanced dictionary comprehension techniques, including nested dictionary comprehensions, creating dictionaries from lists and strings, using zip() and enumerate(), and exploring real-world applications, best practices, and performance tips.

Advanced Dictionary Comprehension

Dictionary comprehensions can be combined with built-in Python functions to create structured dictionaries from different types of data.

Creating a Dictionary Using zip()

The zip() function combines two or more iterables into pairs. It is commonly used with dictionary comprehension.

Example

students = [
    "Rahul",
    "Priya",
    "Amit"
]

marks = [
    92,
    85,
    90
]

student_marks = {
    student: mark
    for student, mark in zip(students, marks)
}

print(student_marks)

Output

{
 'Rahul': 92,
 'Priya': 85,
 'Amit': 90
}

Creating a Dictionary Using enumerate()

The enumerate() function provides both the index and the value while iterating.

subjects = [
    "Python",
    "SQL",
    "Power BI"
]

subject_ids = {
    index + 1: subject
    for index, subject in enumerate(subjects)
}

print(subject_ids)

Output

{
 1: 'Python',
 2: 'SQL',
 3: 'Power BI'
}

Creating a Dictionary from a String

You can iterate through characters in a string while creating a dictionary.

word = "DATA"

letters = {
    character: ord(character)
    for character in word
}

print(letters)

Output

{
 'D': 68,
 'A': 65,
 'T': 84
}

Duplicate characters automatically overwrite previous keys because dictionary keys must be unique.

Nested Dictionary Comprehension

Dictionary comprehensions can also generate nested dictionaries.

students = {
    student: {
        "Marks": 90,
        "Status": "Pass"
    }
    for student in [
        "Rahul",
        "Priya",
        "Amit"
    ]
}

print(students)

Output

{
 'Rahul': {'Marks': 90, 'Status': 'Pass'},
 'Priya': {'Marks': 90, 'Status': 'Pass'},
 'Amit': {'Marks': 90, 'Status': 'Pass'}
}

Real-World Applications

Example 1: Product Inventory

products = [
    "Laptop",
    "Mouse",
    "Keyboard"
]

inventory = {
    product: 100
    for product in products
}

print(inventory)

Output

{
 'Laptop': 100,
 'Mouse': 100,
 'Keyboard': 100
}

Example 2: Employee IDs

employees = [
    "Neha",
    "Rahul",
    "Priya"
]

employee_ids = {
    index + 101: employee
    for index, employee in enumerate(employees)
}

print(employee_ids)

Output

{
 101: 'Neha',
 102: 'Rahul',
 103: 'Priya'
}

Example 3: Student Grades

students = [
    "Rahul",
    "Priya",
    "Amit"
]

grades = [
    "A",
    "B",
    "A"
]

result = {
    student: grade
    for student, grade in zip(students, grades)
}

print(result)

Output

{
 'Rahul': 'A',
 'Priya': 'B',
 'Amit': 'A'
}

Best Practices

• Use dictionary comprehension for simple transformations.
• Keep expressions short and readable.
• Use descriptive variable names.
• Use zip() when combining multiple iterables.
• Use enumerate() when indexes are required.
• Use a normal for loop when the logic becomes too complex.

Performance Tips

• Dictionary comprehensions are generally faster than manually building dictionaries using loops.
• Avoid unnecessary nested comprehensions.
• Use comprehensions for data transformation instead of repeatedly assigning values inside loops.
• Avoid creating duplicate dictionary keys unintentionally.

Execution Flow

Consider the following program.

numbers = {
    number: number * 10
    for number in range(1, 5)
}

print(numbers)

Execution Steps

1. Python starts iterating through the numbers from 1 to 4.
2. Each number becomes a dictionary key.
3. The expression number * 10 becomes the corresponding value.
4. The key-value pair is inserted into the dictionary.
5. The completed dictionary is returned and displayed.

Output

{
 1: 10,
 2: 20,
 3: 30,
 4: 40
}

Common Beginner Mistakes

• Writing very complex dictionary comprehensions that reduce readability.
• Using duplicate keys without realizing later values overwrite earlier ones.
• Forgetting that zip() stops when the shortest iterable ends.
• Using enumerate() incorrectly when custom indexing is required.
• Using dictionary comprehension where a normal loop would be easier to maintain.

Chunk Summary

In this section, you learned advanced dictionary comprehension techniques, including creating dictionaries using zip() and enumerate(), generating dictionaries from strings, creating nested dictionaries, and applying dictionary comprehensions in real-world scenarios. You also explored best practices, performance tips, execution flow, and common beginner mistakes. In the final section, you will review the complete lesson through a lesson summary, key takeaways, FAQs, coding exercises, interview questions, a mini project, and a preview of the next lesson on Nested Dictionaries: Complete Guide for Beginners.

Lesson Summary

In this lesson, you learned how to create dictionaries using Python dictionary comprehension, a concise and efficient alternative to traditional for loops. Dictionary comprehensions allow you to generate dictionaries in a single expression, making your code shorter, more readable, and easier to maintain.

You began by understanding the syntax of dictionary comprehension and learned how to create dictionaries from ranges and lists. You also compared dictionary comprehensions with traditional loops and discovered when each approach should be used.

Next, you explored conditional dictionary comprehensions using if and if...else expressions. You learned how to filter dictionary data, transform keys and values, and create dictionaries based on specific conditions.

Finally, you learned advanced techniques such as creating dictionaries using zip() and enumerate(), generating dictionaries from strings, creating nested dictionaries, and applying dictionary comprehensions to real-world programming tasks. You also reviewed best practices, performance tips, and common beginner mistakes.

Dictionary comprehensions are widely used in data analysis, machine learning, automation, web development, and data processing because they simplify dictionary creation while improving code readability.

Key Takeaways

• Dictionary comprehension creates dictionaries in a single expression.
• Use curly braces with key: value syntax.
• Dictionary comprehensions reduce the amount of code.
• Use if to filter dictionary items.
• Use if...else to assign conditional values.
• Use zip() to combine multiple iterables.
• Use enumerate() when indexes are required.
• Dictionary comprehensions can create nested dictionaries.
• Keep comprehensions simple and readable.
• Use a traditional loop when the logic becomes too complex.

Frequently Asked Questions (FAQs)

1. What is dictionary comprehension?

Dictionary comprehension is a concise way to create dictionaries using a single expression.

2. What symbols are used in dictionary comprehension?

Curly braces {} with a key: value expression.

3. Can dictionary comprehensions use conditions?

Yes. Both if and if...else expressions are supported.

4. Can dictionary comprehensions replace for loops?

For simple dictionary creation and transformations, yes.

5. What is the purpose of zip()?

It combines multiple iterables so they can be processed together.

6. Why is enumerate() useful?

It provides both the index and the value during iteration.

7. Can dictionary comprehensions create nested dictionaries?

Yes. The value expression can itself be another dictionary.

8. What happens if duplicate keys are created?

The last value assigned to the duplicate key overwrites the previous value.

9. Are dictionary comprehensions faster than traditional loops?

For many simple operations, they are generally faster and more concise.

10. When should dictionary comprehension be avoided?

Avoid it when the logic becomes too complex and reduces code readability.

Coding Exercises

1. Create a dictionary containing numbers and their squares using dictionary comprehension.
2. Create a dictionary from a list of student names.
3. Create a dictionary that stores only even numbers.
4. Use if...else to assign pass or fail grades.
5. Create a dictionary from two lists using zip().
6. Create a dictionary using enumerate().
7. Convert dictionary keys to uppercase using comprehension.
8. Apply a 10% discount to all product prices using dictionary comprehension.
9. Create a nested dictionary using comprehension.
10. Create a dictionary from a string that stores each character and its ASCII value.

Interview Questions

1. What is dictionary comprehension?
2. How does dictionary comprehension differ from a traditional for loop?
3. Explain the syntax of dictionary comprehension.
4. How do you use if in dictionary comprehension?
5. What is the purpose of if...else in dictionary comprehension?
6. How can zip() be used with dictionary comprehension?
7. What is the purpose of enumerate()?
8. What happens when duplicate keys are generated?
9. What are the advantages of dictionary comprehension?
10. Give two real-world applications of dictionary comprehension.

Mini Project: Student Grade Management Using Dictionary Comprehension

Create a Python program that manages student grades using dictionary comprehension.

Your program should:

• Create a dictionary of students and marks using zip().
• Create another dictionary showing pass or fail status using if...else.
• Create a dictionary containing only students who passed.
• Create a dictionary assigning serial numbers using enumerate().
• Create a nested dictionary containing marks and grade status.

Sample Output

========== STUDENT GRADE MANAGEMENT ==========

Student Marks

{'Rahul': 92, 'Priya': 85, 'Amit': 35}

Pass / Fail Status

{'Rahul': 'Pass', 'Priya': 'Pass', 'Amit': 'Fail'}

Passed Students

{'Rahul': 92, 'Priya': 85}

Student IDs

{1: 'Rahul', 2: 'Priya', 3: 'Amit'}

Nested Dictionary

{
 'Rahul': {'Marks': 92, 'Status': 'Pass'},
 'Priya': {'Marks': 85, 'Status': 'Pass'},
 'Amit': {'Marks': 35, 'Status': 'Fail'}
}

=============================================

What’s Next?

Congratulations! You have successfully mastered Python Dictionary Comprehension. You can now create dictionaries efficiently, filter and transform data, combine iterables using zip(), generate indexed dictionaries using enumerate(), and build nested dictionaries using concise Python syntax.

In the next lesson, you will learn Nested Dictionaries: Complete Guide for Beginners. You will explore how to create nested dictionaries, access nested values, update nested data, iterate through multiple levels of dictionaries, and use nested dictionaries in real-world Python applications.