Voyons comment obtenir la clé par valeur dans le dictionnaire Python.
Exemple : code One-Liner
Python3
# creating a new dictionary> my_dict>=>{>'Java'>:>100>,>'Python'>:>112>,>'C'>:>11>}> # one-liner> print>(>'One line Code Key value: '>,>list>(my_dict.keys())> >[>list>(my_dict.values()).index(>100>)])> |
>
>
Test de performance
Sortir:
Java>
Extraire la clé du dictionnaire Python à l'aide de la valeur
Méthode 1 : obtenir la clé par valeur en utilisant la compréhension de liste
Une compréhension de liste se compose de crochets contenant l'expression, qui est exécutée pour chaque élément avec la boucle for pour parcourir chaque élément de la liste Python afin d'obtenir la clé d'une valeur dans Dictionnaire .
Python3
dic>=>{>'geeks'>:>'A'>,>'for'>:>'B'>,>'geeks'>:>'C'>}> value>=> {i>for> i>in> dic>if> dic[i]>=>=>'B'>}> print>(>'key by value:'>,value)> |
>
>
Sortir:
key by value: {'for'}> Complexité temporelle : SUR)
Espace auxiliaire : O(1)
Méthode 2 : Obtenez la clé par valeur en utilisant un list.index()
Le Méthode index() renvoie l'index de la valeur correspondante dans une liste. L'approche utilisée ici consiste à trouver deux listes distinctes de clés et de valeurs. Récupérez ensuite la clé à l'aide du position de la valeur dans la val_list. Comme clé à n’importe quelle position N dans key_list aura une valeur correspondante à la position N dans val_list.
Python3
# creating a new dictionary> my_dict>=>{>'java'>:>100>,>'python'>:>112>,>'c'>:>11>}> # list out keys and values separately> key_list>=> list>(my_dict.keys())> val_list>=> list>(my_dict.values())> # print key with val 100> position>=> val_list.index(>100>)> print>(key_list[position])> |
>
les chiffres de l'alphabet
>
Sortir:
java>
Complexité temporelle : O(1)
Espace auxiliaire : O(1)
Méthode 3 : Obtenez la clé par valeur en utilisant dict.item()
Nous pouvons également récupérer la clé d'une valeur en faisant correspondre toutes les valeurs à l'aide de dict.item(), puis en imprimant la clé correspondante à la valeur donnée.
Python3
# function to return key for any value> def> get_key(val):> > >for> key, value>in> my_dict.items():> >if> val>=>=> value:> >return> key> >return> 'key doesn't exist'> # Driver Code> my_dict>=> {>'Java'>:>100>,>'Python'>:>112>,>'C'>:>11>}> print>(get_key(>100>))> print>(get_key(>11>))> |
>
>Sortir
Java C>
Complexité temporelle : O(n), où n est le nombre de paires clé-valeur dans le dictionnaire.
Espace auxiliaire : O(1), car l'espace utilisé par la fonction ne dépend pas de la taille du dictionnaire d'entrée.
Méthode 4 : Utiliser lambda et filter()
Voici un exemple d'utilisation de la fonction filter() pour obtenir la clé correspondant à une valeur dans un dictionnaire :
Python3
my_dict>=> {>'Java'>:>100>,>'Python'>:>112>,>'C'>:>11>}> # Get the key corresponding to value 100> key>=> list>(>filter>(>lambda> x: my_dict[x]>=>=> 100>, my_dict))[>0>]> print>(key)> #This code is contributed by Edula Vinay Kumar Reddy> |
>
>Sortir
Java>
Dans cet exemple, la fonction filter() est utilisée pour créer une liste de clés à partir de my_dict où la valeur est égale à 100. La liste résultante est ensuite indexée à la position 0 pour obtenir le premier élément, qui est la clé correspondant à la valeur 100.
Complexité temporelle : O(n) , car la fonction filter() doit parcourir l'intégralité du dictionnaire pour créer la liste des clés.
L'espace auxiliaire est O(n) , car la liste de clés créée par filter() a une taille égale au nombre d'éléments dans le dictionnaire.
MÉTHODE 5 : Utilisation de la méthode des éléments
Ce code trouve la clé d'une valeur donnée dans un dictionnaire en utilisant une compréhension de liste pour parcourir les éléments du dictionnaire et vérifier si la valeur correspond à la valeur donnée. Si une clé est trouvée, elle est ajoutée à une liste et le premier élément de la liste est imprimé comme clé pour la valeur donnée. Si la valeur n'est pas trouvée dans le dictionnaire, un message est imprimé indiquant qu'elle n'a pas été trouvée.
Pas:
- Utilisez la méthode items du dictionnaire pour parcourir chaque paire clé-valeur dans my_dict.
- Vérifiez si la valeur associée à la clé actuelle est égale à la valeur donnée.
- S'il est égal, ajoutez la clé actuelle à une liste de clés.
- Si la boucle se termine sans trouver de valeur correspondante, imprimez un message indiquant que la valeur n'a pas été trouvée.
- Si une clé correspondante a été trouvée, imprimez la première clé de la liste.
Python3
# input list> my_dict>=> {>'Java'>:>100>,>'Python'>:>112>,>'C'>:>11>}> value>=> 112> key_list>=> [key>for> key, val>in> my_dict.items()>if> val>=>=> value]> if> len>(key_list)>>0>:> >print>(>'The key for the value'>, value,>'is'>, key_list[>0>])> else>:> >print>(>'Value not found in dictionary'>)> |
>
>Sortir
The key for the value 112 is Python>
Complexité temporelle : O(N), où n est le nombre de paires clé-valeur dans le dictionnaire.
Espace auxiliaire : O(K) , où k est le nombre de clés qui correspondent à la valeur donnée.
MÉTHODE 6 : Utilisation du module re
Le programme utilise le module re en Python pour trouver la clé dans un dictionnaire qui correspond à une valeur donnée. Il crée un modèle d'expression régulière qui correspond à la valeur entourée de limites de mots, puis utilise la fonction next() pour parcourir les éléments du dictionnaire et rechercher une valeur qui correspond au modèle. Si une correspondance est trouvée, le programme renvoie la clé correspondante.
ALGORITHME:
- Créez un modèle d'expression régulière qui correspond à la valeur que nous recherchons, entouré de limites de mots.
- Utilisez la fonction next() pour parcourir les éléments du dictionnaire, en recherchant une valeur qui correspond au modèle.
- Si une correspondance est trouvée, renvoyez la clé correspondante. Sinon, renvoyez Aucun.
Python3
PowerShell contre bash
import> re> # Given input> my_dict>=> {>'Java'>:>100>,>'Python'>:>112>,>'C'>:>11>}> value>=> 100> # Program code> pattern>=> re.>compile>(r>''> +> str>(value)>+> r>''>)> key>=> next>((k>for> k, v>in> my_dict.items()>if> pattern.search(>str>(v))),>None>)> print>(key)> |
>
>Sortir
Java>
Complexité temporelle : O(N), La création du modèle d'expression régulière prend un temps O(1). La recherche d'une valeur qui correspond au modèle dans chaque élément du dictionnaire prend un temps O(n) dans le pire des cas, où n est le nombre d'éléments dans le dictionnaire. La fonction next() et l'instruction if prennent chacune un temps O(1). Par conséquent, la complexité temporelle globale du programme est O(n).
Espace auxiliaire : O(1), Le modèle d'expression régulière et la variable clé nécessitent chacun un espace O(1). La variable de motif et l'expression génératrice à l'intérieur de la fonction next() nécessitent toutes deux un espace O(1). Les variables k et v utilisées dans l'expression du générateur ne nécessitent pas d'espace supplémentaire, car elles sont créées dans le cadre de l'itération. Par conséquent, la complexité spatiale globale du programme est O(1).