Welcome to the start of the How to Python series. In this series, I’m putting together several articles for small Python problems that can be solved in a few lines of code. This series is inspired by the everyday Google searches I make to solve my own problems at work. To get started, I’ve decided to kick off the series by writing an article on how to invert a dictionary.
In short, one of the best ways to invert a dictionary in Python is to use a for loop in conjunction with the setdefault method of dictionaries to store duplicate keys in a list. If that’s not an issue for you, a dictionary comprehension works great: {v: k for k, v in my_dict.items()}. As always, we’ll take a look at other solutions as well.
Table of Contents
Video Summary
In order to supplement my articles, I’ve been slowly but surely launching accompanying videos. As a matter of fact, this is just my second YouTube video, so show it some love!
In it, I share all of the same solutions to the dictionary inversion problem that you’ll find in this article. Of course, the advantage of a video is that you can see it all live with a bit of my own commentary. If you want to jump to a specific part of the video, I have the timestamps setup in the description.
Problem Introduction
Recently, I was working on a Python project where I needed to invert a dictionary. For all you Boku no Hero Academia
(BNHA) fans out there, I basically wanted to be able to do the following:
my_dict = {
'Izuku Midoriya': 'One for All',
'Katsuki Bakugo': 'Explosion',
'All Might': 'One for All',
'Ochaco Uraraka': 'Zero Gravity'
}
my_inverted_dict = {
'One for All': ['Izuku Midoriya', 'All Might'],
'Explosion': ['Katsuki Bakugo'],
'Ochaco Uraraka': ['Zero Gravity']
}
In this scenario, we have a dictionary of characters from BNHA mapped to their quirks, and we want to convert that to a dictionary of quirks mapped to the characters that have them.
Unfortunately, the original dictionary has non-unique values, so flipping the dictionary would result in a loss of keys. Instead, we want to accumulate a list of keys for each non-unique value while performing the inversion. As it turns out, this is pretty easy to do.
Note: If you’re looking to perform a reverse dictionary lookup (i.e. get a key given a value), I have a whole other article for that. Otherwise, let’s move on!
Solutions
If we want to invert a dictionary, we have several options. From comprehensions to loops, we’ll take a look at all the practical solutions.
Invert a Dictionary with Map and Reversed
Let’s kick off our series of options with one of the more succinct options:
my_inverted_dict = dict(map(reversed, my_dict.items()))
Here, we use the map function which applies the reversed function to all the items in the dictionary. Then, we take the map object and convert it into a dictionary. The result looks something like the following:
my_inverted_dictionary = {
'One for All': 'All Might',
'Explosion': 'Katsuki Bakugo',
'Zero Gravity': 'Ochaco Uraraka'
}
Of course, if we want to make sure we don’t lose Midoriya, we shouldn’t use this method. Otherwise, this would be a perfect solution.
Invert a Dictionary with Zip
According to Capi Etheriel, there’s yet another way to reverse a dictionary with unique values. Specifically, they mentioned zipping the keys and values in their reverse order and converting the output to a dictionary:
dict(zip(my_dict.values(), my_dict.keys()))
When I first saw this solution, I was a bit skeptical that it would actually work. After all, until Python 3.7, dictionaries had no ordering. In other words, I felt like it wasn’t clear that values() and keys() would return lists that actually lined up. That’s why we typically use a method like items() to ensure we get the keys and values together as pairs.
Well, I kept digging. Apparently, keys() and values() always correspond assuming no changes to the dictionary between calls—at least according to a few folks on Stack Overflow. Of course, be aware that we’ll lose Midoriya with this solution as well:
{
'One for All': 'All Might',
'Explosion': 'Katsuki Bakugo',
'Zero Gravity': 'Ochaco Uraraka'
}
In other words, if you have unique values, this might be the option for you.
Invert a Dictionary with a Comprehension
In Python 2.7 and above, we can use a dictionary comprehension to invert a dictionary. Unfortunately, it falls prey to the same issue mentioned before, but it gets the job done for unique values:
my_inverted_dict = {value: key for key, value in my_dict.items()}
Once again, here’s the result of inverting our example dictionary:
my_inverted_dictionary = {
'One for All': 'All Might',
'Explosion': 'Katsuki Bakugo',
'Zero Gravity': 'Ochaco Uraraka'
}
As we can see, we lose one of our keys. Perhaps there is a better way to invert a dictionary.
Invert a Dictionary with Defaultdict
Luckily, there is another way! Thanks to our friend, Niels van Galen Last, we can accomplish exactly what we need in three lines of code:
from collections import defaultdict
my_inverted_dict = defaultdict(list)
{my_inverted_dict[v].append(k) for k, v in my_dict.items()}
Here, we’ve chosen to leverage the defaultdict object from collections. It allows us to set default values for keys. In this case, we’ve chosen a default value of list, so we can append data without the risk of a runtime error. Check out the results:
my_inverted_dict = {
'One for All': ['Izuku Midoriya', 'All Might'],
'Explosion': ['Katsuki Bakugo'],
'Zero Gravity': ['Ochaco Uraraka']
}
Since defaultdict works like a regular dict, we can interact with it all the same. This is a great solution if you don’t have any strict dict requirements, and your values are not unique.
All of that said, this solution is considered bad practice (also, I’d love a source better than Stack Overflow). After all, we are not using the dictionary comprehension as intended. It’s meant to generate a dictionary, but we’re using it to modify an external dictionary.
Invert a Dictionary with a For Loop
Another way to invert a dictionary is to use a for loop. This allows us to iterate over the set of mappings and properly build the new mappings by hand. Take a look:
my_inverted_dict = dict()
for key, value in my_dict.items():
my_inverted_dict.setdefault(value, list()).append(key)
With this method, we can invert a dictionary while preserving all of our original keys. Let’s take a look at what would happen if we ran this code snippet:
my_inverted_dict = {
'One for All': ['Izuku Midoriya', 'All Might'],
'Explosion': ['Katsuki Bakugo'],
'Zero Gravity': ['Ochaco Uraraka']
}
Great! We have exactly what we need, but what happens if we want to return this dictionary to its original form?
Revert the Inversion
In the basic case where all keys and values are unique, we can revert a dictionary back to its original mapping using the same dictionary comprehension we’ve already covered:
my_dict = {value: key for key, value in my_inverted_dict.items()}
Unfortunately, this doesn’t work out with a dictionary that maps keys to lists. That’s because lists in Python are unhashable types. In other words, Python doesn’t allow lists to be keys in dictionaries because lists are not immutable.
Fortunately, it’s easier to revert our dictionary than it was to invert it in the first place. We can use the following dictionary comprehension:
my_dict = {value: key for key in my_inverted_dict for value in my_inverted_dict[key]}
As we can see, we make a new key-value pair for every single value in each list using this double loop structure.
Performance
Recently, I thought it would be fun to start adding performance information to these articles. In particular, I’m interested in comparing these solutions by their run time. To do that, we’ll use the timeit library. Before we can run our metrics, we’ll need to setup our solutions in strings:
setup = """
from collections import defaultdict
my_dict = {
'Izuku Midoriya': 'One for All',
'Katsuki Bakugo': 'Explosion',
'All Might': 'One for All',
'Ochaco Uraraka': 'Zero Gravity'
}
"""
map_and_reversed = """
dict(map(reversed, my_dict.items()))
"""
keys_vals = """
dict(zip(my_dict.values(), my_dict.keys()))
"""
dict_comprehension = """
{value: key for key, value in my_dict.items()}
"""
default_dict = """
my_inverted_dict = defaultdict(list)
{my_inverted_dict[v].append(k) for k, v in my_dict.items()}
"""
brute_force = """
my_inverted_dict = dict()
for key, value in my_dict.items():
my_inverted_dict.setdefault(value, list()).append(key)
"""
With our strings in hand, we can run our test:
>>> import timeit >>> min(timeit.repeat(stmt=map_and_reversed, setup=setup)) 1.523790699999978 >>> min(timeit.repeat(stmt=keys_vals, setup=setup)) 0.745502799999997 >>> min(timeit.repeat(stmt=dict_comprehension, setup=setup)) 0.5250495999999885 >>> min(timeit.repeat(stmt=default_dict, setup=setup)) 1.5607491000000664 >>> min(timeit.repeat(stmt=brute_force, setup=setup)) 1.3153148999999758
As it turns out, the dictionary comprehension is very fast. However, be aware that it can’t handle non-unique values. If that’s not a constraint, then go with the fast solution. Otherwise, it doesn’t really matter which method you choose.
Also, for reference, I ran this on my Windows 10 desktop with Python 3.7.3. If you’re interested in learning more about this performance testing process, I have an article for that.
A Little Recap
Using the methods above, we can invert just about any dictionary.
# Use to invert dictionaries that have unique values
my_inverted_dict = dict(map(reversed, my_dict.items()))
# Use to invert dictionaries that have unique values
my_inverted_dict = dict(zip(my_dict.values(), my_dict.keys()))
# Use to invert dictionaries that have unique values
my_inverted_dict = {value: key for key, value in my_dict.items()}
# Use to invert dictionaries that have non-unique values
from collections import defaultdict
my_inverted_dict = defaultdict(list)
{my_inverted_dict[v].append(k) for k, v in my_dict.items()}
# Use to invert dictionaries that have non-unique values
my_inverted_dict = dict()
for key, value in my_dict.items():
my_inverted_dict.setdefault(value, list()).append(key)
# Use to invert dictionaries that have lists of values
my_dict = {value: key for key in my_inverted_dict for value in my_inverted_dict[key]}
Just about every other type of dictionary transformation is out of the scope of this tutorial. However, if you have any specific questions, feel free to reach out in the comments.
While you’re here, you might be interested in these articles as well:
- How to Write a List Comprehension in Python
- How to Convert Two Lists into a Dictionary in Python
- Rock, Paper, Scissors Using Modular Arithmetic
If you’re not sure where to start, I recommend my list of Python Code Snippets for Everyday Problems. Alternatively, you can get the latest articles sent to your inbox by becoming a member or subscribing to the newsletter.
While you’re here, check out some of these related BNHA products on Amazon (ad).
Thanks again for sticking around!
Recent Code Posts
In the world of programming languages, expressions are an interesting concept that folks tend to implicitly understand but might not be able to define. As a result, I figured I'd take a crack at...
It might seem like a straightforward concept, but variables are more interesting than you think. In an effort to expand our concept map, we're here to cover one of the most basic programming...