Отримайте ключ за значенням у словнику

Я створив функцію, яка буде шукати віки в a Dictionaryі показувати відповідне ім'я:

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

Я знаю, як порівняти і знайти вік, я просто не знаю, як показати ім’я людини. Крім того, я отримую KeyErrorчерез рядок 5. Я знаю, що це неправильно, але я не можу зрозуміти, як змусити його шукати назад.

Немає жодної. dictне призначений для використання таким чином.

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

Або в Python 3.x:

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

По суті, він розділяє значення словника в списку, знаходить позицію у вас значення і отримує ключ у цій позиції.

Більше про keys()та .values()в Python 3: Як я можу отримати список значень із dict?

Якщо ви хочете і ім’я, і вік, вам слід скористатися, .items()що дає вам ключові (key, value)кортежі:

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

Ви можете розпакувати кортеж у дві окремі змінні прямо у forциклі, а потім відповідати віку.

Слід також розглянути можливість зміни словника, якщо ви, як правило, шукаєте за віком, і двоє людей не мають такого ж віку:

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

тож ви можете шукати ім’я на вік, просто роблячи це

mydict[search_age]

Я називав це mydictзамість того, listщо listце ім'я вбудованого типу, і ви не повинні використовувати це ім'я ні для чого іншого.

Ви навіть можете отримати список усіх людей з певним віком в одному рядку:

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

або якщо є лише одна людина з кожним віком:

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

що просто дасть вам, Noneякщо немає когось із цього віку.

Нарешті, якщо dictдовгий і ви знаходитесь на Python 2, вам слід розглянути можливість використання .iteritems()замість того, .items()як це робив Cat Plus Plus у своїй відповіді, оскільки не потрібно робити копію списку.

Я подумав, що було б цікаво вказати, які методи є найшвидшими та в якому сценарії:

Ось кілька тестів, які я пройшов (на 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)]

Результати profile.run()за кожним методом 100000 разів:

Спосіб 1:

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

Спосіб 2:

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

Спосіб 3:

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

Отже, це показує, що для малого диктату метод 1 є найшвидшим. Це, швидше за все, тому, що він повертає перший матч, на відміну від усіх матчів, як метод 2 (див. Примітку нижче).

Цікаво, що, виконуючи ті самі тести на диктант, що у мене з 2700 записами, я отримую зовсім інші результати (на цей раз пробіг 10000 разів):

Спосіб 1:

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

Спосіб 2:

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

Спосіб 3:

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

Отже, метод 3 набагато швидший. Просто буде показано, який розмір вашої картинки вплине на спосіб вибору.

Примітки: Метод 2 повертає список усіх імен, тоді як методи 1 і 3 повертають лише перше збіг. Я не вважав використанням пам'яті. Я не впевнений, чи метод 3 створює 2 додаткові списки (ключі () та значення ()) і зберігає їх у пам'яті.

версія для одного рядка: (я давній словник, p - зворотний словник)

пояснення: i.keys()і i.values()повертає два списки з ключами та значеннями словника відповідно. Функція zip має можливість зв'язати спілки для створення словника.

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

Попередження: Це буде працювати лише в тому випадку, якщо значення є доступними та унікальними.

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

або краще

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

Спробуйте цей однокласник, щоб скасувати словник:

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

Я вважав цю відповідь дуже ефективною, але не дуже простою для мене.

Щоб зробити це більш зрозумілим, ви можете перевернути ключ і значення словника. Це робиться для клавіш значень та значень клавіш, як показано тут .

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

або

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

що по суті те саме, що ця інша відповідь .

Якщо ви хочете знайти ключ за значенням, ви можете використовувати розуміння словника для створення словника пошуку, а потім використовувати його для пошуку ключа зі значення.

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

Ви можете отримати ключ, використовуючи dict.keys(), dict.values()і list.index()методи, см приклади коду нижче:

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

Ось мій погляд на цю проблему. :) Я щойно почав вивчати Python, тому називаю це:

Рішення "Зрозуміле для початківців".

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

Подумайте про використання Pandas. Як сказано в "Пітоні для аналізу даних" Вільяма Маккінні

Інший спосіб думати про серію - це фіксований розмір, упорядкований дікт, оскільки це відображення значень індексу до значень даних. Його можна використовувати в багатьох контекстах, де ви можете використовувати диктант.

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

Для запиту вашої серії виконайте такі дії:

lookup_list[lookup_list.values == 19]

Який урожай:

Out[1]: 
amber    19
dtype: int64

