blocks|key|1071833|text|没有。不要忘记，可以在任意数量的键上找到该值，包括0或大于1的键。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1071834|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

There is none. Don't forget that the value may be found on any number of keys, including 0 or more than 1.

blocks|key|1286663|text|据我所知没有，但是有一种方法是创建一个字典，用于通过键进行正常查找，另一个字典用于通过值进行反向查找。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1286664|这里有一个这样的实现的例子：|1286665|http://code.activestate.com/recipes/415903-two-dict-classes-which-can-lookup-keys-by-value-an/|offset|length|1286666|这确实意味着查找某个值的键可能会导致多个结果，这些结果可以作为一个简单的列表返回。|1286667|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|2M|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@$F|T|G|U|1|V]]|A|$]]|$1|H|3|I|5|6|7|W|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|E]]]]

There isn't one as far as I know of, one way however to do it is to create a dict for normal lookup by key and another dict for reverse lookup by value.

There's an example of such an implementation here:

<a href="http://code.activestate.com/recipes/415903-two-dict-classes-which-can-lookup-keys-by-value-an/" rel="nofollow noreferrer">http://code.activestate.com/recipes/415903-two-dict-classes-which-can-lookup-keys-by-value-an/</a>

This does mean that looking up the keys for a value could result in multiple results which can be returned as a simple list.

blocks|key|1286751|text|字典中的直通值可以是任何类型的对象，它们不能以其他方式进行散列或索引。因此，通过值查找键对于此集合类型是不自然的。任何这样的查询都只能在O(n)时间内执行。因此，如果这是一项频繁的任务，您应该寻找一些键的索引，比如Jon+sujjested，或者甚至是一些空间索引(DB或http://pypi.python.org/pypi/Rtree/+)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1286752|entityMap|0|LINK|mutability|MUTABLE|url|http://pypi.python.org/pypi/Rtree/^0|3S|Y|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Through values in dictionary can be object of any kind they can't be hashed or indexed other way. So finding key by the value is unnatural for this collection type. Any query like that can be executed in O(n) time only. So if this is frequent task you should take a look for some indexing of key like Jon sujjested or maybe even some spatial index (DB or <a href="http://pypi.python.org/pypi/Rtree/" rel="nofollow noreferrer">http://pypi.python.org/pypi/Rtree/</a> ).

blocks|key|1286843|text|在某些情况下，字典是1:1映射|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1286844|例如，|1286845|d+=+{1:+"one",+2:+"two"+...}|code-block|syntax|javascript|1286846|如果您只进行一次查找，那么您的方法是可以的。但是，如果您需要执行多个查找，则创建倒排字典会更有效|1286847|ivd+=+{v:+k+for+k,+v+in+d.items()}|1286848|如果存在具有相同值的多个键的可能性，则需要在这种情况下指定所需的行为。|1286849|如果您的Python为2.6或更早版本，则可以使用|1286850|ivd+=+dict((v,+k)+for+k,+v+in+d.items())|1286851|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

There are cases where a dictionary is a one:one mapping

Eg,

<pre><code>d = {1: "one", 2: "two" ...}
</code></pre>

Your approach is ok if you are only doing a single lookup. However if you need to do more than one lookup it will be more efficient to create an inverse dictionary

<pre><code>ivd = {v: k for k, v in d.items()}
</code></pre>

If there is a possibility of multiple keys with the same value, you will need to specify the desired behaviour in this case.

If your Python is 2.6 or older, you can use

<pre><code>ivd = dict((v, k) for k, v in d.items())
</code></pre>

blocks|key|1072035|text|您的列表理解遍历了字典的所有条目，找到所有匹配的项，然后只返回第一个键。这个生成器表达式只会根据需要进行迭代，以返回第一个值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1072036|key+=+next(key+for+key,+value+in+dd.items()+if+value+==+'value')|code-block|syntax|javascript|1072037|其中dd是字典。如果找不到匹配项，将引发StopIteration，因此您可能希望捕获该异常并返回更合适的异常，如ValueError或KeyError。|offset|length|style|CODE|1072038|entityMap^0|0|0|2|2|K|D|1L|A|1W|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|N|$]]

Your list comprehension goes through all the dict's items finding all the matches, then just returns the first key. This generator expression will only iterate as far as necessary to return the first value:

<pre><code>key = next(key for key, value in dd.items() if value == 'value')
</code></pre>

where <code>dd</code> is the dict. Will raise <code>StopIteration</code> if no match is found, so you might want to catch that and return a more appropriate exception like <code>ValueError</code> or <code>KeyError</code>.

blocks|key|1286940|text|我知道这可能会被认为是“浪费”的，但在这种情况下，我经常将键作为值记录中的一个附加列来存储：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1286941|d+=+{'key1'+:+('key1',+val,+val...),+'key2'+:+('key2',+val,+val...)+}|code-block|syntax|javascript|1286942|这是一种权衡，感觉是错误的，但它很简单而且有效，当然依赖于值是元组而不是简单的值。|1286943|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I know this might be considered 'wasteful', but in this scenario I often store the key as an additional column in the value record:

<pre><code>d = {'key1' : ('key1', val, val...), 'key2' : ('key2', val, val...) }
</code></pre>

it's a tradeoff and feels wrong, but it's simple and works and of course depends on values being tuples rather than simple values.

blocks|key|1072155|text|也许像下面的DoubleDict这样的类似字典的类就是你想要的？您可以将所提供的任何一个元类与DoubleDict结合使用，也可以完全避免使用任何元类。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1072156|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__']+%2B=+('_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))|code-block|syntax|javascript|1072157|entityMap^0|6|A|1B|A|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Maybe a dictionary-like class such as <code>DoubleDict</code> down below is what you want? You can use any one of the provided metaclasses in conjuction with <code>DoubleDict</code> or may avoid using any metaclass at all.

<pre><code>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 &amp; 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 &lt; other

 def __le__(self, other):
 return self.__forward &lt;= other

 def __eq__(self, other):
 return self.__forward == other

 def __ne__(self, other):
 return self.__forward != other

 def __gt__(self, other):
 return self.__forward &gt; other

 def __ge__(self, other):
 return self.__forward &gt;= 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) &gt; 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) &gt; 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))
</code></pre>

blocks|key|1072200|text|这个版本比yours短26%25，但功能相同，即使是冗余/不明确的值(像您的一样，返回第一个匹配项)。然而，它的速度可能是你的两倍，因为它从字典创建了两次列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1072201|key+=+dict_obj.keys()[dict_obj.values().index(value)]|code-block|syntax|javascript|1072202|或者，如果您更喜欢简洁性而不是可读性，您可以使用|1072203|key+=+list(dict_obj)[dict_obj.values().index(value)]|1072204|如果你更喜欢效率，@PaulMcGuire的approach更好。如果有许多键共享相同值，则不使用列表理解来实例化键列表，而是使用生成器来实例化，这样会更有效：|1072205|key+=+(key+for+key,+value+in+dict_obj.items()+if+value+==+'value').next()|1072206|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/q/2568673/623735|1|https://stackoverflow.com/a/2569076/623735^0|5|5|0|0|0|0|0|M|8|1|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|17|8|@]|9|@$A|18|B|19|1|1A]]|C|$]]|$1|O|3|P|5|F|7|1B|8|@]|9|@]|C|$G|H]]|$1|Q|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]|Y|$5|T|U|V|C|$W|Z]]]]

This version is 26% shorter than <a href="https://stackoverflow.com/q/2568673/623735">yours</a> but functions identically, even for redundant/ambiguous values (returns the first match, as yours does). However, it is probably twice as slow as yours, because it creates a list from the dict twice.

<pre><code>key = dict_obj.keys()[dict_obj.values().index(value)]
</code></pre>

Or if you prefer brevity over readability you can save one more character with

<pre><code>key = list(dict_obj)[dict_obj.values().index(value)]
</code></pre>

And if you prefer efficiency, @PaulMcGuire's <a href="https://stackoverflow.com/a/2569076/623735">approach</a> is better. If there are lots of keys that share the same value it's more efficient not to instantiate that list of keys with a list comprehension and instead use use a generator:

<pre><code>key = (key for key, value in dict_obj.items() if value == 'value').next()
</code></pre>

