Schlüssel nach Wert im Wörterbuch abrufen

Question

Ich habe eine Funktion entwickelt, die die Altersangaben in einer Dictionary und zeigt den passenden Namen an:

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

Ich weiß, wie man vergleicht und das Alter findet, aber ich weiß nicht, wie man den Namen der Person anzeigt. Außerdem erhalte ich eine KeyError wegen der Zeile 5. Ich weiß, dass das nicht korrekt ist, aber ich finde nicht heraus, wie ich die Suche rückwärts durchführen kann.

Answer 1

Manchmal kann int() erforderlich sein:

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

Answer 2

Auf diese Weise können Sie auf das Wörterbuch zugreifen, um das zu tun, was Sie wollen:

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

Natürlich sind Ihre Namen so falsch, dass es aussieht, als würde ein Alter gedruckt werden, aber es wird der Name gedruckt. Da Sie mit Namen zugreifen, wird es verständlicher, wenn Sie schreiben:

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

Besser noch:

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

Answer 3

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.

Für mehrfaches Auftreten verwenden:

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

Answer 4

Mir ist klar, dass es schon lange her ist und der ursprüngliche Fragesteller wahrscheinlich keine Antwort mehr braucht, aber das sind alles keine guten Antworten, wenn Sie tatsächlich die Kontrolle über diesen Code haben. Sie verwenden einfach die falsche Datenstruktur. Dies ist eine perfekte Veranschaulichung des Anwendungsfalls für ein bidirektionales Diktat:

>>> from collections import defaultdict, UserDict
>>> class TwoWayDict(UserDict):
...     def __init__(self, *args, **kwargs):
...         super().__init__(*args, **kwargs)
...         self.val_to_keys = defaultdict(list)
...     def __setitem__(self, key, value):
...         super().__setitem__(key, value)
...         self.val_to_keys[value].append(key)
...     def get_keys_for_val(self, value):
...         return self.val_to_keys[value]
... 
>>> d = TwoWayDict()
>>> d['a'] = 1
>>> d['b'] = 1
>>> d.get_keys_for_val(1)
['a', 'b']

Erhöht den Overhead bei Einfügungen nur geringfügig, aber Sie behalten den Lookup in konstanter Zeit, nur jetzt in beide Richtungen. Sie müssen die umgekehrte Zuordnung nicht jedes Mal von Grund auf neu erstellen, wenn Sie sie benötigen. Speichern Sie sie einfach ab und greifen Sie bei Bedarf darauf zu.

Darüber hinaus sind viele dieser Antworten nicht einmal richtig, weil offensichtlich viele Personen das gleiche Alter haben können, aber sie geben nur den ersten passenden Schlüssel zurück, nicht alle.

Answer 5

Hier ist eine wirklich "Reversible Dictionary", Basierend auf Adam Acosta's Lösung, sondern erzwingen val-to-Key-Aufrufe eindeutig sein und leicht zurückgeben Schlüssel von Wert:

from collections import UserDict

class ReversibleDict(UserDict):
    def __init__(self, enforce_unique=True, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.val_to_keys = {}
        self.check_val = self.check_unique if enforce_unique else lambda x: x

    def __setitem__(self, key, value):
        self.check_val(value)
        super().__setitem__(key, value)
        self.val_to_keys[value] = key

    def __call__(self, value):
        return self.val_to_keys[value]

    def check_unique(self, value):
        assert value not in self.val_to_keys, f"Non unique value '{value}'"
        return value

Wenn Sie die Einzigartigkeit von Dictionary-Werten erzwingen wollen, stellen Sie sicher, dass Sie enforce_unique=True setzen. Um Schlüssel aus Werten zu erhalten, tun Sie einfach rev_dict(value), um Werte aus Schlüsseln aufzurufen, tun Sie einfach wie üblich dict['key'], hier ist ein Beispiel für die Verwendung:

rev_dict = ReversibleDict(enforce_unique=True)
rev_dict["a"] = 1
rev_dict["b"] = 2
rev_dict["c"] = 3
print("full dictinoary is: ", rev_dict)
print("value for key 'b' is: ", rev_dict["b"])
print("key for value '2' is: ", rev_dict(2))
print("tring to set another key with the same value results in error: ")
rev_dict["d"] = 1