Pobierz klucz według wartości w słowniku

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

Lub w Pythonie 3.x:

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

Zasadniczo, oddziela wartości słownika na liście, znajduje pozycję posiadanej wartości i pobiera klucz na tej pozycji.

Więcej o keys() i .values()w Pythonie 3: Python: najprostszy sposób na uzyskanie listy wartości z dict?

Jeśli chcesz mieć zarówno nazwę , jak i wiek, powinieneś używać .items(), który daje Ci krotki klucza (key, value):

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

Możesz rozpakować krotkę do dwóch oddzielnych zmiennych bezpośrednio w pętli for, a następnie dopasować wiek.

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

Więc możesz sprawdzić nazwę dla wieku, po prostu robiąc

mydict[search_age]

I ' ve been calling to mydict zamiast list Ponieważ list jest nazwą typu wbudowanego i nie powinieneś używać tej nazwy do niczego innego.

Możesz nawet uzyskać listę wszystkich osób w danym wieku w jednym wierszu:

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

Lub jeśli jest tylko jedna osoba w każdym wieku:

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

Co da ci None jeśli nie ma nikogo w takim wieku.

Wreszcie, jeśli dict jest długi i jesteś na Pythonie 2, powinieneś rozważyć użycie .iteritems() zamiast .items() Jak Cat Plus Plus w jego odpowiedzi, ponieważ nie trzeba robić kopii listy.

Pomyślałem, że byłoby interesujące wskazać, które metody są najszybsze i w jakim scenariuszu:

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

Wyniki z profile.run() dla każdej metody 100000 razy:

Metoda 1:

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

Metoda 2:

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

Metoda 3:

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

To pokazuje, że dla małego słownika metoda 1 jest najszybsza. Jest to najbardziej prawdopodobne, ponieważ zwraca pierwszy mecz, w przeciwieństwie do wszystkich meczów, takich jak Metoda 2 (Zobacz uwaga poniżej).

Co ciekawe, wykonując te same testy na dict, który mam z 2700 wpisami, otrzymuję zupełnie inne wyniki (Tym razem 10000 razy):

Metoda 1:

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

Metoda 2:

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

Metoda 3:

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

Więc tutaj Metoda 3 jest znacznie szybsza. Wystarczy pokazać, jaki rozmiar Twojego dict wpłynie na wybraną metodę.

Przypisy: Metoda 2 zwraca listę wszystkich nazw, podczas gdy metody 1 i 3 zwracają tylko pierwszą mecz. Nie brałem pod uwagę wykorzystania pamięci. Nie jestem pewien, czy Metoda 3 tworzy 2 dodatkowe listy (keys () i values ()) i zapisuje je w pamięci.

Wersja w jednej linii: (i jest starym słownikiem, p jest słownikiem odwróconym)

Wyjaśnienie: i. keys() I i.values () zwraca dwie listy zawierające odpowiednio klucze i wartości słownika. Funkcja zip ma możliwość łączenia list w celu utworzenia słownika.

Warning: to działa tylko wtedy, gdy wartości są hashable i unikalne.

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

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

Or better

{k:v for k, v in a.items() if v == 1}

lKey = [key for key, value in lDictionary.iteritems() if value == lValue][0]

Oto moje podejście do tego problemu. :) Właśnie zacząłem uczyć się Pythona, więc nazywam to:

"rozwiązanie zrozumiałe dla początkujących".

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

Możesz uzyskać klucz używając dict.keys(), dict.values() oraz list.index() metody, patrz przykłady kodu poniżej:

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

Jeśli chcesz znaleźć klucz według wartości, możesz użyć rozumienia słownika, aby utworzyć Słownik wyszukiwania, a następnie użyć go, aby znaleźć klucz z wartości.

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

Rozważ użycie pand. Jak stwierdzono w "Python for Data Analysis" Williama Mckinneya

Innym sposobem myślenia o serii jest stała długość, uporządkowana dict, ponieważ jest mapowaniem wartości indeksu do wartości danych. Może być używany w wielu kontekstach, w których można użyć dict.

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

Aby zadać pytanie wykonaj następujące czynności:

lookup_list[lookup_list.values == 19]

Co daje:

Out[1]: 
amber    19
dtype: int64

Jeśli potrzebujesz zrobić coś jeszcze z wyjściem przekształcającym odpowiedź na Listę może być użytecznym:

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

Tutaj recover_key pobiera słownik i wartość do znalezienia w słowniku. Następnie wykonujemy pętlę nad kluczami w Słowniku i dokonujemy porównania z wartością i zwracamy ten konkretny klucz.

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

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

To jest odpowiedź, ale można to zrobić za pomocą fantazyjnego "map/reduce", np.:

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

def get_Value(dic,value):
    for name in dic:
        if dic[name] == value:
            del dic[name]
            return name

