Ottieni chiave per valore nel dizionario

Ho creato una funzione che cercherà secoli in a Dictionarye mostrerà il nome corrispondente:

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

So come confrontare e trovare l'età in cui non so come mostrare il nome della persona. Inoltre, sto ottenendo un a KeyErrorcausa della linea 5. So che non è corretto, ma non riesco a capire come fare una ricerca all'indietro.

Non c'è nessuno. dictnon è destinato a essere utilizzato in questo modo.

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

O in Python 3.x:

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

Fondamentalmente, separa i valori del dizionario in un elenco, trova la posizione del valore che hai e ottiene la chiave in quella posizione.

Ulteriori informazioni su keys()e .values()in Python 3: Come posso ottenere un elenco di valori da dict?

Se vuoi sia il nome che l'età, dovresti usare quello .items()che ti dà le (key, value)tuple chiave :

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

Puoi decomprimere la tupla in due variabili separate nel forciclo, quindi abbinare l'età.

Dovresti anche considerare di invertire il dizionario se generalmente guarderai per età e non ci sono due persone della stessa età:

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

così puoi cercare il nome per un'età semplicemente facendo

mydict[search_age]

L'ho chiamato mydictinvece listperché listè il nome di un tipo incorporato e non dovresti usare quel nome per nient'altro.

Puoi anche ottenere un elenco di tutte le persone con una determinata età in una riga:

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

o se esiste una sola persona per ogni età:

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

che ti darà solo Nonese non c'è nessuno con quell'età.

Infine, se dictè lungo e sei su Python 2, dovresti considerare di utilizzare .iteritems()invece di .items()Cat Plus Plus nella sua risposta, dal momento che non è necessario creare una copia dell'elenco.

Ho pensato che sarebbe interessante sottolineare quali metodi sono i più veloci e in quale scenario:

Ecco alcuni test che ho eseguito (su un MacBook Pro 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)]

Risultati profile.run()su ogni metodo 100000 volte:

Metodo 1:

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

Metodo 2:

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

Metodo 3:

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

Questo dimostra che per un piccolo dict, il metodo 1 è il più veloce. Questo è molto probabilmente perché restituisce la prima corrispondenza, a differenza di tutte le partite come il metodo 2 (vedi nota sotto).

È interessante notare che, eseguendo gli stessi test su un dict che ho con 2700 voci, ottengo risultati abbastanza diversi (questa volta eseguito 10000 volte):

Metodo 1:

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

Metodo 2:

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

Metodo 3:

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

Quindi qui, il metodo 3 è molto più veloce. Va solo a mostrare la dimensione del tuo dict influenzerà il metodo che scegli.

Note: il metodo 2 restituisce un elenco di tutti i nomi, mentre i metodi 1 e 3 restituiscono solo la prima corrispondenza. Non ho considerato l'utilizzo della memoria. Non sono sicuro che il metodo 3 crei 2 elenchi extra (chiavi () e valori ()) e li memorizzi.

versione a una riga: (io sono un vecchio dizionario, p è un dizionario invertito)

spiegazione: i.keys()e i.values()restituisce due liste rispettivamente con chiavi e valori del dizionario. La funzione zip ha la capacità di collegare elenchi per produrre un dizionario.

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

Avvertenza: funzionerà solo se i valori sono hash e unici.

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

o meglio

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

Prova questo one-liner per invertire un dizionario:

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

Ho trovato questa risposta molto efficace ma non molto facile da leggere per me.

Per rendere più chiaro è possibile invertire la chiave e il valore di un dizionario. Questo è rendere i valori delle chiavi e le chiavi dei valori, come visto qui .

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

o

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

che è essenzialmente lo stesso che questa altra risposta .

Se si desidera trovare la chiave in base al valore, è possibile utilizzare una comprensione del dizionario per creare un dizionario di ricerca e quindi utilizzarlo per trovare la chiave dal valore.

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

È possibile ottenere chiave utilizzando dict.keys(), dict.values()e list.index()metodi, consultare esempi di codice qui sotto:

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

Ecco la mia opinione su questo problema. :) Ho appena iniziato a studiare Python, quindi lo chiamo:

Soluzione "Comprensibile per i principianti".

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

Prendi in considerazione l'utilizzo di Panda. Come affermato in "Python for Data Analysis" di William McKinney

Un altro modo di pensare a una serie è come una dettatura ordinata a lunghezza fissa, in quanto è una mappatura dei valori dell'indice sui valori dei dati. Può essere utilizzato in molti contesti in cui è possibile utilizzare un dict.

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

Per eseguire una query sulle serie, procedi come segue:

lookup_list[lookup_list.values == 19]

Che produce:

Out[1]: 
amber    19
dtype: int64

Se hai bisogno di fare qualcos'altro con l'output trasformare la risposta in un elenco potrebbe essere utile:

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

