Obtener clave por valor en el diccionario

Hice una función que buscará edades en a Dictionaryy mostrará el nombre correspondiente:

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

Sé cómo comparar y encontrar la edad, pero no sé cómo mostrar el nombre de la persona. Además, recibo una respuesta a KeyErrorcausa de la línea 5. Sé que no es correcta, pero no puedo encontrar la manera de hacer que busque hacia atrás.

No hay ninguno. dictno está destinado a ser utilizado de esta manera.

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 en Python 3.x:

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

Básicamente, separa los valores del diccionario en una lista, encuentra la posición del valor que tiene y obtiene la clave en esa posición.

Más sobre keys()y .values()en Python 3: ¿Cómo puedo obtener la lista de los valores de dict?

Si quieres tanto el nombre como la edad, deberías estar usando lo .items()que te da (key, value)tuplas clave :

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

Puede descomprimir la tupla en dos variables separadas directamente en el forbucle, luego hacer coincidir la edad.

También debe considerar invertir el diccionario si generalmente va a buscar por edad, y no hay dos personas que tengan la misma edad:

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

para que puedas buscar el nombre de una edad simplemente haciendo

mydict[search_age]

Lo he estado llamando en mydictlugar de listporque listes el nombre de un tipo incorporado, y no deberías usar ese nombre para nada más.

Incluso puede obtener una lista de todas las personas con una edad determinada en una línea:

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

o si solo hay una persona con cada edad:

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

que solo te dará Nonesi no hay nadie con esa edad.

Finalmente, si dictes largo y está en Python 2, debería considerar usarlo en .iteritems()lugar de .items()como lo hizo Cat Plus Plus en su respuesta, ya que no necesita hacer una copia de la lista.

Pensé que sería interesante señalar qué métodos son los más rápidos y en qué escenario:

Aquí hay algunas pruebas que ejecuté (en una 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)]

Resultados de profile.run()cada método 100000 veces:

Método 1:

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

Método 2:

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

Método 3:

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

Esto muestra que, para un dict pequeño, el método 1 es el más rápido. Esto es muy probable porque devuelve la primera coincidencia, a diferencia de todas las coincidencias como el método 2 (ver nota a continuación).

Curiosamente, al realizar las mismas pruebas en un dict que tengo con 2700 entradas, obtengo resultados bastante diferentes (esta vez ejecutados 10000 veces):

Método 1:

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

Método 2:

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

Método 3:

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

Aquí, el método 3 es mucho más rápido. Solo muestra que el tamaño de su dict afectará el método que elija.

Notas: El método 2 devuelve una lista de todos los nombres, mientras que los métodos 1 y 3 solo devuelven la primera coincidencia. No he considerado el uso de memoria. No estoy seguro de si el método 3 crea 2 listas adicionales (claves () y valores ()) y las almacena en la memoria.

versión de una línea: (i es un diccionario antiguo, p es un diccionario inverso)

explicación: i.keys()y i.values()devuelve dos listas con claves y valores del diccionario respectivamente. La función zip tiene la capacidad de unir listas para producir un diccionario.

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

Advertencia: Esto funcionará solo si los valores son hashables y únicos.

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

o mejor

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

Pruebe esta línea para invertir un diccionario:

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

Encontré esta respuesta muy efectiva pero no muy fácil de leer para mí.

Para que quede más claro, puede invertir la clave y el valor de un diccionario. Esto es hacer que las claves sean valores y claves de valores, como se ve aquí .

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]

que es esencialmente lo mismo que esta otra respuesta .

Si desea encontrar la clave por el valor, puede usar una comprensión del diccionario para crear un diccionario de búsqueda y luego usarlo para encontrar la clave del valor.

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

Puede obtener la clave mediante el uso de dict.keys(), dict.values()y list.index()métodos, ver ejemplos de código a continuación:

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

Aquí está mi opinión sobre este problema. :) Acabo de empezar a aprender Python, así que llamo a esto:

Solución "La comprensible para principiantes".

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

Considera usar pandas. Como se indica en "Python for Data Analysis" de William McKinney

Otra forma de pensar en una Serie es como una orden ordenada de longitud fija, ya que es un mapeo de valores de índice a valores de datos. Se puede usar en muchos contextos donde puede usar un dict.

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

Para consultar su serie, haga lo siguiente:

lookup_list[lookup_list.values == 19]

Cuyos rendimientos:

Out[1]: 
amber    19
dtype: int64

Si necesita hacer algo más con la salida, puede ser útil transformar la respuesta en una lista:

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

Aquí, recovery_key toma el diccionario y el valor para buscar en el diccionario. Luego recorremos las teclas en el diccionario y hacemos una comparación con la de valor y devolvemos esa clave en particular.

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