blocks|key|1287068|text|不，如果不查看所有键并检查它们的所有值，您就不能有效地执行此操作。因此，您将需要O(n)时间来完成此操作。如果你需要做许多这样的查找，你需要通过构造一个反向字典(也可以在O(n)中完成)，然后在这个反向字典中进行搜索(每次搜索平均占用O(1))来高效地完成这项工作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1287069|以下是如何从普通字典构造反向字典(它将能够进行一对多映射)的示例：|1287070|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)|code-block|syntax|javascript|1287071|例如，如果您的|1287072|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])
}|1287073|您的h_reversed将是|1287074|{
++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])
}|1287075|entityMap^0|14|4|2D|4|39|4|0|0|0|0|0|2|A|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|S|3|T|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|U|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|V|$]]

No, you can not do this efficiently without looking in all the keys and checking all their values. So you will need <code>O(n)</code> time to do this. If you need to do a lot of such lookups you will need to do this efficiently by constructing a reversed dictionary (can be done also in <code>O(n)</code>) and then making a search inside of this reversed dictionary (each search will take on average <code>O(1)</code>).

Here is an example of how to construct a reversed dictionary (which will be able to do one to many mapping) from a normal dictionary:

<pre><code>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)
</code></pre>

For example if your 

<pre><code>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])
}
</code></pre>

your <code>h_reversed</code> will be

<pre><code>{
 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])
}
</code></pre>

blocks|key|1072333|text|由于这仍然是非常相关的，谷歌的第一次点击，我只是花了一些时间弄清楚，我将发布我的(在Python+3中工作)解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1072334|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'|code-block|syntax|javascript|1072335|它将为您提供第一个匹配的值。|1072336|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Since this is still very relevant, the first Google hit and I just spend some time figuring this out, I'll post my (working in Python 3) solution:

<pre><code>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'
</code></pre>

It will give you the first value that matches.

blocks|key|1072380|text|我使用字典作为一种“数据库”，所以我需要找到一个可以重用的键。在我的例子中，如果一个键的值是None，那么我可以接受它并重用它，而不必“分配”另一个id。我只是想和大家分享一下。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1072381|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]|code-block|syntax|javascript|1072382|我喜欢这个，因为我不需要尝试捕捉任何错误，比如StopIteration或IndexError。如果有可用的密钥，那么free_id将包含一个密钥。如果没有，那么它就是None。可能不是pythonic，但我真的不想在这里使用try+...|1072383|entityMap^0|1A|4|0|0|N|D|11|A|1N|7|2C|4|35|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|N|$]]

I'm using dictionaries as a sort of "database", so I need to find a key that I can reuse. For my case, if a key's value is <code>None</code>, then I can take it and reuse it without having to "allocate" another id. Just figured I'd share it.

<pre><code>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]
</code></pre>

I like this one because I don't have to try and catch any errors such as <code>StopIteration</code> or <code>IndexError</code>. If there's a key available, then <code>free_id</code> will contain one. If there isn't, then it will simply be <code>None</code>. Probably not pythonic, but I really didn't want to use a <code>try</code> here...

blocks|key|1287251|text|制作一本反向字典|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1287252|reverse_dictionary+=+{v:k+for+k,v+in+dictionary.items()}+|code-block|syntax|javascript|1287253|如果您有很多反向查找要做|1287254|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<h3>Make a reverse dictionary</h3>

<pre><code>reverse_dictionary = {v:k for k,v in dictionary.items()} 
</code></pre>

If you have a lot of reverse lookups to do

blocks|key|1287333|text|#+oneline+solution+using+zip
>>+x+=+{'a':100,+'b':999}
>>+y+=+dict(zip(x.values(),+x.keys()))++
>>+y
{100:+'a',+999:+'b'}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1287334|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code># oneline solution using zip
&gt;&gt; x = {'a':100, 'b':999}
&gt;&gt; y = dict(zip(x.values(), x.keys())) 
&gt;&gt; y
{100: 'a', 999: 'b'}
</code></pre>

Is there any straightforward way of finding a key by knowing the value within a dictionary?

All I can think of is this:

<pre><code>key = [key for key, value in dict_obj.items() if value == 'value'][0]
</code></pre>

Inverse dictionary lookup in Python

数据库

Python

有没有什么直接的方法可以通过知道字典中的值来查找键？我所能想到的就是：key = [key for key, value in dict_obj.items() if value == 'value'][0]

问Python中的反向字典查找
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中的反向字典查找EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中的反向字典查找
EN