Hice una función que va a buscar las edades en un Dictionary y mostrar la coincidencia de nombre de:

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 yo no sé cómo mostrar el nombre de la persona. Además, me estoy haciendo un KeyError porque de la línea 5. Sé que no es correcto pero no puedo averiguar cómo hacer que la búsqueda hacia atrás.

InformationsquelleAutor user998316 | 2011-11-05

33 Comentarios

  1. 474

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

    for name, age in dictionary.items():    # for name, age in dictionary.iteritems():  (for Python 2.x)
        if age == search_age:
            print(name)
    • En Python 3.x list.items() en lugar de list.iteritems() debe ser utilizado
    • No estoy de acuerdo… agf la respuesta de abajo es más constructivo. Un perfectamente razonable en caso de uso no es «no deseados» (lista de comprensión ajusta a un caso de uso, de todos modos). Un dict puede ser por varias cosas en diferentes momentos, las claves y los valores tienen un significado claro, por supuesto, pero «dict elementos con un valor dado» es perfectamente razonable petición. La recomendación de uso de una lista de pares sería descartar el contexto en el que un elemento es un ‘definición » de los otros, por ejemplo, en las listas de parámetros…
  2. 502
    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, se separa el diccionario de valores en una lista, se encuentra la posición del valor que tienen, y se pone la llave en esa posición.

    Más acerca de keys() y .values() en Python 3: Python: forma más sencilla de obtener la lista de valores de dict?

    • Se ve muy bien pero es que funciona siempre? Quiero decir, ¿list.keys() y list.values() funciones generar elementos en el mismo orden?
    • Sí, que están garantizados para ser coherente. Además, el fin es la garantía de que no cambio a través de iteraciones mientras que el diccionario no es modificado.
    • Esto parece ser una buena solución, pero el índice de dio sólo un valor a la derecha, así que si usted ve múltiples valores iguales, entonces debe devolver varias teclas a la derecha ?
    • Las teclas() no pueden ser ordenadas según los valores de() siempre
    • ¿Tiene usted alguna prueba de copia de seguridad de su declaración?
    • href=»https://docs.python.org/3/library/stdtypes.html#dict-views» >docs.python.org/3/library/stdtypes.html#dict-views, «Si las teclas, los valores y los elementos vistas son iterado con no intervenir modificaciones en el diccionario, el orden de los elementos se corresponden directamente.»
    • Muy bien, gracias. He comprobado la misma sección de la documentación y también se aplica a 2.7. La promesa es que todavía hay en 2.6, aunque formulada de manera ligeramente diferente… suena como en 2.6 la promesa sólo se aplica a CPython, y no a otras implementaciones de Python.
    • Esta solución funcionó muy bien para mí en una instancia donde yo sabía que sólo una de las claves podría tener el valor en cuestión, sin embargo, si varios valores existen, devolverá uno de ellos. (P 2.6)
    • Todavía realiza un costoso bucle bajo el capó; el bucle sólo que está oculta en el interior de la index método.
    • sí, siempre funcionará. incluso yo también tenía la misma duda, pero después de leer esto – stackoverflow.com/questions/15479928/… todo se vuelve claro.
    • Es una forma elegante pero una pregunta: ¿y si los valores son únicos, pero todavía incluye a mi ‘palabra clave’. imagina un diccionario con el ‘orden’ y ‘suborden de los valores y estoy buscando el «orden» mediante la búsqueda en el diccionario.los valores de(). Obtengo la clave relevantes mediante el uso de ur método o cualquiera de ellos?

  3. 225

    Si quieres el nombre y la edad, usted debe utilizar .items() que le da la clave de (key, value) tuplas:

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

    Puede desempaquetar la tupla en dos variables independientes a la derecha en la for bucle, a continuación, coincide con la edad.

    Usted debería considerar también la posibilidad de revertir el diccionario si usted está por lo general va a estar mirando por la edad, y no hay dos personas tienen la misma edad:

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

    así que usted puede buscar el nombre de una era solo por hacer

    mydict[search_age]

    He estado llamando mydict en lugar de list porque list es el nombre de un tipo integrado, y usted no debería usar ese nombre para otra cosa.

    Usted puede incluso 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 sólo hay una persona a cada edad:

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

    que simplemente le dan None si no hay nadie con esa edad.

    Finalmente, si el dict es largo y está en Python 2, usted debe considerar el uso de .iteritems() en lugar de .items() como Cat Plus Plus hizo en su respuesta, ya que no necesita hacer una copia de la lista.

    • Correcto, pero si vas a hacer búsqueda lineal, que bien podría sustituir a la dict con una lista de pares.
    • A menos que su costumbre de acción está buscando las edades, hasta por su nombre, en cuyo caso se dict tiene sentido.
    • Parece peculiar de asumir que sólo hay una persona a cada edad, mientras que por otro lado, es completamente lógico que cada persona tenga una sola edad.
  4. 62

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

    He aquí algunas pruebas me encontré (en el 2012 MacBook Pro)

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

    Así que esto demuestra que para un pequeño dict, el método 1 es el más rápido. Esto es más probable, ya que devuelve el primer partido, frente a todos los partidos como el método 2 (véase la nota más abajo).


    Curiosamente, la realización de las mismas pruebas en un diccionario que tengo con 2700 entradas, puedo obtener resultados muy diferentes (esta vez de ejecutar 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

    Así que aquí, el método 3 es mucho más rápido. Solo se va a mostrar el tamaño de su dict afectará el método que usted elija.

    Notas:
    Método 2 devuelve una lista de todos nombres, mientras que los métodos 1 y 3 devolver sólo el primer partido.
    No he considerado el uso de la memoria. No estoy seguro de si el método 3 crea 2 extra (listas de las teclas() y los valores()) y los almacena en la memoria.

    • Sólo una actualización: parece que dict.los valores de() y dict.las teclas() devuelven listas que hacen referencia a los objetos de la original dict, por lo que el método 3 es también la que utiliza menos memoria (no sólo crea dos delgadas lista de objetos que envuelven el contenido de la dicts, mientras que los otros crean iterador elementos
    • Yo sólo quería referencia a mí mismo, desplaza hacia abajo, bam, ahí los tienen. Gracias! Técnicamente, como ya se señaló método 2 no hacer exactamente lo mismo como la 1 y la 3, porque devuelve todos los partidos. sería bueno ver los resultados, por ejemplo, para volver el próximo([..]).
    • Otra nota importante para hacer es la versión de Python. Sé que algunas versiones tienen más eficiente de las implementaciones de los métodos que otros.
    • todos los métodos de uso de referencias directas a los valores y las claves, no hay memoria de ventaja a cualquiera. Excepto en Python 3 .keys() y` .values() retorno de diccionario de las opiniones, que son de peso ligero.
  5. 44

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

    explicación : yo.las teclas() y yo.los valores de() devuelve dos listas con las claves y valores del diccionario, respectivamente. El zip tiene la capacidad de unir listas para producir un diccionario.

    advertencia : Esto funciona sólo si los valores son hashable y único.

    p = dict(zip(i.values(),i.keys()))
    • Sí, esto va a funcionar: stackoverflow.com/questions/835092/…
    • este trabajo sólo cuando los valores son hashable.
    • … y cuando no hay valores duplicados.
    • Hermoso. W. r.t el comentario anterior, por supuesto, sólo funciona cuando no hay valores duplicados, pero entonces, la pregunta que inicia este hilo hace la suposición de que tenemos un uno-a-uno de la función, por lo tanto, dado que la asunción, esta es la más elegante de la respuesta por el momento.
    • la expansión en hashable valores: si sus valores son listas/conjuntos de convertir a tupla para que esto funcione (que todavía necesitan ser único).
  6. 23
    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}
    • Lo que si hay es otra de las claves que tiene el mismo valor de a? Puede ser python el camino. Pero no es una buena idea.
    • buen punto, he añadido solución que funciona con los únicos valores
  7. 19
    lKey = [key for key, value in lDictionary.iteritems() if value == lValue][0]
    • Puede también tengo una ‘persona’ en esta misma línea? Para el caso cuando mi valor no está en el diccionario valores
    • lKey = [k for k, v in lDictionary.iteritems() if v == lValue][0] or 'else-key'
  8. 11

    Probar este one-liner para revertir un diccionario:

    reversed_dictionary = dict(map(reversed, dictionary.items()))
    • cómo funcionará cuando el valor es una lista
  9. 10

    Usted puede obtener la clave mediante el uso de dict.las teclas(), dict.los valores de() y lista.index() métodos, vea 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)]
    • no uso definido search_age var en la línea siguiente… tal vez debería reemplazar value con search_age?
    • Me sale este error: ‘dict_values’ el objeto no tiene ningún atributo ‘índice’
    • podría por favor proporcionar fragmento de código que usted ha obtenido un error y de la versión de python ( también de la impresión de type(dict_values) sería útil ) ?
  10. 9

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

    «El Comprensible para principiantes» de la solución.

    #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!
  11. 9

    Si quieres encontrar la clave por el valor, usted puede usar un diccionario de comprensión para crear una búsqueda en el diccionario y, a continuación, utilizarlo para encontrar la clave del valor.

    lookup = {value: key for key, value in self.data}
    lookup[value]
    • Una aclaración podría agregarse cuando este iba y no iba a funcionar…
  12. 8

    He encontrado este respuesta muy eficaz, pero no es muy fácil de leer para mí.

    Para hacerlo más claro se puede invertir la clave y el valor de un diccionario. Esto es hacer que las teclas de los valores y las 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 el mismo que este otro respuesta.

  13. 7

    Considerar el uso de los Pandas. Como se indica en William McKinney «Python para el Análisis de Datos’

    Otra forma de pensar acerca de una Serie es como una longitud fija, ordenó
    dict, como es una asignación de valores de índice a valores de datos. Puede ser
    se utiliza en muchos contextos donde se puede utilizar un diccionario.

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

    A la consulta de su serie hacer lo siguiente:

    lookup_list[lookup_list.values == 19]

    Que los rendimientos:

    Out[1]: 
    amber    19
    dtype: int64

    Si necesita hacer nada más con la salida de la transformación de la
    respuesta en una lista que podría ser útil:

    answer = lookup_list[lookup_list.values == 19].index
    answer = pd.Index.tolist(answer)
    • Él es el creador de los pandas. Él es más comúnmente conocido como Wes, aunque.
  14. 6

    Aquí, recover_key toma diccionario y el valor a buscar en el diccionario. Luego nos bucle sobre las teclas en el diccionario y hacer una comparación con la de valor y retorno de esa clave en particular.

    def recover_key(dicty,value):
        for a_key in dicty.keys():
            if (dicty[a_key] == value):
                return a_key
  15. 4
    for name in mydict.keys():
        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
    • Mediante un bucle for y anexar es mucho más lento que una lista de comprensión y es también mayor.
  16. 3

    es contestado, pero se podría hacer con una fantasía de ‘map/reduce’ uso, 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()))
  17. 3

    aquí está mi opinión sobre ella. Esto es bueno para la visualización de varios resultados en caso de que necesite uno. Así que he añadido a la lista así

    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 todo…

  18. 3

    No hay ninguna manera fácil para encontrar una clave en una lista de ‘mirar’ el valor. Sin embargo, si se conoce el valor de la iteración a través de las teclas, usted puede buscar valores en el diccionario por el elemento. Si D[elemento] donde D es un objeto de diccionario, es igual a la clave está tratando de mirar hacia arriba, puede ejecutar el 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)
  19. 2

    Gato Plus Plus mencionó que esto no es un diccionario destinado a ser utilizado. He aquí por qué:

    La definición de un diccionario, que es análoga a la de una asignación en matemáticas. En este caso, un diccionario es una asignación de K (el conjunto de teclas) a V (de los valores) -, pero no viceversa. Si eliminar un diccionario, que se espera exactamente un valor devuelto. Pero, es perfectamente legal para los diferentes claves del mapa en el mismo valor, por ejemplo:

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

    Cuando usted mira una clave por su correspondiente valor, básicamente estás invirtiendo el diccionario. Pero una asignación no es necesariamente invertible! En este ejemplo, pidiendo la clave correspondiente a la v1 podría producir k1 o k3. Deberá usted devolver? Sólo la primera se encuentra? Es por eso que indexof() está definido para los diccionarios.

    Si usted sabe sus datos, usted podría hacer esto. Pero una API no puede asumir que un arbitrario diccionario es invertible, por lo tanto la falta de este tipo de operación.

  20. 2
    d= {'george':16,'amber':19}
    
    dict((v,k) for k,v in d.items()).get(16)

    El resultado es como sigue:

    -> prints george
    • [k, k, v in d.los elementos() si v==16]
  21. 2

    Necesita usar un diccionario y el reverso de ese diccionario. Esto significa que usted necesita otra estructura de datos. Si usted está en python 3, uso enum módulo, pero si usted está usando python 2.7 uso enum34 que atrás está adaptada 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 
  22. 2

    Espero que esto pueda ayudar…

    for key in list:
       if list[key] == search_value:
           return key
  23. 2

    podemos obtener la Key de dict por :

    def getKey(dict,value):
         return [key for key in dict.keys() if (dict[key] == value)]
  24. 1

    ya se han respondido, pero ya que varias de las personas mencionadas revertir el diccionario, aquí te explicamos cómo hacerlo en una sola línea (suponiendo asignación 1:1) y algunos de varios perf datos:

    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 usted piensa que no es 1:1, todavía puede crear una razonable correlación inversa con un par de líneas:

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

    lo lento que es este: más lento que una simple búsqueda, pero no tan lento como se podría pensar – en un ‘derecho’ 100000 entrada de diccionario, un «rápido» de búsqueda (es decir, buscando un valor que deben ser las primeras en las teclas) fue de alrededor de 10 veces más rápido que revertir todo el diccionario, y un ‘lento’ de búsqueda (hacia el final) de alrededor de 4-5 veces más rápido. Así que después de que en la mayoría de los cerca de 10 búsquedas, es pagado por sí mismo.

    la segunda versión (con listas por elemento) toma alrededor de 2.5 x mientras 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 había algunos resultados interesantes con ifilter. Teóricamente, ifilter debe ser más rápido, en el que podemos utilizar itervalues() y posiblemente no tendrá que crear o ir a través de toda la lista de valores. En la práctica, los resultados fueron… extraño…

    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

    Así, para pequeños desplazamientos, era mucho más rápido que cualquier versión anterior (2.36 *u*S frente a un mínimo de 1.48 *m*S para que en los casos anteriores). Sin embargo, para grandes desplazamientos cerca del final de la lista, que era considerablemente más lento (15.1 ms vs el mismo 1.48 mS). El pequeño ahorro en el extremo bajo que no vale la pena el costo en el extremo superior, en mi humilde opinión.

    • Mi mayor deseo es (reversedict = defaultdict(lista) reversedict[valor].append(clave) para el valor de clave, en largedict.iteritems()] ) para trabajar, pero el uso de Python 2.7.3, me da error de sintaxis en la palabra ‘para’
    • es que lo que has escrito? falta un [ en ella, si es que. de lo contrario, asegúrese de que está en dos líneas, o poner un ; entre ellos si no lo es.
  25. 1

    A veces int() puede ser necesaria:

    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
  26. 1

    Esta es la forma de acceder al diccionario para hacer lo que quieres:

    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 son así, parece que sería la impresión de una edad, pero imprime el nombre. Desde que se accede por su nombre, se hace más comprensible si se escribe:

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

    Mejor aún:

    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
  27. 1
    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 varias apariciones uso:

    keys = [filter( lambda x: dictionary[x] == k  , dictionary )]
    • *** NameError: global name 'dictionary' is not defined
    • filter( lambda x, dictionary=dictionary, search_age=int(search_age): dictionary[x] == search_age , dictionary )
  28. 1

    Traté de leer tantas soluciones como puedo evitar dar duplicado respuesta. Sin embargo, si usted está trabajando en un diccionario de cuáles son los valores que figuran en las listas y si usted desea conseguir las llaves que tienen un elemento en particular que usted podría hacer esto:

    d = {'Adams': [18, 29, 30],
         'Allen': [9, 27],
         'Anderson': [24, 26],
         'Bailey': [7, 30],
         'Baker': [31, 7, 10, 19],
         'Barnes': [22, 31, 10, 21],
         'Bell': [2, 24, 17, 26]}

    Ahora permite buscar nombres que tienen 24 en sus valores.

    for key in d.keys():    
        if 24 in d[key]:
            print(key)

    Esto funciona con múltiples valores.

  29. 1

    Sólo mi respuesta en lambda y filter.

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

    Aquí es una solución que funciona tanto en Python 2 y Python 3:

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

    La pieza, hasta que [search_age] construye el diccionario inverso (donde los valores son claves y vice-versa).
    Usted podría crear un método auxiliar que se caché de esto invierte el diccionario como:

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

    o más en general de una fábrica que iba a crear un por-edad nombre de método de búsqueda de una o más listas de

    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]

    así que usted sería capaz de hacer:

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

    Tenga en cuenta que he cambiado el nombre de list a ages_by_name puesto que el primero es un tipo predefinido.

  31. 0

    Una manera simple de hacer esto podría ser:

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

    Esto devolverá una lista de las teclas con el valor que coincida con search_age. También puede reemplazar «list==search_age» con las demás condiciones de la declaración, si es necesario.

Dejar respuesta

Please enter your comment!
Please enter your name here