已经回答了，但由于一些人提到反转字典，下面是如何在一行中做到这一点(假设1:1映射)和一些各种性能数据:

python 2.6:

reversedict = dict([(value, key) for key, value in mydict.iteritems()])

+ 2.7:

reversedict = {value:key for key, value in mydict.iteritems()}

如果你认为不是1:1，你仍然可以用几行创建一个合理的反向映射:

reversedict = defaultdict(list)
[reversedict[value].append(key) for key, value in mydict.iteritems()]

这有多慢:比简单的搜索慢，但远没有你想象的那么慢——在一个“直接”100000条目的字典上，“快速”搜索(即查找键前面的值)比反转整个字典快10倍左右，而“缓慢”搜索(接近结尾)大约快4-5倍。所以最多查找10次，就能收回成本。

第二个版本(每个项目都有列表)大约是简单版本的2.5倍。

largedict = dict((x,x) for x in range(100000))

# Should be slow, has to search 90000 entries before it finds it
In [26]: %timeit largedict.keys()[largedict.values().index(90000)]
100 loops, best of 3: 4.81 ms per loop

# Should be fast, has to only search 9 entries to find it. 
In [27]: %timeit largedict.keys()[largedict.values().index(9)]
100 loops, best of 3: 2.94 ms per loop

# How about using iterkeys() instead of keys()?
# These are faster, because you don't have to create the entire keys array.
# You DO have to create the entire values array - more on that later.

In [31]: %timeit islice(largedict.iterkeys(), largedict.values().index(90000))
100 loops, best of 3: 3.38 ms per loop

In [32]: %timeit islice(largedict.iterkeys(), largedict.values().index(9))
1000 loops, best of 3: 1.48 ms per loop

In [24]: %timeit reversedict = dict([(value, key) for key, value in largedict.iteritems()])
10 loops, best of 3: 22.9 ms per loop

In [23]: %%timeit
....: reversedict = defaultdict(list)
....: [reversedict[value].append(key) for key, value in largedict.iteritems()]
....:
10 loops, best of 3: 53.6 ms per loop

过滤器也有一些有趣的结果。理论上，filter应该更快，因为我们可以使用itervalues()，而且可能不需要创建/遍历整个值列表。在实践中，结果是……奇怪的……

In [72]: %%timeit
....: myf = ifilter(lambda x: x[1] == 90000, largedict.iteritems())
....: myf.next()[0]
....:
100 loops, best of 3: 15.1 ms per loop

In [73]: %%timeit
....: myf = ifilter(lambda x: x[1] == 9, largedict.iteritems())
....: myf.next()[0]
....:
100000 loops, best of 3: 2.36 us per loop

因此，对于小偏移量，它比以前的任何版本都要快得多(2.36 *u*S vs.以前的情况下至少1.48 *m*S)。然而，对于接近列表末尾的大偏移量，它会显着变慢(15.1ms vs.相同的1.48mS)。以我之见，在低端产品上节省下来的少量成本，在高端产品上的成本是不值的。

如果你想要名字和年龄，你应该使用.items()，它会给你key (key, value)元组:

for name, age in mydict.items():
    if age == search_age:
        print name

您可以在for循环中将元组解包为两个单独的变量，然后匹配年龄。

如果你通常要根据年龄查找，而且没有两个人的年龄相同，你还应该考虑颠倒字典:

{16: 'george', 19: 'amber'}

所以你可以通过这样做来查找这个名字

mydict[search_age]

我一直称它为mydict而不是list，因为list是内置类型的名称，你不应该将这个名称用于其他任何类型。

你甚至可以在一行中得到给定年龄的所有人的列表:

[name for name, age in mydict.items() if age == search_age]

或者如果每个年龄只有一个人:

next((name for name, age in mydict.items() if age == search_age), None)

如果没有这个年龄的人，就会给你None。

最后，如果字典很长并且你使用的是Python 2，你应该考虑使用.iteritems()而不是像Cat Plus Plus在他的回答中所做的那样使用.items()，因为它不需要复制列表。

我试着阅读尽可能多的答案，以防止给出重复的答案。然而，如果你正在处理一个包含在列表中的值的字典，并且如果你想获得具有特定元素的键，你可以这样做:

d = {'Adams': [18, 29, 30],
     'Allen': [9, 27],
     'Anderson': [24, 26],
     'Bailey': [7, 30],
     'Baker': [31, 7, 10, 19],
     'Barnes': [22, 31, 10, 21],
     'Bell': [2, 24, 17, 26]}

现在让我们找到值为24的名称。

for key in d.keys():    
    if 24 in d[key]:
        print(key)

这也适用于多个值。

这里，recover_key接受dictionary和要在dictionary中查找的值。然后循环遍历dictionary中的键，并与value的键进行比较，然后返回特定的键。

def recover_key(dicty,value):
    for a_key in dicty.keys():
        if (dicty[a_key] == value):
            return a_key

你可以通过使用dict.keys()， dict.values()和list.index()方法来获取key，参见下面的代码示例:

names_dict = {'george':16,'amber':19}
search_age = int(raw_input("Provide age"))
key = names_dict.keys()[names_dict.values().index(search_age)]

使用列表理解的一行解决方案，如果值可能出现多次，则返回多个键。

[key for key,value in mydict.items() if value == 16]