get_key = lambda v, d: next(k for k in d if d[k] is v)

Oto moje zdanie na ten temat. Jest to dobre do wyświetlania wielu wyników na wszelki wypadek. Więc dodałem również listę

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)

Nie ma łatwego sposobu na znalezienie klucza na liście poprzez 'wyszukanie' wartości. Jeśli jednak znasz wartość, iterując przez klucze, możesz wyszukać wartości w słowniku za pomocą elementu. Jeśli d [element], gdzie D jest obiektem słownika, jest równy kluczowi, który próbujesz wyszukać, możesz wykonać jakiś kod.

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

Wiem, że to jest stare, ale można dość łatwo znaleźć wszystkie osoby na liście z wieku wyszukiwania za pomocą zrozumienia listy.

ages = {'george':16,'amber':19}
search = 16
print([name for (name, age) in ages.items() if age == search])

Mam nadzieję, że to pomoże...

for key in list:
   if list[key] == search_value:
       return key

Znalazłem tę odpowiedź bardzo skuteczną, ale wciąż nie bardzo łatwą do odczytania dla mnie.

Aby było to bardziej jasne, możesz odwrócić klucz i wartość słownika. Jest to make wartości kluczy i klucze wartości, jak widać TUTAJ .

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

Lub

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

Który jest zasadniczo taki sam, że ten drugi odpowiedzieć .

Spróbuj odwrócić słownik:

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

Cat Plus Plus wspomniał, że nie tak ma być używany słownik. Oto dlaczego:

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

Gdy spojrzysz w górę klucza przez to odpowiadająca wartość, zasadniczo odwracasz słownik. Ale mapowanie niekoniecznie jest odwracalne! W tym przykładzie Zapytanie o klucz odpowiadający v1 może dać k1 lub k3. Powinieneś zwrócić oba? Tylko ten pierwszy znaleziony? Dlatego indexof () jest niezdefiniowany dla słowników.

Czasami może być potrzebne 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

Musisz użyć słownika i odwrotnie tego słownika. Oznacza to, że potrzebujesz innej struktury danych. Jeśli używasz Pythona 3, Użyj modułu enum, ale jeśli używasz Pythona 2.7 użyj enum34, który jest ponownie przeniesiony dla Pythona 2.

Przykład:

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 

Już odebrano, ale skoro kilka osób wspomniało o odwróceniu słownika, oto jak to zrobić w jednej linijce (zakładając odwzorowanie 1: 1) i kilka różnych danych 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()}

Jeśli uważasz, że nie jest 1: 1, nadal możesz utworzyć rozsądne odwzorowanie odwrotne z kilkoma liniami:

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

Jak wolno to jest: wolniej niż proste wyszukiwanie, ale nie tak wolno, jak myślisz - na "prostym" słowniku wpisów 100000, "szybko" wyszukiwanie (tzn. szukanie wartości, która powinna znajdować się na początku klawiszy) było około 10x szybsze niż cofanie całego słownika, a "powolne" wyszukiwanie (pod koniec) około 4-5x szybsze. Więc po co najwyżej około 10 przeglądach, to się opłaca.

Druga wersja (z listami na element) zajmuje około 2,5 x tyle, ile wersja prosta.

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

Również miał kilka ciekawych wyników z ifilter. Teoretycznie ifilter powinien być szybszy, ponieważ możemy użyć itervalues () i prawdopodobnie nie trzeba utworzyć / przejść przez całą listę wartości. W praktyce wyniki były... dziwne...

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

Więc, dla małych przesunięć, był znacznie szybszy niż jakakolwiek poprzednia wersja (2.36 *u*S vs.minimum 1.48 *m*S dla poprzednich przypadków). Jednak w przypadku dużych przesunięć pod koniec listy było to znacznie wolniejsze (15,1 ms vs. to samo 1,48 mS). Małe oszczędności na niskim końcu nie są warte kosztów na wysokim końcu, imho.

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

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

Wyjście jest następujące:

-> prints george

W ten sposób uzyskujesz dostęp do słownika, aby robić to, co chcesz:

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

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

Jeszcze lepiej:

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

Oto rozwiązanie, które działa zarówno w Pythonie 2, jak i Pythonie 3:

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

Część until [search_age] tworzy słownik odwrotny (gdzie wartości są kluczami i odwrotnie). Możesz utworzyć metodę pomocniczą, która będzie buforować ten odwrócony słownik w następujący sposób:

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

Lub nawet bardziej ogólnie fabryka, która utworzyłaby metodę wyszukiwania nazw według wieku dla jednej lub więcej z twoich list

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]

Byłabyś w stanie zrobić:

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

Zauważ, że zmieniłem nazwę list na ages_by_name od pierwszy jest typem predefiniowanym.

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.

Dla wielu zdarzeń użyj:

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