Qui, recuper_key richiede il dizionario e il valore per trovare nel dizionario. Quindi eseguiamo il ciclo delle chiavi nel dizionario e facciamo un confronto con quello del valore e restituiamo quella chiave particolare.

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

siamo in grado di ottenere il Keydi dictby:

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

ha una risposta, ma potrebbe essere fatto con un uso "mappa / riduzione" elaborato, ad esempio:

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

Cat Plus Plus ha affermato che questo non è il modo in cui un dizionario deve essere utilizzato. Ecco perché:

La definizione di un dizionario è analoga a quella di una mappatura in matematica. In questo caso, un dict è una mappatura di K (l'insieme di chiavi) su V (i valori) - ma non viceversa. Se si dereference un dict, si prevede di ottenere esattamente un valore restituito. Tuttavia, è perfettamente legale che diverse chiavi mappino sullo stesso valore, ad esempio:

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

Quando cerchi una chiave in base al valore corrispondente, stai essenzialmente invertendo il dizionario. Ma una mappatura non è necessariamente invertibile! In questo esempio, la richiesta della chiave corrispondente a v1 potrebbe produrre k1 o k3. Dovresti restituire entrambi? Solo il primo trovato? Ecco perché indexof () non è definito per i dizionari.

Se conosci i tuoi dati, puoi farlo. Ma un'API non può presumere che un dizionario arbitrario sia invertibile, quindi la mancanza di tale operazione.

Ecco la mia opinione a riguardo. Questo è utile per visualizzare più risultati nel caso in cui ne abbiate bisogno. Quindi ho aggiunto anche l'elenco

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 questo è tutto ...

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

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

L'output è il seguente:

-> prints george

Non esiste un modo semplice per trovare una chiave in un elenco "cercando" il valore. Tuttavia, se si conosce il valore, scorrendo le chiavi, è possibile cercare i valori nel dizionario tramite l'elemento. Se D [elemento] in cui D è un oggetto dizionario, è uguale alla chiave che stai cercando di cercare, puoi eseguire del codice.

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

Devi usare un dizionario e il contrario di quel dizionario. Significa che hai bisogno di un'altra struttura di dati. Se sei in Python 3, usa il enummodulo ma se stai usando Python 2.7 usaenum34 back port per Python 2.

Esempio:

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

Solo la mia risposta in lambdae filter.

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

ha già ricevuto risposta, ma poiché diverse persone hanno menzionato l'inversione del dizionario, ecco come lo fai in una riga (assumendo la mappatura 1: 1) e alcuni vari dati 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 pensi che non sia 1: 1, puoi comunque creare una ragionevole mappatura inversa con un paio di righe:

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

quanto è lento: più lento di una semplice ricerca, ma non così lento come si potrebbe pensare - su un dizionario di voci 100000 "dritto", una ricerca "veloce" (cioè cercare un valore che dovrebbe essere all'inizio nelle chiavi) era circa 10 volte più veloce di invertire l'intero dizionario e una ricerca "lenta" (verso la fine) circa 4-5 volte più veloce. Quindi dopo al massimo circa 10 ricerche, viene pagato da solo.

la seconda versione (con elenchi per articolo) richiede circa 2,5 volte la versione semplice.

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

Ha avuto anche alcuni risultati interessanti con ifilter. Teoricamente, ifilter dovrebbe essere più veloce, in quanto possiamo usare itervalues ​​() e possibilmente non dover creare / scorrere l'intero elenco di valori. In pratica, i risultati sono stati ... strani ...

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

Quindi, per piccoli offset, è stato drammaticamente più veloce di qualsiasi versione precedente (2,36 * u * S contro un minimo di 1,48 * m * S per i casi precedenti). Tuttavia, per grandi offset vicino alla fine dell'elenco, è stato notevolmente più lento (15,1 ms contro gli stessi 1,48 mS). I piccoli risparmi nella fascia bassa non valgono il costo nella fascia alta, imho.

A volte può essere necessario int ():

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

Ecco una soluzione che funziona sia in Python 2 che in Python 3:

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

La parte fino a quando non [search_age]costruisce il dizionario inverso (dove i valori sono chiavi e viceversa). È possibile creare un metodo di supporto che memorizzerà nella cache questo dizionario invertito in questo modo:

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

o ancora più in generale una fabbrica che creerebbe un metodo di ricerca per nome per età per uno o più dei tuoi elenchi

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]

così saresti in grado di fare:

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

Si noti che ho rinominato listin ages_by_namequanto il primo è un tipo predefinito.

Ecco come accedi al dizionario per fare quello che vuoi:

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

ovviamente, i tuoi nomi sono così spenti che sembra che stiano stampando un'età, ma stampa il nome. Dato che accedi per nome, diventa più comprensibile se scrivi:

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

Meglio ancora:

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.

Per più occorrenze utilizzare:

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