最后我用一个函数来做。这种方法可以避免进行完整的循环，直觉告诉我们，它应该比其他解决方案更快。

def get_key_from_value(my_dict, to_find):

    for k,v in my_dict.items():
        if v==to_find: return k

    return None

a = {'a':1,'b':2,'c':3}
{v:k for k, v in a.items()}[1]

或更好的

{k:v for k, v in a.items() if v == 1}

已经回答了，但由于一些人提到反转字典，下面是如何在一行中做到这一点(假设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)。以我之见，在低端产品上节省下来的少量成本，在高端产品上的成本是不值的。

以下是我的看法。这对于显示多个结果很有好处，以防您需要一个结果。所以我也添加了这个列表

myList = {'george':16,'amber':19, 'rachel':19, 
           'david':15 }                         #Setting the dictionary
result=[]                                       #Making ready of the result list
search_age = int(input('Enter age '))

for keywords in myList.keys():
    if myList[keywords] ==search_age:
    result.append(keywords)                    #This part, we are making list of results

for res in result:                             #We are now printing the results
    print(res)

就是这样……

下面是一个在python2和python3中都适用的解决方案:

dict((v, k) for k, v in list.items())[search_age]

直到[search_age]的部分构造反向字典(其中值是键，反之亦然)。 你可以创建一个helper方法来缓存这个反向字典，就像这样:

def find_name(age, _rev_lookup=dict((v, k) for k, v in ages_by_name.items())):
    return _rev_lookup[age]

或者更一般的是一个工厂，它会为你的一个或多个列表创建一个按年龄查找的方法

def create_name_finder(ages_by_name):
    names_by_age = dict((v, k) for k, v in ages_by_name.items())
    def find_name(age):
      return names_by_age[age]

所以你可以这样做:

find_teen_by_age = create_name_finder({'george':16,'amber':19})
...
find_teen_by_age(search_age)

注意，我将list重命名为ages_by_name，因为前者是预定义的类型。

这是一个奇怪的问题，因为第一条评论就给出了完美的答案。 根据样例提供的数据示例

dictionary = {'george': 16, 'amber': 19}
print(dictionary["george"])

它返回

16

所以你想要相反的结果 输入“16”，得到“george” 简单地交换键值和presto

dictionary = {'george': 16, 'amber': 19}
inv_dict = {value:key for key, value in dictionary.items()}
print(inv_dict[16])

我处于完全相反的位置，因为我有一本字典

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

我试着喂"乔治"然后得到16个…我尝试了几种循环和迭代器，OK..他们工作，但它不是简单的一行解决方案，我将使用快速结果…所以我简单地交换了解。 如果我错过了什么，请让我知道删除我的答案。