辞書の値でキーを取得

私は年齢を調べて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()Pythonの3：どのように私は辞書からの値のリストを得ることができますか？

名前と年齢の両方が必要な場合は、キータプル.items()を提供するものを使用する必要があります(key, value)。

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

forループ内でタプルを2つの別々の変数にアンパックし、年齢と一致させることができます。

一般的に年齢で検索する場合で、同じ年齢の2人がいない場合は、辞書を逆にすることも検討する必要があります。

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

そうするだけで年齢の名前を調べることができます

mydict[search_age]

は組み込み型の名前なので、mydict代わりにそれを呼び出しています。その名前を他の目的に使用しないでください。listlist

特定の年齢のすべての人のリストを1行で取得することもできます。

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

または、年齢ごとに1人しかいない場合：

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

これはNone、その年齢の人がいない場合にのみ提供されます。

最後に、dictPython 2を使用している場合は、リストのコピーを作成する必要がないため、Cat Plus Plusの回答の.iteritems()代わりに使用することを検討してください.items()。

どの方法が最も速く、どのシナリオであるかを指摘するのは興味深いと思いました。

これが私が実行したいくつかのテストです（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()各メソッドの結果は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の方がはるかに高速です。あなたのdictのサイズがあなたが選ぶ方法に影響することを示すために行きます。

注：方法2はすべての名前のリストを返しますが、方法1と3は最初の一致のみを返します。メモリ使用量は考慮していません。メソッド3が2つの追加リスト（keys（）とvalues（））を作成してメモリに保存するかどうかはわかりません。

1行バージョン：（iは古い辞書、pは逆引き辞書です）

説明：i.keys()とi.values()、それぞれ辞書のキーと値を含む2つのリストを返します。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)

パンダの使用を検討してください。William McKinneyの「Python for Data Analysis」で述べたように

Seriesを考えるもう1つの方法は、固定長の順序付けられた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

我々は得ることができるKeyの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

答えはありますが、「マップ/リデュース」という手の込んだ使い方で実現できます。例：

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（値）へのマッピングですが、その逆はありません。辞書を逆参照すると、正確に1つの値が返されることが期待されます。ただし、次のように、異なるキーを同じ値にマッピングすることは完全に合法です。

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：1マッピングを想定）といくつかのさまざまなパフォーマンスデータを示します。

python 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番目のバージョン（アイテムごとのリスト付き）は、シンプルバージョンの約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）。ただし、リストの終わり近くの大きなオフセットの場合、劇的に遅くなりました（同じ1.48ミリ秒に対して15.1ミリ秒）。ローエンドでのわずかな節約は、ハイエンドでのコストに見合うものではありません。

時々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]

または、より一般的には、1つ以上のリストの年齢別の名前検索メソッドを作成するファクトリ

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