Vediamo come ottenere la chiave per valore nel dizionario Python.
Esempio: codice 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>)])> |
>
>
Produzione:
Java>
Estrai la chiave dal dizionario Python usando Value
Metodo 1: ottieni la chiave in base al valore utilizzando la comprensione dell'elenco
Una comprensione di lista è costituita da parentesi contenenti l'espressione, che viene eseguita per ogni elemento insieme al ciclo for per scorrere ogni elemento nell'elenco Python per ottenere la chiave da un valore in Dizionario .
Python3
dic>=>{>'geeks'>:>'A'>,>'for'>:>'B'>,>'geeks'>:>'C'>}> value>=> {i>for> i>in> dic>if> dic[i]>=>=>'B'>}> print>(>'key by value:'>,value)> |
>
>
Produzione:
key by value: {'for'}> Complessità temporale: SU)
Spazio ausiliario: O(1)
Metodo 2: Ottieni la chiave in base al valore utilizzando un list.index()
IL metodo indice() restituisce l'indice del valore corrispondente in una lista. L'approccio utilizzato in questo caso consiste nel trovare due elenchi separati di chiavi e valori. Quindi recupera la chiave utilizzando il file posizione del valore nella val_list. Poiché la chiave in qualsiasi posizione N in key_list avrà un valore corrispondente nella posizione N in 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])> |
>
cos'è F5 sulla tastiera?
>
Produzione:
java>
Complessità temporale: O(1)
Spazio ausiliario: O(1)
Metodo 3: Ottieni la chiave in base al valore utilizzando dict.item()
Possiamo anche recuperare la chiave da un valore abbinando tutti i valori utilizzando dict.item() e quindi stampando la chiave corrispondente al valore specificato.
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>))> |
>
>Produzione
Java C>
Complessità temporale: O(n), dove n è il numero di coppie chiave-valore nel dizionario.
Spazio ausiliario: O(1), poiché lo spazio utilizzato dalla funzione non dipende dalla dimensione del dizionario di input.
Metodo 4: utilizzo di lambda e filter()
Ecco un esempio di utilizzo della funzione filter() per ottenere la chiave corrispondente a un valore in un dizionario:
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> |
>
>Produzione
Java>
In questo esempio, la funzione filter() viene utilizzata per creare un elenco di chiavi da my_dict in cui il valore è uguale a 100. L'elenco risultante viene quindi indicizzato alla posizione 0 per ottenere il primo elemento, che è la chiave corrispondente al valore 100.
Complessità temporale: O(n) , poiché la funzione filter() deve scorrere l'intero dizionario per creare l'elenco delle chiavi.
Lo spazio ausiliario è O(n) , poiché l'elenco di chiavi creato da filter() ha una dimensione pari al numero di elementi nel dizionario.
METODO 5: Utilizzo del metodo degli oggetti
Questo codice trova la chiave di un determinato valore in un dizionario utilizzando una comprensione di elenco per scorrere gli elementi nel dizionario e verificare se il valore corrisponde al valore specificato. Se viene trovata una chiave, viene aggiunta a un elenco e il primo elemento dell'elenco viene stampato come chiave per il valore specificato. Se il valore non viene trovato nel dizionario, viene stampato un messaggio che indica che non è stato trovato.
Passaggi:
- Utilizza il metodo items del dizionario per scorrere ciascuna coppia chiave-valore in my_dict.
- Controlla se il valore associato alla chiave corrente è uguale al valore specificato.
- Se è uguale, aggiunge la chiave corrente a un elenco di chiavi.
- Se il ciclo viene completato senza trovare un valore corrispondente, stampa un messaggio che indica che il valore non è stato trovato.
- Se è stata trovata una chiave corrispondente, stampa la prima chiave nell'elenco.
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'>)> |
>
>Produzione
The key for the value 112 is Python>
Complessità temporale: O(N), dove n è il numero di coppie chiave-valore nel dizionario.
Spazio ausiliario: O(K) , dove k è il numero di chiavi che corrispondono al valore specificato.
METODO 6:Utilizzo del modulo re
Il programma utilizza il modulo re in Python per trovare la chiave in un dizionario che corrisponde a un determinato valore. Crea un modello di espressione regolare che corrisponde al valore circondato dai limiti delle parole, quindi utilizza la funzione next() per scorrere gli elementi nel dizionario e cercare un valore che corrisponda al modello. Se viene trovata una corrispondenza, il programma restituisce la chiave corrispondente.
ALGORITMO:
- Crea un modello di espressione regolare che corrisponda al valore che stiamo cercando, circondato da limiti di parole.
- Utilizza la funzione next() per scorrere gli elementi nel dizionario, cercando un valore che corrisponda al modello.
- Se viene trovata una corrispondenza, restituire la chiave corrispondente. Altrimenti, restituisci None.
Python3
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)> |
>
>Produzione
Java>
Complessità temporale: O(N), La creazione del modello di espressione regolare richiede tempo O(1). La ricerca di un valore che corrisponda al modello in ciascun elemento del dizionario richiede nel caso peggiore un tempo O(n), dove n è il numero di elementi nel dizionario. La funzione next() e l'istruzione if richiedono ciascuna tempo O(1). Pertanto, la complessità temporale complessiva del programma è O(n).
Spazio ausiliario: O(1), Il modello dell'espressione regolare e la variabile chiave richiedono ciascuno lo spazio O(1). La variabile pattern e l'espressione del generatore all'interno della funzione next() richiedono entrambe lo spazio O(1). Le variabili k e v utilizzate nell'espressione del generatore non richiedono spazio aggiuntivo, poiché vengono create come parte dell'iterazione. Pertanto, la complessità spaziale complessiva del programma è O(1).