Obter chave por valor no dicionário

Eu criei uma função que irá procurar idades em um Dictionarye mostrar o nome correspondente:

dictionary = {'george' : 16, 'amber' : 19}
search_age = raw_input("Provide age")
for age in dictionary.values():
    if age == search_age:
        name = dictionary[age]
        print name

Eu sei como comparar e encontrar a idade em que simplesmente não sei como mostrar o nome da pessoa. Além disso, estou recebendo uma KeyErrorcausa da linha 5. Sei que não está correta, mas não consigo descobrir como fazê-la pesquisar para trás.

Não há nenhum. dictnão se destina a ser usado dessa maneira.

dictionary = {'george': 16, 'amber': 19}
search_age = input("Provide age")
for name, age in dictionary.items():  # for name, age in dictionary.iteritems():  (for Python 2.x)
    if age == search_age:
        print(name)

mydict = {'george': 16, 'amber': 19}
print mydict.keys()[mydict.values().index(16)]  # Prints george

Ou no Python 3.x:

mydict = {'george': 16, 'amber': 19}
print(list(mydict.keys())[list(mydict.values()).index(16)])  # Prints george

Basicamente, ele separa os valores do dicionário em uma lista, localiza a posição do valor que você possui e obtém a chave nessa posição.

Mais sobre keys()e .values()no Python 3: Como posso obter uma lista de valores do dict?

Se você deseja o nome e a idade, deve usar o .items()que fornece as (key, value)tuplas principais :

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

Você pode descompactar a tupla em duas variáveis ​​separadas diretamente no forloop e depois corresponder à idade.

Você também deve reverter o dicionário se geralmente procura por idade e não há duas pessoas com a mesma idade:

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

para que você possa procurar o nome por uma idade, apenas fazendo

mydict[search_age]

Chamo-o em mydictvez de listporque listé o nome de um tipo interno e você não deve usar esse nome para mais nada.

Você pode até obter uma lista de todas as pessoas com uma determinada idade em uma linha:

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

ou se houver apenas uma pessoa com cada idade:

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

o que lhe dará apenas Nonese não houver ninguém com essa idade.

Finalmente, se o dictarquivo for longo e você estiver usando o Python 2, considere usar em .iteritems()vez do .items()Cat Plus Plus em sua resposta, pois não é necessário fazer uma cópia da lista.

Eu pensei que seria interessante apontar quais métodos são os mais rápidos e em que cenário:

Aqui estão alguns testes que eu executei (em um MacBook Pro de 2012)

>>> def method1(list,search_age):
...     for name,age in list.iteritems():
...             if age == search_age:
...                     return name
... 
>>> def method2(list,search_age):
...     return [name for name,age in list.iteritems() if age == search_age]
... 
>>> def method3(list,search_age):
...     return list.keys()[list.values().index(search_age)]

Resultados de profile.run()cada método 100000 vezes:

Método 1:

>>> profile.run("for i in range(0,100000): method1(list,16)")
     200004 function calls in 1.173 seconds

Método 2:

>>> profile.run("for i in range(0,100000): method2(list,16)")
     200004 function calls in 1.222 seconds

Método 3:

>>> profile.run("for i in range(0,100000): method3(list,16)")
     400004 function calls in 2.125 seconds

Portanto, isso mostra que, para um pequeno ditado, o método 1 é o mais rápido. Isso é mais provável porque ele retorna a primeira correspondência, em oposição a todas as correspondências como o método 2 (veja a nota abaixo).

Curiosamente, executando os mesmos testes em um ditado que tenho com 2700 entradas, obtenho resultados bem diferentes (desta vez, executados 10000 vezes):

Método 1:

>>> profile.run("for i in range(0,10000): method1(UIC_CRS,'7088380')")
     20004 function calls in 2.928 seconds

Método 2:

>>> profile.run("for i in range(0,10000): method2(UIC_CRS,'7088380')")
     20004 function calls in 3.872 seconds

Método 3:

