사전에서 값으로 키 가져 오기

나는 나이를 찾고 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

나는 나이를 비교하고 찾는 방법을 알고 있습니다. 나는 그 사람의 이름을 보여주는 법을 모릅니다. 또한 KeyError5 행 으로 인해 문제가 발생합니다. 정확하지 않다는 것을 알고 있지만 뒤로 검색하는 방법을 알 수 없습니다.

없습니다. 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()파이썬 3 : 어떻게 딕셔너리의 값의 목록을 얻을 수 있나요?

이름 과 나이를 모두 원한다면 .items()주요 (key, value)튜플 을 제공하는 것을 사용해야합니다 .

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

for루프 에서 튜플을 두 개의 개별 변수로 압축을 풀고 연령을 일치시킬 수 있습니다.

일반적으로 나이별로 조회를하고 같은 나이를 가진 두 사람이 없다면 사전을 뒤집는 것도 고려해야합니다.

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

그래서 당신은 그냥 수행하여 나이의 이름을 찾을 수 있습니다

mydict[search_age]

내장 유형의 이름 이기 때문에 mydict대신 호출했습니다 . 다른 이름으로 사용해서는 안됩니다.listlist

주어진 나이의 모든 사람들의 목록을 한 줄에 얻을 수도 있습니다.

[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가 목록에서 사본을 만들 필요가 없으므로 Cat Plus Plus 와 달리 대신 사용 하는 것을 고려해야 합니다.

어떤 방법이 가장 빠르며 어떤 시나리오에 있는지 지적하는 것이 흥미로울 것이라고 생각했습니다.

다음은 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)]

profile.run()각 방법에 대한 결과 100,000 회 :

방법 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

따라서 이것은 작은 dict의 경우 방법 1이 가장 빠르다는 것을 보여줍니다. 방법 2와 같은 모든 일치 항목과 반대로 첫 번째 일치 항목을 반환하기 때문일 가능성이 높습니다 (아래 참고 참조).

흥미롭게도 2700 개의 항목으로 얻은 dict에 대해 동일한 테스트를 수행하면 매우 다른 결과를 얻습니다 (이번에는 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이 훨씬 빠릅니다. dict의 크기를 보여 주면 선택한 방법에 영향을 미칩니다.

참고 : 방법 2는 모든 이름 목록을 반환하는 반면 방법 1과 3은 첫 번째 일치 항목 만 반환합니다. 메모리 사용량을 고려하지 않았습니다. 방법 3이 두 개의 추가 목록 (keys () 및 values ​​())을 만들어 메모리에 저장하는지 확실하지 않습니다.

한 줄 버전 : (i는 오래된 사전, 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)]

다음은이 문제에 대한 설명입니다. :) 방금 파이썬을 배우기 시작했습니다.

"초보자를위한 이해"솔루션.

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

팬더 사용을 고려하십시오. William McKinney의 "데이터 분석을위한 파이썬"

Series를 생각하는 또 다른 방법은 인덱스 값을 데이터 값에 매핑하는 고정 길이의 순서가있는 dict입니다. dict를 사용할 수있는 많은 상황에서 사용할 수 있습니다.

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)

여기서 recover_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는 이것이 사전이 사용되는 방식이 아니라고 언급했습니다. 이유는 다음과 같습니다.

사전의 정의는 수학에서의 매핑의 정의와 유사합니다. 이 경우, dict는 K (키 세트)를 V (값)에 매핑하지만 그 반대는 아닙니다. dict을 역 참조하면 정확히 하나의 값이 리턴 될 것으로 예상됩니다. 그러나 다른 키가 동일한 값에 매핑되는 것은 완전히 합법적입니다. 예 :

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 [element] 인 경우 조회하려는 키와 같은 경우 일부 코드를 실행할 수 있습니다.

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

사전을 사용해야하며 해당 사전을 반대로 사용해야합니다. 다른 데이터 구조가 필요하다는 의미입니다. 파이썬 3 인 경우 enum모듈을 사용 하지만 파이썬 2.7을 사용 enum34하는 경우 파이썬 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.1ms vs. 동일한 1.48mS). 낮은 가격의 작은 절약은 높은 비용의 가치가 없습니다.

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