Inverse de la recherche dans le dictionnaire en Python

Est-il un moyen simple de trouver une clé en connaissant la valeur dans un dictionnaire?

Tout ce que je peux penser, c'est ceci:

key = [key for key, value in dict_obj.items() if value == 'value'][0]

double possible: stackoverflow.com/questions/483666/...
jetez un oeil à ma réponse comment construire un dictionnaire inversé
Google m'a guidé ici... Et je dois dire.. pourquoi pas une aide iteritems que pour moi cela fait une 40x plus rapide de différence... à l'aide de la ().méthode suivante
Si vous avez beaucoup de recherches inversées à faire: reverse_dictionary = {v:k for k,v in dictionary.items()}

InformationsquelleAutor RadiantHex | 2010-04-02

dictionary python

16

Il n'y a aucun. N'oubliez pas que la valeur peut être trouvé sur un certain nombre de clés, y compris 0 ou supérieur à 1.
- python a un .méthode de l'indice sur les listes de l'retourne le premier indice de la valeur spécifiée ou une exception si elle ne trouve pas... aucune raison pourquoi une telle sémantique ne peut pas être appliquée à des dictionnaires?
- Les dictionnaires ne sont pas commandés, comme le définit. Regardez les collections.OrderedDict pour une mise en œuvre que est commandés.
- .l'indice ne doit garantir qu'il renvoie une valeur unique et il n'a pas besoin d'être lexicalement premier seulement qu'il sera le premier match et qu'il a un comportement stable (plusieurs appels sur la même dict au fil du temps devraient rapporter le même élément correspondant). À moins que les dictionnaires de réorganiser leur non modifié hachages plus de temps que d'autres éléments sont ajoutés, supprimés ou modifiés il fonctionne encore correctement. Une implémentation naïve: dictObject.les éléments().index(clé)
- le point de essentiellement de .index (), c'est que, par définition, nous ne nous soucions pas des doublons seulement que nous pouvons regarder d'un seul élément de manière cohérente
- Lorsque les valeurs sont uniques, @plaques de réponse devrait bien fonctionner.
- j'ai horreur des non-réponses comme ceci. "Arrêter d'essayer de faire ce que vous avez à juste titre veux faire!" est pas une réponse acceptable. Pourquoi en était-il accepté? Comme une note plus élevée à cette question des réponses attestent, l'inverse de recherche dans le dictionnaire est carrément faisable en moins de 80 caractères de pur Python. Il ne peut pas faire plus "bourrin" que cela. Paul McGuiredu solution c'est probablement la plus efficace, mais ils tous de travail. </sigh>
InformationsquelleAutor Ignacio Vazquez-Abrams
76

Votre liste de compréhension passe par tous les dict éléments de trouver tous les matchs, puis retourne juste la première clé. Ce générateur d'expression ne itérer autant que nécessaire pour revenir à la première valeur:
```
key = next(key for key, value in dd.items() if value == 'value')
```
où dd est le dict. Va augmenter StopIteration si aucune correspondance n'est trouvée, de sorte que vous pouvez attraper et retourner un plus approprié d'exception comme ValueError ou KeyError.
- Oui Il devrait probablement augmenter même exception que listObject.index(clé) lorsque la clé n'est pas dans la liste.
- aussi keys = { key for key,value in dd.items() if value=='value' } pour obtenir l'ensemble de toutes les clés si plusieurs matchs.
- pas de réel besoin de retourner la présente comme un ensemble, dict clés déjà être unique, il suffit de retourner une liste ou mieux, de retour d'un générateur d'expression, et l'appelant de la mettre dans tout ce conteneur qu'ils veulent.
InformationsquelleAutor PaulMcG
46

Il y a des cas où un dictionnaire est un:une cartographie

Par exemple,
```
d = {1: "one", 2: "two" ...}
```
Votre approche est ok si vous ne faites que d'une seule recherche. Toutefois, si vous avez besoin de faire plus d'une recherche, il sera plus efficace de créer un dictionnaire inverse
```
ivd = {v: k for k, v in d.items()}
```
Si il y a une possibilité de plusieurs touches avec la même valeur, vous aurez besoin de spécifier le comportement souhaité dans ce cas.

Si votre Python 2.6 ou plus, vous pouvez utiliser
```
ivd = dict((v, k) for k, v in d.items())
```
- Belle optimisation. Mais, je pense que vous dans le but de transformer votre liste de 2-tuples dans un dictionnaire à l'aide de dict(): ivd=dict([(v,k) for (k,v) in d.items()])
- Cela fonctionne tant que toutes les valeurs sont hashable.
- il suffit d'utiliser un dict compréhension au lieu de la compréhension de liste: invd = { v:k for k,v in d.items() }
- merci je l'ai changé pour un dict compréhension
- dict interprétations n'ont pas été migré vers la version 2.6 de Python, donc si vous voulez rester portable, vous aurez besoin de mettre en place avec les 6 caractères supplémentaires pour les dict() autour d'un générateur de 2-tuples ou une compréhension de liste de 2-tuples
- J'ai ajouté à ma réponse.
InformationsquelleAutor John La Rooy
30

Cette version est 26% plus courte que la vôtre mais fonctionne de manière identique, même pour redondante/valeurs ambiguës (renvoie le premier match, comme la vôtre n'). Cependant, il est probablement deux fois plus lent que le vôtre, car il crée une liste à partir du dict deux fois.
```
key = dict_obj.keys()[dict_obj.values().index(value)]
```
Ou si vous préférez la brièveté plus de lisibilité, vous pouvez enregistrer un caractère de plus avec
```
key = list(dict_obj)[dict_obj.values().index(value)]
```
Et si vous préférez l'efficacité, @PaulMcGuire de approche est mieux. Si il y a beaucoup de touches qui partagent la même valeur, il est plus efficace de ne pas instancier la liste des clés de compréhension de liste et d'utiliser plutôt l'utilisation d'un générateur:
```
key = (key for key, value in dict_obj.items() if value == 'value').next()
```
- C'est une vraie réponse à la question.
- En supposant une opération atomique, sont les clés et les valeurs de la garantie d'être dans le même ordre correspondant?
- Oui, dict.keys() et dict.values() sont garantis correspondent aussi longtemps que le dict n'est pas muté entre les appels.
InformationsquelleAutor hobs

Peut-être un dictionnaire-comme la classe, comme DoubleDict en bas, est ce que vous voulez? Vous pouvez utiliser l'un quelconque des metaclasses en conjonction avec DoubleDict ou peut éviter d'utiliser tout métaclasse à tous.

import functools
import threading
################################################################################
class _DDChecker(type):
def __new__(cls, name, bases, classdict):
for key, value in classdict.items():
if key not in {'__new__', '__slots__', '_DoubleDict__dict_view'}:
classdict[key] = cls._wrap(value)
return super().__new__(cls, name, bases, classdict)
@staticmethod
def _wrap(function):
@functools.wraps(function)
def check(self, *args, **kwargs):
value = function(self, *args, **kwargs)
if self._DoubleDict__forward != \
dict(map(reversed, self._DoubleDict__reverse.items())):
raise RuntimeError('Forward & Reverse are not equivalent!')
return value
return check
################################################################################
class _DDAtomic(_DDChecker):
def __new__(cls, name, bases, classdict):
if not bases:
classdict['__slots__'] += ('_DDAtomic__mutex',)
classdict['__new__'] = cls._atomic_new
return super().__new__(cls, name, bases, classdict)
@staticmethod
def _atomic_new(cls, iterable=(), **pairs):
instance = object.__new__(cls, iterable, **pairs)
instance.__mutex = threading.RLock()
instance.clear()
return instance
@staticmethod
def _wrap(function):
@functools.wraps(function)
def atomic(self, *args, **kwargs):
with self.__mutex:
return function(self, *args, **kwargs)
return atomic
################################################################################
class _DDAtomicChecker(_DDAtomic):
@staticmethod
def _wrap(function):
return _DDAtomic._wrap(_DDChecker._wrap(function))
################################################################################
class DoubleDict(metaclass=_DDAtomicChecker):
__slots__ = '__forward', '__reverse'
def __new__(cls, iterable=(), **pairs):
instance = super().__new__(cls, iterable, **pairs)
instance.clear()
return instance
def __init__(self, iterable=(), **pairs):
self.update(iterable, **pairs)
########################################################################
def __repr__(self):
return repr(self.__forward)
def __lt__(self, other):
return self.__forward < other
def __le__(self, other):
return self.__forward <= other
def __eq__(self, other):
return self.__forward == other
def __ne__(self, other):
return self.__forward != other
def __gt__(self, other):
return self.__forward > other
def __ge__(self, other):
return self.__forward >= other
def __len__(self):
return len(self.__forward)
def __getitem__(self, key):
if key in self:
return self.__forward[key]
return self.__missing_key(key)
def __setitem__(self, key, value):
if self.in_values(value):
del self[self.get_key(value)]
self.__set_key_value(key, value)
return value
def __delitem__(self, key):
self.pop(key)
def __iter__(self):
return iter(self.__forward)
def __contains__(self, key):
return key in self.__forward
########################################################################
def clear(self):
self.__forward = {}
self.__reverse = {}
def copy(self):
return self.__class__(self.items())
def del_value(self, value):
self.pop_key(value)
def get(self, key, default=None):
return self[key] if key in self else default
def get_key(self, value):
if self.in_values(value):
return self.__reverse[value]
return self.__missing_value(value)
def get_key_default(self, value, default=None):
return self.get_key(value) if self.in_values(value) else default
def in_values(self, value):
return value in self.__reverse
def items(self):
return self.__dict_view('items', ((key, self[key]) for key in self))
def iter_values(self):
return iter(self.__reverse)
def keys(self):
return self.__dict_view('keys', self.__forward)
def pop(self, key, *default):
if len(default) > 1:
raise TypeError('too many arguments')
if key in self:
value = self[key]
self.__del_key_value(key, value)
return value
if default:
return default[0]
raise KeyError(key)
def pop_key(self, value, *default):
if len(default) > 1:
raise TypeError('too many arguments')
if self.in_values(value):
key = self.get_key(value)
self.__del_key_value(key, value)
return key
if default:
return default[0]
raise KeyError(value)
def popitem(self):
try:
key = next(iter(self))
except StopIteration:
raise KeyError('popitem(): dictionary is empty')
return key, self.pop(key)
def set_key(self, value, key):
if key in self:
self.del_value(self[key])
self.__set_key_value(key, value)
return key
def setdefault(self, key, default=None):
if key not in self:
self[key] = default
return self[key]
def setdefault_key(self, value, default=None):
if not self.in_values(value):
self.set_key(value, default)
return self.get_key(value)
def update(self, iterable=(), **pairs):
for key, value in (((key, iterable[key]) for key in iterable.keys())
if hasattr(iterable, 'keys') else iterable):
self[key] = value
for key, value in pairs.items():
self[key] = value
def values(self):
return self.__dict_view('values', self.__reverse)
########################################################################
def __missing_key(self, key):
if hasattr(self.__class__, '__missing__'):
return self.__missing__(key)
if not hasattr(self, 'default_factory') \
or self.default_factory is None:
raise KeyError(key)
return self.__setitem__(key, self.default_factory())
def __missing_value(self, value):
if hasattr(self.__class__, '__missing_value__'):
return self.__missing_value__(value)
if not hasattr(self, 'default_key_factory') \
or self.default_key_factory is None:
raise KeyError(value)
return self.set_key(value, self.default_key_factory())
def __set_key_value(self, key, value):
self.__forward[key] = value
self.__reverse[value] = key
def __del_key_value(self, key, value):
del self.__forward[key]
del self.__reverse[value]
########################################################################
class __dict_view(frozenset):
__slots__ = '__name'
def __new__(cls, name, iterable=()):
instance = super().__new__(cls, iterable)
instance.__name = name
return instance
def __repr__(self):
return 'dict_{}({})'.format(self.__name, list(self))

OVERKILL! (J'aime!)

InformationsquelleAutor Noctis Skytower

5

Puisque c'est encore très pertinent, le premier Google a frappé et je viens de passer un peu de temps à essayer de comprendre cela, je vais poster mon (travail en Python 3) solution:
```
testdict = {'one'   : '1',
'two'   : '2',
'three' : '3',
'four'  : '4'
}
value = '2'
[key for key in testdict.items() if key[1] == value][0][0]
Out[1]: 'two'
```
Il vous donnera la première valeur qui correspond à.

InformationsquelleAutor Freek
2

Il n'y a pas pour autant que je sache, d'une manière toutefois à faire est de créer un dict normal de la recherche par clé et un autre dict pour la recherche inversée par valeur.

Il y a un exemple d'une telle mise en œuvre ici:

http://code.activestate.com/recipes/415903-two-dict-classes-which-can-lookup-keys-by-value-an/

Cela signifie que la recherche les clés pour une valeur pourrait aboutir à plusieurs résultats qui peuvent être retournés comme une simple liste.
- Notez qu'il y a beaucoup, beaucoup de valeurs qui ne sont pas des clés valides.
InformationsquelleAutor Jon
2

Non, vous ne pouvez pas le faire efficacement sans regarder à toutes les touches et de la vérification de toutes leurs valeurs. Vous aurez donc besoin de O(n) temps pour ce faire. Si vous avez besoin de faire beaucoup de ces recherches, vous aurez besoin pour ce faire de manière efficace par la construction d'un dictionnaire inversé (peut être fait aussi dans O(n)) et ensuite faire une recherche à l'intérieur de ce dictionnaire inversé (chaque recherche prendra en moyenne O(1)).

Voici un exemple de la façon de construire un dictionnaire inversé (qui sera en mesure de le faire un à plusieurs mapping) à partir d'un dictionnaire:
```
for i in h_normal:
for j in h_normal[i]:
if j not in h_reversed:
h_reversed[j] = set([i])
else:
h_reversed[j].add(i)
```
Par exemple, si votre
```
h_normal = {
1: set([3]), 
2: set([5, 7]), 
3: set([]), 
4: set([7]), 
5: set([1, 4]), 
6: set([1, 7]), 
7: set([1]), 
8: set([2, 5, 6])
}
```
votre h_reversed sera
```
{
1: set([5, 6, 7]),
2: set([8]), 
3: set([1]), 
4: set([5]), 
5: set([8, 2]), 
6: set([8]), 
7: set([2, 4, 6])
}
```
InformationsquelleAutor Salvador Dali
0

À travers des valeurs dans le dictionnaire peut être l'objet de quelque nature qu'ils ne peuvent pas être haché ou indexé autre manière. Afin de trouver la clé par la valeur n'est pas naturel pour ce type de collection. Toute requête qui peut être exécuté en O(n) fois seulement. Donc, si c'est fréquent tâche, vous devez prendre un coup d'oeil pour certains d'indexation de clé comme Jon sujjested ou peut-être même certains d'index spatial (DB ou http://pypi.python.org/pypi/Rtree/ ).

InformationsquelleAutor Odomontois
0

Je sais que cela peut être considéré comme "gaspillage", mais dans ce scénario, j'ai souvent stocker la clé comme une colonne supplémentaire dans la valeur record:
```
d = {'key1' : ('key1', val, val...), 'key2' : ('key2', val, val...) }
```
c'est un compromis et se sent mal, mais c'est simple et fonctionne et bien sûr, dépend des valeurs de n-uplets, plutôt que de simples valeurs.
- en supposant que je fais cela, pouvez-vous expliquer comment cela va m'aider en faisant une recherche inversée?
InformationsquelleAutor CarlS
0

Je suis en utilisant les dictionnaires comme une sorte de "base de données", j'ai donc besoin de trouver une clé que je peux réutiliser. Pour mon cas, si une valeur de clé est None, alors je peux le prendre et de le réutiliser sans avoir à "attribuer" un autre id. Juste pensé que je devais le partager.
```
db = {0:[], 1:[], ..., 5:None, 11:None, 19:[], ...}
keys_to_reallocate = [None]
allocate.extend(i for i in db.iterkeys() if db[i] is None)
free_id = keys_to_reallocate[-1]
```
Je l'aime parce que je n'ai pas à essayer d'attraper les erreurs comme StopIteration ou IndexError. Si il y a une clé disponible, free_id contient une. Si il n'y en a pas, alors il sera simplement None. Probablement pas pythonic, mais je n'avais vraiment pas envie d'utiliser un try ici...

InformationsquelleAutor Zizouz212
0

Que la valeur pourrait être inexistante dans les dict, plus pythonic et auto-documenté code serait:
```
a  # Value to search against
x = None  # Searched key
for k, v in d.items():
if v == a:
x = k
break
x  # Now contains the key or None if not found.
```
En effet dicts ne sont pas faits pour répondre à ces problématiques, si vous rencontrez ce problème sur un nouveau programme conçu par, alors vous devriez sans doute revoir votre conception.

InformationsquelleAutor Emmanuel

Créer un dictionnaire inverse. Ensuite, une recherche.

Exemple d'un livre de téléphone de recherche inversée:

normDic = {'KVOTHE':['789-2583']
,'DENNA':['987-6453']}
revDic = {'789-2583':['KVOTHE']
,'987-6453':['DENNA']}
numInput = str(input('Enter number:\n>>'))
if numInput in revDic:
print('Contact found:', revDic[numInput], numInput)

InformationsquelleAutor aused1

-3
```
key in dict.values()
```
C'est littéralement il
- instructions peu claires. "Vrai" n'est pas une clé dans le dictionnaire original.
InformationsquelleAutor Anon

Vous devez vous connecter pour publier un commentaire.