>>> profile.run("for i in range(0,10000): method3(UIC_CRS,'7088380')")
     40004 function calls in 1.176 seconds

Então, aqui, o método 3 é muito mais rápido. Apenas mostra que o tamanho do seu ditado afetará o método escolhido.

Notas: O método 2 retorna uma lista de todos os nomes, enquanto os métodos 1 e 3 retornam apenas a primeira correspondência. Eu não considerei o uso de memória. Não tenho certeza se o método 3 cria 2 listas extras (chaves () e valores ()) e as armazena na memória.

versão de uma linha: (i é um dicionário antigo, p é um dicionário invertido)

explicação: i.keys()e i.values()retorna duas listas com chaves e valores do dicionário, respectivamente. A função zip tem a capacidade de amarrar listas para produzir um dicionário.

p = dict(zip(i.values(),i.keys()))

Aviso: Isso funcionará apenas se os valores forem laváveis ​​e exclusivos.

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

ou melhor

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

key = next((k for k in my_dict if my_dict[k] == val), None)

Tente esta lista para reverter um dicionário:

reversed_dictionary = dict(map(reversed, dictionary.items()))

Achei esta resposta muito eficaz, mas não muito fácil de ler para mim.

Para tornar mais claro, você pode inverter a chave e o valor de um dicionário. Isso é fazer os valores das chaves e as chaves de valores, como visto aqui .

mydict = {'george':16,'amber':19}
res = dict((v,k) for k,v in mydict.iteritems())
print(res[16]) # Prints george

ou

mydict = {'george':16,'amber':19}
dict((v,k) for k,v in mydict.iteritems())[16]

que é essencialmente o mesmo que essa outra resposta .

Se você deseja encontrar a chave pelo valor, pode usar uma compreensão de dicionário para criar um dicionário de pesquisa e, em seguida, usá-lo para encontrar a chave no valor.

lookup = {value: key for key, value in self.data}
lookup[value]

Você pode obter a chave usando dict.keys(), dict.values()e list.index()métodos, ver exemplos de código a seguir:

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

Aqui está a minha opinião sobre este problema. :) Acabei de começar a aprender Python, então chamo isso:

Solução "Compreensível para iniciantes".

#Code without comments.

list1 = {'george':16,'amber':19, 'Garry':19}
search_age = raw_input("Provide age: ")
print
search_age = int(search_age)

listByAge = {}

for name, age in list1.items():
    if age == search_age:
        age = str(age)
        results = name + " " +age
        print results

        age2 = int(age)
        listByAge[name] = listByAge.get(name,0)+age2

print
print listByAge

.

#Code with comments.
#I've added another name with the same age to the list.
list1 = {'george':16,'amber':19, 'Garry':19}
#Original code.
search_age = raw_input("Provide age: ")
print
#Because raw_input gives a string, we need to convert it to int,
#so we can search the dictionary list with it.
search_age = int(search_age)

#Here we define another empty dictionary, to store the results in a more 
#permanent way.
listByAge = {}

#We use double variable iteration, so we get both the name and age 
#on each run of the loop.
for name, age in list1.items():
    #Here we check if the User Defined age = the age parameter 
    #for this run of the loop.
    if age == search_age:
        #Here we convert Age back to string, because we will concatenate it 
        #with the person's name. 
        age = str(age)
        #Here we concatenate.
        results = name + " " +age
        #If you want just the names and ages displayed you can delete
        #the code after "print results". If you want them stored, don't...
        print results

        #Here we create a second variable that uses the value of
        #the age for the current person in the list.
        #For example if "Anna" is "10", age2 = 10,
        #integer value which we can use in addition.
        age2 = int(age)
        #Here we use the method that checks or creates values in dictionaries.
        #We create a new entry for each name that matches the User Defined Age
        #with default value of 0, and then we add the value from age2.
        listByAge[name] = listByAge.get(name,0)+age2

#Here we print the new dictionary with the users with User Defined Age.
print
print listByAge

.

#Results
Running: *\test.py (Thu Jun 06 05:10:02 2013)

Provide age: 19

amber 19
Garry 19

{'amber': 19, 'Garry': 19}

Execution Successful!

get_key = lambda v, d: next(k for k in d if d[k] is v)

Considere usar Pandas. Conforme declarado em "Python for Data Analysis" de William McKinney

Outra maneira de pensar em uma série é como um ditado ordenado de comprimento fixo, pois é um mapeamento de valores de índice para valores de dados. Pode ser usado em muitos contextos em que você pode usar um ditado.

import pandas as pd
list = {'george':16,'amber':19}
lookup_list = pd.Series(list)

Para consultar sua série, faça o seguinte:

lookup_list[lookup_list.values == 19]

Qual produz:

Out[1]: 
amber    19
dtype: int64

Se você precisar fazer mais alguma coisa com a saída, transformar a resposta em uma lista pode ser útil:

answer = lookup_list[lookup_list.values == 19].index
answer = pd.Index.tolist(answer)

Aqui, recover_key leva dicionário e valor para encontrar no dicionário. Em seguida, fazemos um loop sobre as chaves no dicionário e fazemos uma comparação com a do valor e retornamos essa chave específica.

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

podemos obter o Keyde dict:

def getKey(dct,value):
     return [key for key in dct if (dct[key] == value)]

for name in mydict:
    if mydict[name] == search_age:
        print(name) 
        #or do something else with it. 
        #if in a function append to a temporary list, 
        #then after the loop return the list

é respondido, mas pode ser feito com um uso sofisticado de 'mapear / reduzir';

def find_key(value, dictionary):
    return reduce(lambda x, y: x if x is not None else y,
                  map(lambda x: x[0] if x[1] == value else None, 
                      dictionary.iteritems()))

O Cat Plus Plus mencionou que não é assim que um dicionário se destina a ser usado. Aqui está o porquê:

A definição de um dicionário é análoga à de um mapeamento em matemática. Nesse caso, um ditado é um mapeamento de K (o conjunto de chaves) para V (os valores) - mas não vice-versa. Se você derreferenciar um ditado, espera obter exatamente um valor retornado. Mas é perfeitamente legal que diferentes chaves sejam mapeadas para o mesmo valor, por exemplo:

d = { k1 : v1, k2 : v2, k3 : v1}

Quando você pesquisa uma chave pelo seu valor correspondente, está basicamente invertendo o dicionário. Mas um mapeamento não é necessariamente invertível! Neste exemplo, pedir a chave correspondente a v1 pode gerar k1 ou k3. Você deve devolver os dois? Apenas o primeiro encontrado? É por isso que indexof () é indefinido para dicionários.

Se você conhece seus dados, você pode fazer isso. Mas uma API não pode assumir que um dicionário arbitrário é invertível, daí a falta de uma operação desse tipo.

aqui está a minha opinião. Isso é bom para exibir vários resultados, caso você precise de um. Então eu adicionei a lista também

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)

E é isso...

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

dict((v,k) for k,v in d.items()).get(16)

A saída é a seguinte:

-> prints george

Não há uma maneira fácil de encontrar uma chave em uma lista 'pesquisando' o valor. No entanto, se você souber o valor, iterando pelas chaves, poderá procurar valores no dicionário pelo elemento. Se D [elemento] em que D é um objeto de dicionário, for igual à chave que você está tentando procurar, você poderá executar algum código.

D = {'Ali': 20, 'Marina': 12, 'George':16}
age = int(input('enter age:\t'))  
for element in D.keys():
    if D[element] == age:
        print(element)

Você precisa usar um dicionário e o inverso desse dicionário. Isso significa que você precisa de outra estrutura de dados. Se você estiver no python 3, use o enummódulo, mas se estiver usando o python 2.7, use a enum34porta traseira do python 2.

Exemplo:

from enum import Enum

class Color(Enum): 
    red = 1 
    green = 2 
    blue = 3

>>> print(Color.red) 
Color.red

