Encontrar chave por valor no Python Dicionário

Os dicionários Python associam chaves a valores; por isso, para encontrar uma chave a partir de um valor, é preciso pesquisar as entradas do dicionário. Percorra cada par de chave e valor e compare o valor com o alvo. Use um laço ou next() quando precisar da primeira chave correspondente e uma compreensão de lista quando precisar de todas. Essas buscas percorrem as entradas até encontrar uma correspondência ou chegar ao fim do dicionário.

Pesquisar pares de chave e valor com um laço

dict.items() fornece um iterável de pares de chave e valor. Um laço sobre esse iterável pode retornar a primeira chave cujo valor seja igual ao alvo. Retornar None ao fim do laço oferece um resultado claro quando não há correspondência; se None também puder ser uma chave válida, use um sentinela distinto ou retorne um par (found, key).

Execute este exemplo:

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

def find_key_by_value(dictionary, target):
    for key, value in dictionary.items():
        if value == target:
            return key
    return None

scores = {"Ada": 91, "Lin": 87, "Sam": 91}
print(find_key_by_value(scores, 87))

Lin

O laço retorna assim que encontra uma correspondência; portanto, retorna a primeira chave correspondente na ordem de iteração do dicionário. Se várias chaves tiverem o valor procurado, as correspondências seguintes não serão verificadas depois que a primeira for encontrada.

Obter a primeira chave correspondente com next()

Uma expressão geradora permite escrever de forma concisa a mesma busca pela primeira correspondência. Passe-a para next() com um valor padrão para que a chamada retorne None quando o gerador não encontrar uma chave correspondente, em vez de gerar StopIteration.

Defina o alvo como argumento de uma função antes de avaliar a expressão. Assim, ela pode ser usada com um valor que corresponda a uma chave e com outro que não corresponda:

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

def find_key_with_next(dictionary, target):
    return next((key for key, value in dictionary.items() if value == target), None)

scores = {"Ada": 91, "Lin": 87, "Sam": 91}
print(find_key_with_next(scores, 87))
print(find_key_with_next(scores, 100))

O gerador produz as chaves conforme necessário, sem criar uma lista com todas as correspondências. O valor padrão é retornado quando nenhum valor corresponde. Se os dados puderem conter None como chave, escolha um padrão que não possa ser confundido com uma chave válida.

Reunir todas as chaves correspondentes com uma compreensão

Quando for importante identificar valores duplicados, reúna todas as chaves correspondentes com uma compreensão de lista:

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

def find_all_keys(dictionary, target):
    return [key for key, value in dictionary.items() if value == target]

scores = {"Ada": 91, "Lin": 87, "Sam": 91}
print(find_all_keys(scores, 91))

['Ada', 'Sam']

A lista retornada fica vazia quando nenhum valor corresponde e, caso contrário, contém todas as chaves correspondentes. Uma expressão filter() também pode selecionar os pares de chave e valor correspondentes, mas a compreensão deixa visíveis, em um só lugar, tanto a condição quanto as chaves reunidas.

Encontrar uma chave usando listas alinhadas de chaves e valores

Outra opção é converter dict.keys() e dict.values() em listas. As posições correspondem: a chave na posição i pertence ao valor que está nessa mesma posição. Chamar index() na lista de valores encontra a primeira posição que contém o alvo; use essa posição para selecionar a chave correspondente na lista de chaves.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

scores = {"Ada": 91, "Lin": 87, "Sam": 91}
keys = list(scores.keys())
values = list(scores.values())
position = values.index(91)
print(keys[position])

Ada

index() gera ValueError se o valor não estiver presente; por isso, verifique primeiro se ele pertence a values ou trate esse erro quando a ausência for esperada. Se houver valores duplicados, index() seleciona apenas a primeira posição correspondente.

Lidar com duplicados, valores ausentes e desempenho

Escolha o formato do resultado conforme a tarefa: um laço ou next() retorna uma chave, enquanto a compreensão retorna uma lista com todas as chaves correspondentes. As abordagens que procuram a primeira correspondência e index() param ao encontrar a primeira; o resultado depende da ordem de iteração do dicionário. Quando não há correspondência, o resultado pode ser None ou uma lista vazia; a técnica com listas alinhadas gera ValueError, a menos que você verifique se o valor está presente ou trate o erro.

No pior caso, qualquer uma dessas abordagens pode examinar todas as entradas, então o tempo de busca é proporcional ao número de entradas do dicionário. O laço e a expressão geradora não criam uma coleção de correspondências. A compreensão cria uma lista de resultados, e a abordagem com listas alinhadas cria listas separadas de chaves e valores antes da busca. Se precisar consultar repetidamente a chave correspondente a um valor, considere manter um mapeamento inverso; leve em conta os valores duplicados, pois um dicionário inverso simples mantém apenas uma chave por valor. Para dicionários aninhados, decida primeiro qual nível deve ser pesquisado e aplique a esse dicionário o mesmo padrão de iteração pelas entradas.