podemos obtener el Keyde dict:

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

es respondido, pero podría hacerse con un uso elegante de 'mapa / reducir', por ejemplo:

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 mencionó que no es así como se pretende utilizar un diccionario. Este es el por qué:

La definición de un diccionario es análoga a la de un mapeo en matemáticas. En este caso, un dict es un mapeo de K (el conjunto de claves) a V (los valores), pero no al revés. Si cancela la referencia a un dict, espera obtener exactamente un valor devuelto. Pero, es perfectamente legal que diferentes claves se asignen al mismo valor, por ejemplo:

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

Cuando busca una clave por su valor correspondiente, esencialmente está invirtiendo el diccionario. ¡Pero un mapeo no es necesariamente invertible! En este ejemplo, pedir la clave correspondiente a v1 podría generar k1 o k3. ¿Deberías devolver ambos? ¿Solo el primero encontrado? Es por eso que indexof () no está definido para los diccionarios.

Si conoce sus datos, podría hacer esto. Pero una API no puede suponer que un diccionario arbitrario es invertible, de ahí la falta de dicha operación.

Aquí está mi opinión al respecto. Esto es bueno para mostrar múltiples resultados en caso de que necesite uno. Así que también agregué la lista

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)

Y eso es...

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

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

El resultado es el siguiente:

-> prints george

No hay una manera fácil de encontrar una clave en una lista 'buscando' el valor. Sin embargo, si conoce el valor, iterando a través de las claves, puede buscar valores en el diccionario por elemento. Si D [elemento] donde D es un objeto de diccionario, es igual a la clave que está intentando buscar, puede ejecutar algún código.

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

Necesita usar un diccionario y el reverso de ese diccionario. Significa que necesita otra estructura de datos. Si está en Python 3, use el enummódulo, pero si está usando Python 2.7, use enum34el puerto de vuelta para Python 2.

Ejemplo:

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 mi respuesta en lambday filter.

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

ya se ha respondido, pero dado que varias personas mencionaron invertir el diccionario, así es como lo hace en una línea (suponiendo un mapeo 1: 1) y algunos datos de rendimiento diferentes:

Python 2.6:

reversedict = dict([(value, key) for key, value in mydict.iteritems()])

2.7+:

reversedict = {value:key for key, value in mydict.iteritems()}

Si cree que no es 1: 1, aún puede crear una asignación inversa razonable con un par de líneas:

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

qué tan lento es esto: más lento que una simple búsqueda, pero no tan lento como se podría pensar: en un diccionario de entrada 100000 "directo", una búsqueda "rápida" (es decir, buscar un valor que debería estar al principio de las teclas) fue aproximadamente 10 veces más rápido que invertir todo el diccionario, y una búsqueda 'lenta' (hacia el final) aproximadamente 4-5 veces más rápido. Entonces, después de un máximo de 10 búsquedas, se paga solo.

la segunda versión (con listas por elemento) tarda aproximadamente 2.5 veces más que la versión simple.

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

También tuvo algunos resultados interesantes con ifilter. Teóricamente, ifilter debería ser más rápido, ya que podemos usar itervalues ​​() y posiblemente no tener que crear / revisar la lista completa de valores. En la práctica, los resultados fueron ... extraños ...

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

Entonces, para pequeñas compensaciones, fue dramáticamente más rápido que cualquier versión anterior (2.36 * u * S vs. un mínimo de 1.48 * m * S para casos anteriores). Sin embargo, para grandes compensaciones cerca del final de la lista, fue drásticamente más lento (15,1 ms frente a los mismos 1,48 ms). Los pequeños ahorros en el extremo inferior no valen el costo en el extremo superior, en mi humilde opinión.

A veces puede ser necesario 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

Aquí hay una solución que funciona tanto en Python 2 como en Python 3:

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

La parte hasta [search_age]construye el diccionario inverso (donde los valores son claves y viceversa). Podría crear un método auxiliar que almacenará en caché este diccionario invertido de la siguiente manera:

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

o incluso más generalmente una fábrica que crearía un método de búsqueda de nombres por edad para una o más de sus listas

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]

para que puedas hacer:

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

Tenga en cuenta que Retitulé lista ages_by_nameya que el primero es un tipo predefinido.

Así es como accede al diccionario para hacer lo que quiere:

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

por supuesto, sus nombres están tan apagados que parece que se imprimiría una edad, pero SÍ imprime el nombre. Como está accediendo por nombre, se vuelve más comprensible si escribe:

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

Mejor todavía:

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.

Para múltiples ocurrencias use:

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