Trouver la clé par valeur dans le dictionnaire Python

Les dictionnaires Python associent des clés à des valeurs. Pour trouver une clé à partir d’une valeur, il faut donc parcourir les entrées du dictionnaire. Parcourez chaque paire clé-valeur et comparez sa valeur à la valeur recherchée. Utilisez une boucle ou next() pour obtenir la première clé correspondante, et une compréhension de liste pour obtenir toutes les clés correspondantes. Ces recherches parcourent les entrées jusqu’à trouver une correspondance ou jusqu’à épuiser le dictionnaire.

Parcourir les paires clé-valeur avec une boucle

dict.items() fournit un itérable de paires clé-valeur. Une boucle qui le parcourt peut renvoyer la première clé dont la valeur est égale à celle recherchée. Renvoyer None après la boucle indique clairement qu’aucune correspondance n’a été trouvée ; si None peut aussi être une clé valide, utilisez une sentinelle distincte ou renvoyez une paire (found, key).

Exécutez cet exemple :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

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

La boucle renvoie immédiatement une clé dès qu’elle trouve une correspondance. Il s’agit donc de la première clé correspondante dans l’ordre d’itération du dictionnaire. Si plusieurs clés ont la valeur recherchée, les suivantes ne sont pas parcourues après la première correspondance.

Obtenir la première clé correspondante avec next()

Une expression génératrice permet d’écrire plus brièvement la même recherche de première correspondance. Passez-la à next() avec une valeur par défaut : l’appel renverra None si le générateur ne produit aucune clé correspondante, au lieu de lever StopIteration.

Dans l’exemple, target est un paramètre de la fonction : appelez-la avec une valeur présente pour obtenir la première clé correspondante, ou avec une valeur absente pour obtenir None.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

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))

Le générateur produit les clés à mesure qu’elles sont nécessaires, sans créer de liste de toutes les correspondances. La valeur par défaut est renvoyée si aucune valeur ne correspond. Si vos données peuvent inclure None comme clé, choisissez une valeur par défaut qui ne risque pas d’être confondue avec une clé valide.

Récupérer toutes les clés correspondantes avec une compréhension

Lorsque les valeurs en double comptent, récupérez toutes les clés correspondantes avec une compréhension de liste :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

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']

La liste renvoyée est vide si aucune valeur ne correspond ; sinon, elle contient toutes les clés correspondantes. Une expression filter() peut également sélectionner les paires clé-valeur correspondantes, mais la compréhension rend visibles à la fois la condition et les clés récupérées.

Trouver une clé à l’aide de listes de clés et de valeurs alignées

Une autre possibilité consiste à convertir dict.keys() et dict.values() en listes. Leurs positions correspondent : la clé à la position i est associée à la valeur à la même position. Appeler index() sur la liste des valeurs trouve la première position contenant la valeur recherchée ; utilisez cette position pour récupérer la clé correspondante dans la liste des clés.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

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

Ada

index() lève ValueError si la valeur est absente. Vérifiez donc d’abord si elle figure dans values, ou gérez cette erreur si son absence est prévisible. En présence de valeurs en double, index() ne sélectionne que la première position correspondante.

Gérer les doublons, les valeurs absentes et les performances

Choisissez le type de résultat en fonction du besoin : une boucle ou next() renvoie une seule clé, tandis que la compréhension renvoie une liste de toutes les clés correspondantes. Les méthodes qui cherchent la première correspondance, ainsi que index(), s’arrêtent à la première trouvée ; leur résultat dépend de l’ordre d’itération du dictionnaire. En l’absence de correspondance, le résultat peut être None ou une liste vide. La méthode des listes alignées lève ValueError, sauf si vous vérifiez la présence de la valeur ou gérez l’erreur.

Dans le pire des cas, toutes ces méthodes peuvent examiner chaque entrée : le temps de recherche est donc proportionnel au nombre d’entrées du dictionnaire. La boucle et l’expression génératrice ne créent pas de collection de correspondances. La compréhension crée une liste de résultats, tandis que la méthode des listes alignées crée des listes distinctes de clés et de valeurs avant la recherche. Si vous devez effectuer souvent des recherches de clé par valeur, envisagez de maintenir une correspondance inverse ; tenez compte des valeurs en double, car un simple dictionnaire inverse ne conserve qu’une seule clé par valeur. Pour les dictionnaires imbriqués, déterminez d’abord le niveau à parcourir, puis appliquez à ce dictionnaire la même méthode d’itération sur les entrées.