Python Dictionary Comprehension

Combining dictionaries

When Spider-Man says "with great power comes great responsibility," he might as well be talking about the .update() method. Use it to meld dictionaries into one:

# Meet the Avengers of dictionaries: two dictionaries become one
first_dict = {'a': 1, 'b': 2}
second_dict = {'c': 3, 'd': 4}
first_dict.update(second_dict)


Resulting in united earth's mightiest heroes, or, er, dictionary: {'a': 1, 'b': 2, 'c': 3, 'd': 4}.

Assigning uniform values

To create a clone army — I mean, uniformly assign the same value to multiple keys — use dictionary comprehension or dict.fromkeys():

# Equality for all, Star Trek's United Federation of Planets would approve this
same_values = {key: 'value' for key in ['a', 'b', 'c']}
# or, for fans of one-liners
same_values = dict.fromkeys(['a', 'b', 'c'], 'value')


In either scenario, you'll get {'a': 'value', 'b': 'value', 'c': 'value'}, a utopian society of key-value pairs. Be careful with dict.fromkeys() and mutable values: all keys share the same mutable instance.

Auto-initializing dictionaries

collections.defaultdict is the Python equivalent of Dumbledore's pensieve — it pulls out memories that may not even exist yet:

# Suddenly, "a" remembers it was to be incremented. Thanks, defaultdict!
from collections import defaultdict
letters = defaultdict(int)
letters['a'] += 1


So the 'a' key starts with a default int, which is 0.

Pairing keys with values

Just as chocolate and peanut butter are a perfect pair, so too are keys and values. Zip them into a delicious dictionary sandwich:

# Keys are to values as chewy centers are to candies
keys = ['a', 'b', 'c']
values = [1, 2, 3]
zipped_dict = dict(zip(keys, values))


This results in a tasty treat of {'a': 1, 'b': 2, 'c': 3}.

Comprehension vs loops: an epic showdown

While comprehension is as stylish as the Matrix's Neo dodging bullets, sometimes the job requires a standard loop's skyscraper jump:

# Sometimes you gotta go slow to go fast
d = {}
for key, value in zip(keys, complex_data_gen()):
    if complex_condition(key, value):
        d[key] = fancy_calc(value)


For times when multiple lines per iteration, complex logic, or side-effects are necessary, loops are your superhero of choice.

Syntax, or the villainous SyntaxError

Avert SyntaxError calamities by getting chummy with syntax nuances. Be fluent in conditional stuff and nested dict comprehensions:

# One interpreter's meat is another coder's poison, avoid SyntaxError by sticking to the right syntax
{f'key_{k}': v if v else 'default' for k, v in iterable}


And for all your inception needs, nested comprehensions:

# It's a dict within a dict within a dict, because why not!
{outer_k: {inner_k: inner_v for inner_k, inner_v in inner_dict.items()}
 for outer_k, inner_dict in outer_matrioshka_dict.items()}


Not just pythonic, but also eco-friendly

In the big data rainforest, the way you hack your way through dict creation can impact your memory footprint:

# Every bit counts when you're on a memory diet
eco_dict = {green_key(key): green_value(value) for key, value in dataset}


Make green_key and green_value as hyper-efficient as possible for a greener memory profile.

An octopus-like embrace of data structures

Dictionary comprehensions can adapt to fit various data structures, converting from lists, sets, or even other dictionaries:

# Comprehension is like Transformers, more than meets the eye
list_of_pairs = [('a', 1), ('b', 2)]
decepticon = {k: v for k, v in list_of_pairs}


Here, decepticon dutifully follows its Autobot conversion rules, resulting in {'a': 1, 'b': 2}.