Python Dictionary Comprehension: A Comprehensive Exploration

What Is Dictionary Comprehension in Python?

Definition

Dictionary comprehension in Python is a syntactic construct that creates a dictionary by applying expressions to define key-value pairs from an iterable (e.g., list, tuple, range, or another dictionary). It combines the functionality of loops and optional conditions into a compact form, making it an efficient alternative to traditional dictionary construction methods.

Why Use Dictionary Comprehension?

Compared to traditional for loops with dictionary assignments, dictionary comprehension:

• Reduces code length and complexity.
• Enhances readability for straightforward transformations.
• Executes faster due to Python’s optimized internals.

Example of traditional loop vs. dictionary comprehension:

Copy code# Traditional loop 
squares = {} 
for i in range(5): 
    squares[i] = i ** 2
print(squares) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16} 

# Dictionary comprehension 
squares = {i: i ** 2 for i in range(5)}
print(squares) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Syntax of Dictionary Comprehension

Basic Syntax

The basic structure of a dictionary comprehension is:

text

CollapseWrapCopy

{key_expression: value_expression for item in iterable}

• key_expression: Defines the key for each dictionary entry.
• value_expression: Defines the value associated with the key.
• item: Variable representing each element in the iterable.
• iterable: The source sequence (e.g., list, range, string).

Example:

Copy codenumbers = {x: x * 2 for x in range(4)}
print(numbers) # {0: 0, 1: 2, 2: 4, 3: 6}

Conditional Syntax

To filter items, add an if clause:

text

CollapseWrapCopy

{key_expression: value_expression for item in iterable if condition}

• condition: A test that must be True for the key-value pair to be included.

Example:

Copy codeevens = {x: x ** 2 for x in range(6) if x % 2 == 0}
print(evens) # {0: 0, 2: 4, 4: 16}

Conditional Expression Syntax

For conditional transformations of values, use an inline if/else:

text

CollapseWrapCopy

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

Example:

Copy codeparity = {x: "even" if x % 2 == 0 else "odd" for x in range(5)}
print(parity) # {0: 'even', 1: 'odd', 2: 'even', 3: 'odd', 4: 'even'}

Basic Dictionary Comprehension Examples

Creating Key-Value Pairs

Generate a dictionary of numbers and their squares:

Copy codesquares = {n: n ** 2 for n in range(5)}
print(squares) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

From a List

Map names to their lengths:

Copy codenames = ["Alice", "Bob", "Charlie"] 
lengths = {name: len(name) for name in names}
print(lengths) # {'Alice': 5, 'Bob': 3, 'Charlie': 7}

From a String

Count character frequencies:

Copy codetext = "hello" 
freq = {char: text.count(char) for char in text}
print(freq) # {'h': 1, 'e': 1, 'l': 2, 'o': 1}

Dictionary Comprehension with Conditions

Filtering Elements

Include only even keys:

Copy codeeven_doubled = {x: x * 2 for x in range(10) if x % 2 == 0}
print(even_doubled) # {0: 0, 2: 4, 4: 8, 6: 12, 8: 16}

Multiple Conditions

Filter based on multiple criteria:

Copy codefiltered = {x: x ** 2 for x in range(10) if x % 2 == 0 and x > 4}
print(filtered) # {6: 36, 8: 64}

Conditional Transformation

Assign different values based on a condition:

Copy codesigns = {x: "positive" if x > 0 else "zero or negative" for x in [-2, 0, 1, 2]}
print(signs) # {-2: 'zero or negative', 0: 'zero or negative', 1: 'positive', 2: 'positive'}

Nested Dictionary Comprehension

Definition

Nested dictionary comprehension involves multiple for clauses or works with nested data structures, allowing complex dictionary creation.

From Nested Lists

Create a dictionary from a list of pairs:

Copy codepairs = [["a", 1], ["b", 2], ["c", 3]] 
d = {k: v for k, v in pairs}
print(d) # {'a': 1, 'b': 2, 'c': 3}

