Question

我的问题是：如何使用字典值获取字典密钥？

d={'dict2': {1: 'one', 2: 'two'}, 'dict1': {3: 'three', 4: 'four'}}

我希望获得dict2密钥的two。

感谢。

Answer 1

这是一个可以处理任意嵌套字典的递归解决方案：

>>> import collections
>>> def dict_find_recursive(d, target):
...     if not isinstance(d, collections.Mapping):
...         return d == target
...     else:
...         for k in d:
...             if dict_find_recursive(d[k], target) != False:
...                 return k
...     return False

从长远来看，它不像“反向词典”那样高效，但如果你不经常进行这种反向搜索，那可能并不重要。（请注意，您必须明确地将dict_find_recursive(d[k], target)的结果与False进行比较，否则像''这样的假密钥会导致搜索失败。实际上，即使此版本失败，如果{{1} }被用作密钥;完全通用的解决方案将使用唯一的标记False来表示错误。）

一些用法示例：

object()

如果你想颠倒任意嵌套的字典集，递归生成器就是你的朋友：

>>> d = {'dict1': {3: 'three', 4: 'four'}, 'dict2': {1: 'one', 2: 'two'}}
>>> dict_find_recursive(d, 'two')
'dict2'
>>> dict_find_recursive(d, 'five')
False
>>> d = {'dict1': {3: 'three', 4: 'four'}, 'dict2': {1: 'one', 2: 'two'}, 
         'dict3': {1: {1:'five'}, 2: 'six'}}
>>> dict_find_recursive(d, 'five')
'dict3'
>>> dict_find_recursive(d, 'six')
'dict3'

上面简单地列出了字典中不是映射的所有值。然后，您可以将每个值映射到一个键，如下所示：

>>> def dict_flatten(d):
...     if not isinstance(d, collections.Mapping):
...         yield d
...     else:
...         for value in d:
...             for item in dict_flatten(d[value]):
...                 yield item
... 
>>> list(dict_flatten(d))
['three', 'four', 'five', 'six', 'one', 'two']

这会生成一个可迭代的元组，因此不会丢失任何信息：

>>> def reverse_nested_dict(d):
...     for k in d:
...         if not isinstance(d[k], collections.Mapping):
...             yield (d[k], k)
...         else:
...             for item in dict_flatten(d[k]):
...                 yield (item, k)
...

如果您知道所有非映射值都是可清除的 - 如果您知道它们是唯一的，或者您不关心冲突 - 那么只需将生成的元组传递给>>> for tup in reverse_nested_dict(d): ... print tup ... ('three', 'dict1') ('four', 'dict1') ('five', 'dict3') ('six', 'dict3') ('one', 'dict2') ('two', 'dict2')：< / p>

dict()

Answer 2

如果你不想反转字典，这是另一种可能的解决方案：

def get_key_from_value(my_dict, v):
    for key,value in my_dict.items():
        if value == v:
            return key
    return None

>>> d = {1: 'one', 2: 'two'}
>>> get_key_from_value(d,'two')
2

Answer 3

以下将为两级示例创建反向字典：

d={'dict2': {1: 'one', 2: 'two'}, 'dict1': {3: 'three', 4: 'four'}}
r = {}
for d1 in d:
    for d2 in d[d1]:
        r[d[d1][d2]] = d1

结果：

>>> r
{'four': 'dict1', 'three': 'dict1', 'two': 'dict2', 'one': 'dict2'}

Answer 4

我不知道最好的解决方案，但有一种可能性是反转字典（以便值成为键），然后只进行正常的键查找。这将颠倒字典：

forward_dict = { 'key1': 'val1', 'key2': 'val2'}
reverse_dict = dict([(v,k) for k,v in forward_dict.items()])

所以给定“val1”，我可以这样做：

reverse_dict["val1"]

找到相应的密钥。此解决方案存在明显的问题 - 例如，如果您的值不是唯一的，那么您将丢失一些信息。

Answer 5

编写代码以反转字典（即创建一个新字典，将旧字典的值映射到旧字典的键）。
既然你似乎在处理嵌套字典，这显然会更棘手。弄清楚你需要解决问题和编写代码的最少时间（即如果你的问题只涉及dicts中的dicts而不是任何dicts，那么就不要创建一个可以任意深度嵌套的解决方案）< / p>

Answer 6

要处理嵌套字典，我会像senderle's answer状态一样处理。

但是，如果将来它不包含嵌套字典，请非常小心地进行简单的反转。根据设计，字典键是唯一的，但值不具备此要求。

如果您的多个键的值相同，则在反转字典时，您将失去除了一个之外的所有字符。而且由于字典没有排序，你可能会随意丢失不同的数据。

逆转工作示例：

>>> d={'dict1': 1, 'dict2': 2, 'dict3': 3, 'dict4': 4}
>>> rd = dict([(v,k) for k,v in d.items()])
>>> print d
{'dict4': 4, 'dict1': 1, 'dict3': 3, 'dict2': 2}

>>> print rd
{1: 'dict1', 2: 'dict2', 3: 'dict3', 4: 'dict4'}

撤消失败的示例：请注意dict4已丢失

>>> d={'dict1': 1, 'dict2': 4, 'dict3': 3, 'dict4': 4}
>>> rd = dict([(v,k) for k,v in d.items()])
>>> print d
{'dict4': 4, 'dict1': 1, 'dict3': 3, 'dict2': 4}

>>> print rd
{1: 'dict1', 3: 'dict3', 4: 'dict2'}

Answer 7

这是一个没有人想到的例子:(可以类似地使用）

raw_dict = { 'key1': 'val1', 'key2': 'val2', 'key3': 'val1' }

new_dict = {}
for k,v in raw_dict.items():
    try: new_dict[v].append(k)
    except: new_dict[v] = [k]

结果：

>>> new_dict
{'val2': ['key2'], 'val1': ['key3', 'key1']}

可能不是最好的方法，但它适用于我需要它。

在python中使用dict值获取dict键

7 个答案: