Possible Duplicate:
Inverse dictionary lookup - Python

Is there a built in way to index a dictionary by value in Python.

e.g. something like:

dict = {'fruit':'apple','colour':'blue','meat':'beef'}
print key where dict[key] == 'apple'

or:

dict = {'fruit':['apple', 'banana'], 'colour':'blue'}
print key where 'apple' in dict[key]

or do I have to manually loop it?

• python
• dictionary

You could use a list comprehension:

my_dict = {'fruit':'apple','colour':'blue','meat':'beef'}
print [key for key, value in my_dict.items() if value == 'apple']

The code above is doing almost exactly what said you want:

print key where dict[key] == 'apple'

The list comprehension is going through all the key, value pairs given by your dictionary's items method, and making a new list of all the keys where the value is 'apple'.

As Niklas pointed out, this does not work when your values could potentially be lists. You have to be careful about just using in in this case since 'apple' in 'pineapple' == True. So, sticking with a list comprehension approach requires some type checking. So, you could use a helper function like:

def equals_or_in(target, value):
    """Returns True if the target string equals the value string or,
    is in the value (if the value is not a string).
    """
    if isinstance(target, str):
        return target == value
    else:
        return target in value

Then, the list comprehension below would work:

my_dict = {'fruit':['apple', 'banana'], 'colour':'blue'}
print [key for key, value in my_dict.items() if equals_or_in('apple', value)]

You'll have to manually loop it, but if you'll need the lookup repeatedly this is a handy trick:

d1 = {'fruit':'apple','colour':'blue','meat':'beef'}

d1_rev = dict((v, k) for k, v in d1.items())

You can then use the reverse dictionary like this:

>>> d1_rev['blue']
'colour'
>>> d1_rev['beef']
'meat'

Your requirements are more complex than you realize:

• You need to handle both list values and plain values
• You don't actually need to get back a key, but a list of keys

You could solve this in two steps:

1. normalize the dict so that every value is a list (every plain value becomes a single-element)
2. build a reverse dictionary

The following functions will solve this:

from collections import defaultdict

def normalize(d):
    return { k:(v if isinstance(v, list) else [v]) for k,v in d.items() }

def build_reverse_dict(d):
    res = defaultdict(list)
    for k,values in normalize(d).items():
        for x in values:
            res[x].append(k)
    return dict(res)

To be used like this:

>>> build_reverse_dict({'fruit':'apple','colour':'blue','meat':'beef'})
{'blue': ['colour'], 'apple': ['fruit'], 'beef': ['meat']}
>>> build_reverse_dict({'fruit':['apple', 'banana'], 'colour':'blue'})
{'blue': ['colour'], 'apple': ['fruit'], 'banana': ['fruit']}
>>> build_reverse_dict({'a':'duplicate', 'b':['duplicate']})
{'duplicate': ['a', 'b']}

So you just build up the reverse dictionary once and then lookup by value and get back a list of keys.