Combining Two Iterables

Use zip() to pair keys and values:

Copy codekeys = ["x", "y", "z"] 
values = [10, 20, 30] 
coords = {k: v for k, v in zip(keys, values)}
print(coords) # {'x': 10, 'y': 20, 'z': 30}

Nested Dictionary Creation

Generate a dictionary of dictionaries:

Copy codematrix = [[1, 2], [3, 4]] 
nested = {i: {j: val for j, val in enumerate(row)} for i, row in enumerate(matrix)}
print(nested) # {0: {0: 1, 1: 2}, 1: {0: 3, 1: 4} }

Advanced Dictionary Comprehension Techniques

Using Functions

Apply functions to keys or values:

Copy codewords = ["python", "code", "fun"] 
lengths = {w.upper(): len(w) for w in words}
print(lengths) # {'PYTHON': 6, 'CODE': 4, 'FUN': 3}

Custom function:

Copy codedef cube(x): \
    return x ** 3 
cubes = {x: cube(x) for x in range(4)}
print(cubes) # {0: 0, 1: 1, 2: 8, 3: 27}

Inverting a Dictionary

Swap keys and values (assuming unique values):

Copy coded = {"a": 1, "b": 2, "c": 3} 
inverted = {v: k for k, v in d.items()}
print(inverted) # {1: 'a', 2: 'b', 3: 'c'}

From Another Dictionary

Transform keys or values:

Copy codeprices = {"apple": 1.5, "banana": 0.5} 
doubled = {k: v * 2 for k, v in prices.items()}
print(doubled) # {'apple': 3.0, 'banana': 1.0}

Handling Duplicates

When keys repeat, the last value wins:

Copy codedata = [("a", 1), ("b", 2), ("a", 3)] 
d = {k: v for k, v in data}
print(d) # {'a': 3, 'b': 2} (later 'a': 3 overwrites 'a': 1)

Practical Applications of Dictionary Comprehension

Data Mapping

Map student names to grades:

Copy codestudents = ["Alice", "Bob", "Charlie"] 
grades = [85, 90, 78] 
report = {name: grade for name, grade in zip(students, grades)}
print(report) # {'Alice': 85, 'Bob': 90, 'Charlie': 78}

Data Transformation

Convert temperatures from Celsius to Fahrenheit:

Copy codecelsius = {"Mon": 20, "Tue": 25, "Wed": 15} 
fahrenheit = {day: (temp * 9/5) + 32 for day, temp in celsius.items()}
print(fahrenheit) # {'Mon': 68.0, 'Tue': 77.0, 'Wed': 59.0}

Filtering Data

Extract high scores:

Copy codescores = {"Alice": 85, "Bob": 92, "Charlie": 78} 
high_scores = {name: score for name, score in scores.items() if score >= 80}
print(high_scores) # {'Alice': 85, 'Bob': 92}

Counting Occurrences

Count characters in a string:

Copy codetext = "programming" 
char_count = {char: text.count(char) for char in set(text)}
print(char_count) # {'p': 1, 'r': 2, 'o': 1, 'g': 2, 'a': 1, 'm': 2, 'i': 1, 'n': 1}

Creating Lookup Tables

Generate a multiplication table:

Copy codetable = {f"{i}x{j}": i * j for i in range(1, 4) for j in range(1, 4)}
print(table) # {'1x1': 1, '1x2': 2, '1x3': 3, '2x1': 2, '2x2': 4, '2x3': 6, '3x1': 3, '3x2': 6, '3x3': 9}

Conclusion

Python dictionary comprehension is a versatile and efficient tool for creating and transforming dictionaries. With its ability to handle basic mappings, conditional logic, nested structures, and advanced transformations, it offers a concise alternative to traditional loops. This blog has provided an exhaustive exploration of dictionary comprehension—its syntax, conditional and nested forms, and practical examples—demonstrating its utility across various scenarios.

Incorporate dictionary comprehension into your Python projects to streamline data manipulation, and experiment with these examples to harness its full potential!