Mastering Dictionary Comprehensions in Python

In our previous article, we covered Python lists and list comprehensions, key tools for managing and transforming data efficiently.

In this guide, we’ll cover another important topic in python. We will discuss the basics of Python dictionaries. We will introduce Dictionary comprehensions. And also we will show examples of how they can make data processing and daily programming faster and simpler.

Dictionary in Python

In Python, dictionaries are versatile and powerful data structures used to store key-value pairs. Unlike lists, where elements are accessed by their index(position), dictionary values are accessed using unique keys. These keys can be strings, numbers, or other immutable data types. This makes dictionaries highly suitable for tasks requiring fast lookup and associations between related pieces of data.

# Single Level Dictionary
{'name': 'Jon Doe', 'age': 26}

# Nested Dictionary
{
1: {
'name': 'Jon Doe',
'age': 26 
},
2: {
'name': 'Jane Doe',
'age': 24 
}
}

What is a Dictionary Comprehension

A dictionary comprehension generates a new dictionary from the input with minimal code. It processes each item in an iterable to generate key-value pairs based on specific conditions or transformations. This enables developers to write concise and readable code for handling dictionary data. It provides an efficient and clean approach, especially when working with complex mappings or large datasets. By reducing the need for lengthy and boring loops, dictionary comprehensions enhance performance and improve code clarity. They also promote a functional programming style, making the code more maintainable and easier to understand.

The basic syntax of dictionary comprehension is:

Examples of Dictionary Comprehensions

Example 1: Squaring Numbers

Let’s examine the traditional approach. It creates a dictionary with each number as a key. The square of each number is the corresponding value.

squares = {}
for x in range(1, 6):
    squares[x] = x**2
print(squares) # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Here’s how you can achieve the same result using dictionary comprehension.

squares = {x: x**2 for x in range(1, 6)}
print(squares) # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Example 2: Filtering Even Numbers and Squaring them

Let’s make it more interesting! In the example above, let’s only include the squares of even numbers. Traditionally, we would use:

numbers = {}
for x in range(1, 11):
    numbers[x] = x ** 2

even_values = {}
for k, v in numbers.items():
    if v % 2 == 0:
        even_values[k] = v
print(even_values) # Output: {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

Here’s how you can achieve the same result using dictionary comprehension:

numbers = {x: x**2 for x in range(1, 11)}
even_values = {k: v for k, v in numbers.items() if v % 2 == 0}
print(even_values) # Output: {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

See the magic!, it only took less then half the line of code to achieve the same result.

Example 3: Invert key and value of dictionary

Let’s see how this is achieved using for loop.

original = {'one': 1, 'two': 2, 'three': 3, 'four': 4}
inverted = {}
for k, v in original.items():
    inverted[v] = k
print(inverted)  # Output: {1: 'one', 2: 'two', 3: 'three', 4: 'four'}

• If you only want the name of the students:

original = {'one': 1, 'two': 2, 'three': 3, 'four': 4}
inverted = {v: k for k, v in original.items()}
print(inverted)  # Output: {1: 'one', 2: 'two', 3: 'three', 4: 'four'}

Example 4: Flattening a Nested Dictionary

For flattening a nested dictionary:

nested_dict = {
    'item1': {'a': 1, 'b': 2},
    'item2': {'a': 1},
    'item3': {'a': 7, 'b': 2}
}

# Flatten the nested dictionary using dictionary comprehension
flattened_dict = {f"{key}.{sub_key}": sub_value 
                  for key, sub_dict in nested_dict.items() 
                  for sub_key, sub_value in sub_dict.items()}

print(flattened_dict)
#output
{
    'item1.a': 1,
    'item1.b': 2,
    'item2.a': 1,
    'item3.a': 7,
    'item3.b': 2
}

Example 5: Character Occurrence

For creating an array of characters:

text = "Hello World"
char_count = {char.lower(): text.lower().count(char.lower()) for char in set(text)}
# Output: {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}

Example 6: Dictionary Initialization

To initialize a dictionary value with a particular value:

keys = ['jon', 'jane', 'alice']
my_dict = {key: 0 for key in keys}
print(my_dict) # Output: {'jon': 0, 'jane': 0, 'alice': 0}

Example 7: Adding index to a list

items = ['x', 'y', 'z']
indexed = {i: items[i] for i in range(len(items))}
# Output: {0: 'x', 1: 'y', 2: 'z'}

Example 8: Find word occurrence

Find word occurrence in a sentence

sentence = "Python programming is fun and versatile. It allows for powerful data manipulation and quick development of projects."
word_count = {word: sentence.split().count(word) for word in set(sentence.split())}
print(word_count)
# Output
{'Python': 1, 'programming': 1, 'is': 1, 'fun': 1, 'and': 2, 'versatile.': 1,
 'It': 1, 'allows': 1, 'for': 1, 'powerful': 1, 'data': 1, 'manipulation': 1,
 'quick': 1, 'development': 1, 'of': 1, 'projects.': 1}

Example 9: Vowels or Consonants

Find vowels in the sentence using dictionary comprehension:

chars = "HelloWorld"
# Using dictionary comprehension to check if each character is a vowel or consonant
vowel_check = {char: ('vowel' if char.lower() in 'aeiou' else 'consonant') for char in chars}
print(vowel_check)
# Output
{'H': 'consonant', 'e': 'vowel', 'l': 'consonant', 'o': 'vowel',
 'W': 'consonant', 'r': 'consonant', 'd': 'consonant'}

Example 10: Fahrenheit to Celsius Temperature Conversion

Converting Fahrenheit to Celsius:

temps_celsius = [0, 25, 37, 50, 100]
temps_fahrenheit = {temp: temp * 9/5 + 32 for temp in temps_celsius}
print(temps_fahrenheit) # Output: {0: 32.0, 25: 77.0, 37: 98.6, 50: 122.0, 100: 212.0}

Conclusion

Dictionary comprehensions are a powerful feature in Python that makes your code cleaner and easier to read. They let you perform complex tasks on lists and dictionary and other data structure in one line, cutting down on long loops and temporary variables. Whether you’re changing data, filtering items, or flattening nested dictionary, dictionary comprehensions provide a more efficient option.

By using dictionary comprehensions, you can make your data tasks quicker and your code easier to read. However, it’s important to find a balance. Dictionary comprehensions work well for simple tasks, but traditional loops may be better for more complex operations to keep things clear.