Якщо вам потрібно зробити що-небудь ще з результатом перетворення відповіді у список, може бути корисним:

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

Тут recovery_key бере словник і значення, яке можна знайти в словнику. Потім перебираємо ключі в словнику і проводимо порівняння зі значенням і повертаємо саме цей ключ.

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

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

ми можемо отримати Keyз dictпо:

def getKey(dct,value):
     return [key for key in dct if (dct[key] == value)]

на нього відповіли, але це можна зробити за допомогою фантазійного використання "карта / зменшення", наприклад:

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 зазначив, що словник не використовується таким чином. Ось чому:

Визначення словника є аналогічним для відображення у математиці. У цьому випадку диктант - це відображення K (набір ключів) до V (значення), але не навпаки. Якщо ви відмежуєте дік, ви очікуєте повернення рівно одного значення. Але цілком законно, щоб різні клавіші відображали одне і те ж значення, наприклад:

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

Коли ви шукаєте ключ за відповідним значенням, ви по суті перевертаєте словник. Але відображення не обов'язково є зворотним! У цьому прикладі запит ключа, що відповідає v1, може дати k1 або k3. Ви повинні повернути обидва? Просто перший знайдений? Ось чому indexof () не визначений для словників.

Якщо ви знаєте свої дані, ви могли б це зробити. Але API не може припустити, що довільний словник є зворотним, отже, відсутність такої операції.

ось моя думка про це. Це добре для відображення кількох результатів на той випадок, якщо вам потрібен. Тож я і список додав

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)

І це все...

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

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

Вихід такий:

-> prints george

Немає простого способу знайти ключ у списку, "шукаючи" значення. Однак якщо ви знаєте значення, повторюючись за допомогою клавіш, ви можете шукати значення у словнику за елементом. Якщо D [елемент], де D - об’єкт словника, дорівнює ключу, який ви намагаєтеся шукати, ви можете виконати деякий код.

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

Вам потрібно використовувати словник і зворотній бік цього словника. Це означає, що вам потрібна інша структура даних. Якщо ви перебуваєте в python 3, використовуйте enumмодуль, але якщо ви використовуєте python 2.7, використовуйте, enum34який переноситься назад для python 2.

Приклад:

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

Просто моя відповідь в lambdaі filter.

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

вже відповіли, але оскільки кілька людей згадували про перевернення словника, ось як ви це робите в одному рядку (припускаючи відображення 1: 1) та декількох різних даних про парфу:

пітон 2.6:

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

2.7+:

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

якщо ви думаєте, що це не 1: 1, ви все одно можете створити розумне зворотне відображення за допомогою пари рядків:

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

наскільки повільно це: повільніше, ніж простий пошук, але не так повільно, як ви могли б подумати - у "прямому" словнику введення 100000, "швидкому" пошуку (тобто пошуку значення, яке повинно бути на початку клавіш) було приблизно в 10 разів швидше, ніж обернення всього словника, а «повільний» пошук (до кінця) приблизно на 4-5 разів швидший. Тож, як мінімум, приблизно 10 пошукових запитів, він окупається сам.

друга версія (зі списками на предмет) займає приблизно 2,5 рази довше, ніж проста версія.

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

Також були цікаві результати з ifilter. Теоретично, ifilter повинен бути швидшим, оскільки ми можемо використовувати itervalues ​​() і, можливо, не потрібно створювати / проходити через весь список значень. На практиці результати були ... незвичайні ...

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

Так, для невеликих компенсацій це було значно швидше, ніж будь-яка попередня версія (2,36 * u * S проти мінімум 1,48 * m * S для попередніх випадків). Однак для великих компенсацій наприкінці списку це було значно повільніше (15,1 мс проти тих же 1,48 мс). Невеликі заощадження в нижньому кінці не варті витрат у найвищому кінці, imho.

Іноді може знадобитися 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

Ось рішення, яке працює як у Python 2, так і в Python 3:

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

Частина, поки не [search_age]побудує зворотний словник (де значеннями є ключі та навпаки). Ви можете створити допоміжний метод, який кешуватиме цей перевернутий словник так:

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

або ще більше загалом фабрика, яка створила б метод пошуку вікових імен для одного чи кількох списків

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]

тож ви зможете зробити:

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

Зверніть увагу , що я перейменував listв ages_by_nameтак колишній зумовлений тип.

Ось як ви отримуєте доступ до словника, щоб робити те, що ви хочете:

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

Ще краще:

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.

Для кількох випадків використовуйте:

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