1097

Given a dictionary like so:

my_map = {'a': 1, 'b': 2}

How can one invert this map to get:

inv_map = {1: 'a', 2: 'b'}
Improve this question
0

35 Answers 35

Reset to default
1
2
1532

Python 3+:

inv_map = {v: k for k, v in my_map.items()}

Python 2:

inv_map = {v: k for k, v in my_map.iteritems()}
Improve this answer
Sign up to request clarification or add additional context in comments.

9 Comments

In recent Python 2.7.x versions my_map.items() works as well
@valentin Yes, that works, but it's less efficient because it generates a list of pairs, rather than an iterator.
This'll work except that it won't work if there is not unicity in the values. In that case you'll loose some entries
I think that's unavoidable when you "transpose" a dict.
This is a pretty popular question with two pages of different answers. So I decided to profile different approaches. This answer presents one of the most voracious ways. You can see the results here
@VasinYuriy The snippet behind your link does not measure the exact method in this answer.
|
238

Assuming that the values in the dict are unique:

Python 3:

dict((v, k) for k, v in my_map.items())

Python 2:

dict((v, k) for k, v in my_map.iteritems())
Improve this answer

5 Comments

The values have to be hashable too
@Buttons840: If the values aren’t unique, there is no unique inversion of the dictionary anyway or, with other words, inverting does not make sense.
@Buttons840 Only the last key will appear for the value. There are probably no guarantees on the order that iteritems() will output, so it may be assumed that an arbitrary key will be assigned for a non-unique value, in a way that will be apparently reproducible under some conditions, but no so in general.
Note, of course, that in Python 3 there is no longer an iteritems() method and this approach will not work; use items() there instead as shown in the accepted answer. Also, a dictionary comprehension would make this prettier than calling dict.
@Wrzlprmft There is a natural definition for inverse in the case of non unique values. Every value is mapped to the set of keys leading to it.
215

If the values in my_map aren't unique:

Python 3:

inv_map = {} for k, v in my_map.items(): inv_map[v] = inv_map.get(v, []) + [k]

Python 2:

inv_map = {} for k, v in my_map.iteritems(): inv_map[v] = inv_map.get(v, []) + [k]
Improve this answer

9 Comments

... or just inv_map.setdefault(v, []).append(k). I used to be a defaultdict fanboy, but then I got screwed one too many times and concluded that actually explicit is better than implicit.
@YaroslavBulatov no, the code as shown here isn't broken - inv_map.get(v, []) returns the already-added list if there is one, so the assignment doesn't reset to an empty list. setdefault would still be prettier, though.
A set would make more sense here. The keys are (probably) hashable, and there is no order. inv_map.setdefault(v, set()).add(k).
In python3, use my_map.items() instead of my_map.iteritems().
You can avoid setdefault by using a defaultdict: inv_map = collections.defaultdict(set) and then simply inv_map[v].add(k)
|
56

To do this while preserving the type of your mapping (assuming that it is a dict or a dict subclass):

def inverse_mapping(f): return f.__class__(map(reversed, f.items()))
Improve this answer

5 Comments

Clever it may be, but it doesn't work when more than one key has the same value in the original dictionary.
@Rafael_Espericueta That's true of any possible answer to this question, since a map with values repeated is not invertible.
@Mark_Amery It can be invertible more generally, in a sense. For example: D = {1: [1, 2], 2:[2, 3], 3: [1]}, Dinv = {1: [1, 3], 2: [1, 2], 3: [2]}. D is a dictionary of for example {parent: children}, while Dinv is the dictionary {child: parents}.
I don't think it is necessary to do the f.__class__ because you already made the assumption that it is a dictionary. I would do it like this: dict(map(reversed, f.items()))
@bkbilly no assumption was made we have a dict - only we have an items method
52

Try this:

inv_map = dict(zip(my_map.values(), my_map.keys()))

(Note that the Python docs on dictionary views explicitly guarantee that .keys() and .values() have their elements in the same order, which allows the approach above to work.)

Alternatively:

inv_map = dict((my_map[k], k) for k in my_map)

or using python 3.0's dict comprehensions

inv_map = {my_map[k] : k for k in my_map}

Notice that this only works if the keys are unique

Improve this answer

2 Comments

Notice that this only works if the keys are unique (which is almost never the case if you want to invert them).
According to python.org/dev/peps/pep-0274 dict comprehensions are available in 2.7+, too.
45

Another, more functional, way:

my_map = { 'a': 1, 'b':2 } dict(map(reversed, my_map.items()))
Improve this answer

3 Comments

Thanks for posting. I am not sure this is preferable - to quote Guido Van Rossum in PEP 279: "filter and map should die and be subsumed into list comprehensions, not grow more variants".
Yeah, that's a fair point Brian. I was just adding it as a point of conversation. The dict comprehension way is more readable for most I'd imagine. (And likely faster too I'd guess)
Might be less readable than others, but this way does have the benefit of being able to swap out dict with other mapping types such as collections.OrderedDict or collections.defaultdict
21

We can also reverse a dictionary with duplicate keys using defaultdict:

from collections import Counter, defaultdict def invert_dict(d): d_inv = defaultdict(list) for k, v in d.items(): d_inv[v].append(k) return d_inv text = 'aaa bbb ccc ddd aaa bbb ccc aaa' c = Counter(text.split()) # Counter({'aaa': 3, 'bbb': 2, 'ccc': 2, 'ddd': 1}) dict(invert_dict(c)) # {1: ['ddd'], 2: ['bbb', 'ccc'], 3: ['aaa']}

See here:

This technique is simpler and faster than an equivalent technique using dict.setdefault().

Improve this answer

1 Comment

It can be good to return dict(d_inv), since a dictionary has broader support than a less standard defaultdict. For example, some serializers (such as yaml.safe_dump) won't serialize a defaultdict while they will serialize a dict.
18

This expands upon the answer by Robert, applying to when the values in the dict aren't unique.

class ReversibleDict(dict): # Ref: https://stackoverflow.com/a/13057382/ def reversed(self): """ Return a reversed dict, with common values in the original dict grouped into a list in the returned dict. Example: >>> d = ReversibleDict({'a': 3, 'c': 2, 'b': 2, 'e': 3, 'd': 1, 'f': 2}) >>> d.reversed() {1: ['d'], 2: ['c', 'b', 'f'], 3: ['a', 'e']} """ revdict = {} for k, v in self.items(): revdict.setdefault(v, []).append(k) return revdict

The implementation is limited in that you cannot use reversed twice and get the original back. It is not symmetric as such. It is tested with Python 2.6. Here is a use case of how I am using to print the resultant dict.

If you'd rather use a set than a list, and there could exist unordered applications for which this makes sense, instead of setdefault(v, []).append(k), use setdefault(v, set()).add(k).

Improve this answer

2 Comments

this would also be a good place to use sets instead of lists, i.e. revdict.setdefault(v, set()).add(k)
Of course, but that's exacty why it's a good reason to use set. It's the intrinsic type that applies here. What if I want to find all keys where the values are not 1 or 2? Then I can just do d.keys() - inv_d[1] - inv_d[2] (in Python 3)
13

For instance, you have the following dictionary:

my_dict = {'a': 'fire', 'b': 'ice', 'c': 'fire', 'd': 'water'}

And you wanna get it in such an inverted form:

inverted_dict = {'fire': ['a', 'c'], 'ice': ['b'], 'water': ['d']}

First Solution. For inverting key-value pairs in your dictionary use a for-loop approach:

# Use this code to invert dictionaries that have non-unique values inverted_dict = dict() for key, value in my_dict.items(): inverted_dict.setdefault(value, list()).append(key)

Second Solution. Use a dictionary comprehension approach for inversion:

# Use this code to invert dictionaries that have unique values inverted_dict = {value: key for key, value in my_dict.items()}

Third Solution. Use reverting the inversion approach (relies on the second solution):

# Use this code to invert dictionaries that have lists of values my_dict = {value: key for key in inverted_dict for value in my_map[key]}
Improve this answer

3 Comments

dict is reserved and shouldn't be used for variable names
forgot to tell us what my_map is
dictio()? Did you mean dict()?
12

A case where the dictionary values is a set. Like:

some_dict = {"1":{"a","b","c"}, "2":{"d","e","f"}, "3":{"g","h","i"}}

The inverse would like:

some_dict = {vi: k for k, v in some_dict.items() for vi in v}

The output is like this:

{'c': '1', 'b': '1', 'a': '1', 'f': '2', 'd': '2', 'e': '2', 'g': '3', 'h': '3', 'i': '3'}
Improve this answer

1 Comment

It also works if the dictionary values are a list. Thanks.
12

Lot of answers but didn't find anything clean in case we are talking about a dictionary with non-unique values.

A solution would be:

from collections import defaultdict inv_map = defaultdict(list) for k, v in my_map.items(): inv_map[v].append(k)

Example:

If initial dict my_map = {'c': 1, 'd': 5, 'a': 5, 'b': 10}

then, running the code above will give:

{5: ['a', 'd'], 1: ['c'], 10: ['b']}
Improve this answer

Comments

11

Combination of list and dictionary comprehension. Can handle duplicate keys

{v:[i for i in d.keys() if d[i] == v ] for k,v in d.items()}
Improve this answer

1 Comment

Like stackoverflow.com/a/41861007/1709587, this is an O(n²) solution to a problem that is easily solved in O(n) with a couple of extra lines of code.
3

I found that this version is more than 10% faster than the accepted version of a dictionary with 10000 keys.

d = {i: str(i) for i in range(10000)} new_d = dict(zip(d.values(), d.keys()))
Improve this answer

Comments

2

In addition to the other functions suggested above, if you like lambdas:

invert = lambda mydict: {v:k for k, v in mydict.items()}

Or, you could do it this way too:

invert = lambda mydict: dict( zip(mydict.values(), mydict.keys()) )
Improve this answer

1 Comment

-1; all you've done is taken other answers from the page and put them into a lambda. Also, assigning a lambda to a variable is a PEP 8 violation.
2

I think the best way to do this is to define a class. Here is an implementation of a "symmetric dictionary":

class SymDict: def __init__(self): self.aToB = {} self.bToA = {} def assocAB(self, a, b): # Stores and returns a tuple (a,b) of overwritten bindings currB = None if a in self.aToB: currB = self.bToA[a] currA = None if b in self.bToA: currA = self.aToB[b] self.aToB[a] = b self.bToA[b] = a return (currA, currB) def lookupA(self, a): if a in self.aToB: return self.aToB[a] return None def lookupB(self, b): if b in self.bToA: return self.bToA[b] return None

Deletion and iteration methods are easy enough to implement if they're needed.

This implementation is way more efficient than inverting an entire dictionary (which seems to be the most popular solution on this page). Not to mention, you can add or remove values from your SymDict as much as you want, and your inverse-dictionary will always stay valid -- this isn't true if you simply reverse the entire dictionary once.

Improve this answer

4 Comments

I like this idea, though it would be good to note that it trades off additional memory to achieve improved computation. A happier medium may be caching or lazily computing the mirror. It is also worth noting that it could be made more syntactically appealing with e.g. dictionary views and custom operators.
@BrianM.Hunt It trades off memory, but not a lot. You only store two sets of pointers to each object. If your objects are much bigger than single integers, this won't make much of a difference. If you have huge table of tiny objects on the other hand, you might need to consider those suggestions...
And I agree, there's more to be done here -- I might flesh this out into a fully functioning datatype later
"This implementation is way more efficient than inverting an entire dictionary" - um, why? I don't see any plausible way this approach can have a significant performance benefit; you've still got two dictionaries this way. If anything, I'd expect this to be slower than, say, inverting the dict with a comprehension, because if you invert the dict Python can plausibly know in advance how many buckets to allocate in the underlying C data structure and create the inverse map without ever calling dictresize, but this approach denies Python that possibility.
2

If the values aren't unique, and you're a little hardcore:

inv_map = dict( (v, [k for (k, xx) in filter(lambda (key, value): value == v, my_map.items())]) for v in set(my_map.values()) )

Especially for a large dict, note that this solution is far less efficient than the answer Python reverse / invert a mapping because it loops over items() multiple times.

Improve this answer

1 Comment

This is just plain unreadable and a good example of how to not write maintainable code. I won't -1 because it still answers the question, just my opinion.
2

This handles non-unique values and retains much of the look of the unique case. 

inv_map = {v:[k for k in my_map if my_map[k] == v] for v in my_map.itervalues()}

For Python 3.x, replace itervalues with values.

Improve this answer

2 Comments

This solution is quite elegant as a one liner and it manages the non unique values case. However it has a complexity in O(n2) which means it should be ok for several dozens of elements but it would be too slow for practical use if you have several hundreds of thousands of elements in your initial dictionary. The solutions based on a default dict are way faster than this one.
Gabuzo is quite right. This version is (arguably) clearer than some, but it is not suitable for large data.
2

I am aware that this question already has many good answers, but I wanted to share this very neat solution that also takes care of duplicate values:

def dict_reverser(d): seen = set() return {v: k for k, v in d.items() if v not in seen or seen.add(v)}

This relies on the fact that set.add always returns None in Python.

Improve this answer

Comments

1

Here is another way to do it.

my_map = {'a': 1, 'b': 2} inv_map= {} for key in my_map.keys() : val = my_map[key] inv_map[val] = key
Improve this answer

Comments

1 
dict([(value, key) for key, value in d.items()])
Improve this answer

Comments

1

Simple Case -- Bijections (no duplicate values)

The solution is to loop over the start dictionary keys and value, and add them in reverse order to a new dictionary.

Example of reversing an english-to-spanish dictionary:

e2s = {'one': 'uno', 'two': 'dos', 'three': 'tres'}

Plain old-fashioned clear Python code:

s2e = {} for english, spanish in e2s.items(): s2e[spanish] = english

Dict comprehension:

>>> {spanish: english for english, spanish in e2s.items()} {'uno': 'one', 'dos': 'two', 'tres': 'three'}

Functional approach:

>>> dict(map(reversed, s2e.items())) {'one': 'uno', 'two': 'dos', 'three': 'tres'}

Functional approach with the operator module:

>>> dict(map(itemgetter(1, 0), e2s.items())) {'uno': 'one', 'dos': 'two', 'tres': 'three'}

Many-to-many relationships

A dictionary of lists can model a one-to-many relationships.

boy_knows_girl = {'al': ['amy', 'sue'], 'bo': ['sue', 'dee'], 'kip': ['daisy', 'dee'], 'mark': ['amy', 'daisy']}

To model many-to-many relationships, the forward one-to-many dictionary should be reversed into a second one-to-many dictionary.

girl_knows_boy = {'amy': ['al', 'mark'], 'sue': ['al', 'bo'], 'dee': ['bo', 'kip'], 'daisy': ['kip', 'mark']}

Plain old-fashioned clear Python code:

 girl_knows_boy = {} for boy, girls in boy_knows_girl.items(): for girl in girls: if girl not in girl_knows_boy: girl_knows_boy[girl] = [] girl_knows_boy[girl].append(boy)

Simplify with dict.setdefault:

 girl_knows_boy = {} for boy, girls in boy_knows_girl.items(): for girl in girls: girl_knows_boy.setdefault(girl, []).append(boy)

Simplify more with collections.defaultdict:

 from collections import defaultdict girl_knows_boy = defaultdict(list) for boy, girls in boy_knows_girl.items(): for girl in girls: girl_knows_boy[girl].append(boy)

More complex multiway relationships

Relationship tuples with multiple fields are modeled as a list of tuples:

 data = [('bob', 'male', 'sorbonne', 35), ('amy', 'female', 'oxford', 30), ('sue', 'female', 'sapienza', 25), ('mark', 'male', 'oxford', 35), ('bo', 'male', 'harvard', 25), ('dee', 'female', 'sorbonne', 30), ('daisy', 'female', 'stanford', 25), ('al', 'male', 'stanford', 40),]

Unsurprisingly, the preferred tool designed for querying this data is a relational database such as sqlite3.

 import sqlite3 conn = sqlite3.connect(':memory:') conn.execute('CREATE TABLE Cohort (name text, gender text, school text, age integer)') conn.executemany('INSERT INTO Cohort VALUES (?, ?, ?, ?)', data)

Once loaded, forward and reverse lookups between any of the fields are implemented with simple queries:

 conn.execute('SELECT name, age FROM Cohort WHERE gender="male"').fetchall() conn.execute('SELECT gender, age FROM Cohort WHERE school="stanford"').fetchall() conn.execute('SELECT school, gender FROM Cohort WHERE age=30').fetchall()

Those queries can be made to run fast if the essential fields are in an index:

 conn.execute('CREATE INDEX FastIndex ON Cohort ("gender", "school", "age")')
Improve this answer

Comments

1

This is a pretty popular question with two pages of different answers. So I decided to profile different approaches.

Here the most popular solutions:

def swap_loop(mock_dict): return dict((v,k) for k,v in mock_dict.items()) def swap_map(mock_dict): return dict(map(reversed, mock_dict.items())) def swap_map_lambda(mock_dict): return dict(map(lambda x: x[::-1], mock_dict.items())) def swap_slice(mock_dict): return {mock_dict[i]:i for i in mock_dict} def swap_zip(mock_dict): return dict(zip(mock_dict.values(), mock_dict.keys()))

And results of profiling:

ncalls tottime percall cumtime percall filename:lineno(function) 1 0.128 0.128 0.247 0.247 script.py:34(swap_loop) 1 0.019 0.019 0.019 0.019 script.py:37(swap_map) 1 0.130 0.130 0.256 0.256 script.py:40(swap_map_lambda) 1 0.005 0.005 0.005 0.005 script.py:43(swap_slice) 1 0.003 0.003 0.003 0.003 script.py:46(swap_zip)

As you can see zip approach is the fastest, any way result contains only unique keys (result has less length).

Full code and the results here

Improve this answer

Comments

0

Function is symmetric for values of type list; Tuples are coverted to lists when performing reverse_dict(reverse_dict(dictionary))

def reverse_dict(dictionary): reverse_dict = {} for key, value in dictionary.iteritems(): if not isinstance(value, (list, tuple)): value = [value] for val in value: reverse_dict[val] = reverse_dict.get(val, []) reverse_dict[val].append(key) for key, value in reverse_dict.iteritems(): if len(value) == 1: reverse_dict[key] = value[0] return reverse_dict
Improve this answer

Comments

0

Since dictionaries require one unique key within the dictionary unlike values, we have to append the reversed values into a list of sort to be included within the new specific keys. 

def r_maping(dictionary): List_z=[] Map= {} for z, x in dictionary.iteritems(): #iterate through the keys and values Map.setdefault(x,List_z).append(z) #Setdefault is the same as dict[key]=default."The method returns the key value available in the dictionary and if given key is not available then it will return provided default value. Afterward, we will append into the default list our new values for the specific key. return Map
Improve this answer

Comments

0

Fast functional solution for non-bijective maps (values not unique):

from itertools import imap, groupby def fst(s): return s[0] def snd(s): return s[1] def inverseDict(d): """ input d: a -> b output : b -> set(a) """ return { v : set(imap(fst, kv_iter)) for (v, kv_iter) in groupby( sorted(d.iteritems(), key=snd), key=snd ) }

In theory this should be faster than adding to the set (or appending to the list) one by one like in the imperative solution.

Unfortunately the values have to be sortable, the sorting is required by groupby.

Improve this answer

1 Comment

"In theory this should be faster than adding to the set (or appending to the list) one by one" - no. Given n elements in the original dict, your approach has O(n log n) time complexity due to the need to sort the dict's items, whereas the naive imperative approach has O(n) time complexity. For all I know your approach may be faster up until absurdly large dicts in practice, but it certainly isn't faster in theory.
0

Try this for python 2.7/3.x

inv_map={}; for i in my_map: inv_map[my_map[i]]=i print inv_map
Improve this answer

Comments

0 
def invertDictionary(d): myDict = {} for i in d: value = d.get(i) myDict.setdefault(value,[]).append(i) return myDict print invertDictionary({'a':1, 'b':2, 'c':3 , 'd' : 1})

This will provide output as : {1: ['a', 'd'], 2: ['b'], 3: ['c']}

Improve this answer

1 Comment

Iterating key-value pairs simultaneously via dict.items (or iteritems in Python 2) is more efficient than extracting each value separately while iterating keys. Also, you have added no explanation to an answer which duplicates others.
0

A lambda solution for current python 3.x versions:

d1 = dict(alice='apples', bob='bananas') d2 = dict(map(lambda key: (d1[key], key), d1.keys())) print(d2)

Result:

{'apples': 'alice', 'bananas': 'bob'}

This solution does not check for duplicates.

Some remarks:

  • The lambda construct can access d1 from the outer scope, so we only pass in the current key. It returns a tuple.
  • The dict() constructor accepts a list of tuples. It also accepts the result of a map, so we can skip the conversion to a list.
  • This solution has no explicit for loop. It also avoids using a list comprehension for those who are bad at math ;-)
Improve this answer

1 Comment

I could not find this solution using google search or in the other answers or in the dupliate questions, so I created it.
0

Taking up the highly voted answer starting If the values in my_map aren't unique:, I had a problem where not only the values were not unique, but in addition, they were a list, with each item in the list consisting again of a list of three elements: a string value, a number, and another number.

Example:

mymap['key1'] gives you:

[('xyz', 1, 2), ('abc', 5, 4)]

I wanted to switch only the string value with the key, keeping the two number elements at the same place. You simply need another nested for loop then:

inv_map = {} for k, v in my_map.items(): for x in v: # with x[1:3] same as x[1], x[2]: inv_map[x[0]] = inv_map.get(x[0], []) + [k, x[1:3]]

Example:

inv_map['abc'] now gives you:

[('key1', 1, 2), ('key1', 5, 4)]
Improve this answer

Comments

0

This works even if you have non-unique values in the original dictionary.

def dict_invert(d): ''' d: dict Returns an inverted dictionary ''' # Your code here inv_d = {} for k, v in d.items(): if v not in inv_d.keys(): inv_d[v] = [k] else: inv_d[v].append(k) inv_d[v].sort() print(f"{inv_d[v]} are the values") return inv_d
Improve this answer

2 Comments

This solution doesn't work, I tried it and I have a TypeError: unhashable type: "list"
Can you show an example of the data you're using?
1
2

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.