>>> print(repr(Color.red)) 
<color.red: 1=""> 

>>> type(Color.red) 
<enum 'color'=""> 
>>> isinstance(Color.green, Color) 
True 

>>> member = Color.red 
>>> member.name 
'red' 
>>> member.value 
1 

def get_Value(dic,value):
    for name in dic:
        if dic[name] == value:
            del dic[name]
            return name

Apenas minha resposta em lambdae filter.

filter( lambda x, dictionary=dictionary, search_age=int(search_age): dictionary[x] == search_age  , dictionary )

já foi respondido, mas como várias pessoas mencionaram a reversão do dicionário, veja como você faz isso em uma linha (assumindo o mapeamento 1: 1) e alguns dados de perf:

python 2.6:

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

2.7+:

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

se você acha que não é 1: 1, ainda pode criar um mapeamento reverso razoável com algumas linhas:

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

quão lenta é essa: mais lenta que uma pesquisa simples, mas não tão lenta quanto você imagina - em um dicionário de entradas 100000 'direto', uma pesquisa 'rápida' (ou seja, procurando um valor que deve estar no início das teclas) foi cerca de 10x mais rápido do que reverter o dicionário inteiro e uma pesquisa "lenta" (no final) cerca de 4-5x mais rápido. Então, depois de no máximo 10 pesquisas, é pago por si próprio.

a segunda versão (com listas por item) leva cerca de 2,5x enquanto a versão simples.

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

Também teve alguns resultados interessantes com o ifilter. Teoricamente, se o filtro deve ser mais rápido, podemos usar itervalues ​​() e possivelmente não precisamos criar / passar por toda a lista de valores. Na prática, os resultados foram ... estranhos ...

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

Portanto, para pequenas compensações, foi dramaticamente mais rápido que qualquer versão anterior (2,36 * u * S vs. um mínimo de 1,48 * m * S para casos anteriores). No entanto, para grandes compensações perto do final da lista, foi drasticamente mais lenta (15,1ms vs. o mesmo 1,48mS). As pequenas economias na parte baixa não valem o custo na parte alta, imho.

Às vezes, int () pode ser necessário:

titleDic = {'Фильмы':1, 'Музыка':2}

def categoryTitleForNumber(self, num):
    search_title = ''
    for title, titleNum in self.titleDic.items():
        if int(titleNum) == int(num):
            search_title = title
    return search_title

Aqui está uma solução que funciona tanto em Python 2 quanto em Python 3:

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

A parte até [search_age]constrói o dicionário reverso (onde os valores são chaves e vice-versa). Você pode criar um método auxiliar que armazene em cache esse dicionário invertido da seguinte maneira:

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

ou ainda mais geralmente uma fábrica que criaria um método de busca por nome por idade para uma ou mais listas

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]

então você seria capaz de fazer:

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

Observe que eu renomei listpara, ages_by_namepois o primeiro é um tipo predefinido.

É assim que você acessa o dicionário para fazer o que deseja:

list = {'george': 16, 'amber': 19}
search_age = raw_input("Provide age")
for age in list:
    if list[age] == search_age:
        print age

é claro, seus nomes estão tão errados que parece que eles estão imprimindo uma era, mas NÃO imprime o nome. Como você está acessando pelo nome, fica mais compreensível se você escrever:

list = {'george': 16, 'amber': 19}
search_age = raw_input("Provide age")
for name in list:
    if list[name] == search_age:
        print name

Melhor ainda:

people = {'george': {'age': 16}, 'amber': {'age': 19}}
search_age = raw_input("Provide age")
for name in people:
    if people[name]['age'] == search_age:
        print name

dictionary = {'george' : 16, 'amber' : 19}
search_age = raw_input("Provide age")
key = [filter( lambda x: dictionary[x] == k  , dictionary ),[None]][0] 
# key = None from [None] which is a safeguard for not found.

Para várias ocorrências, use:

keys = [filter( lambda x: dictionary[x] == k  , dictionary )]