Python 如果嵌套字典中存在值，则查找键

我正在使用Python3.6，我需要在嵌套字典中循环查找指定的值是否存在，如果存在，则存储与该值对应的所有键。我还需要扩展这些条件，以便能够为指定的子字典键存储存在指定值的键

词典的构建如下所示：

dict = {A: {B: [a, b, c], C: [d, c, e]}, D: {B: [f, g, h], E: [i, j, c]}...}

每个主键（A、D等）都是唯一的，但子字典中的键在不同的子字典中重复

我想获取所有主键，其值如“c”存在，因此输出为：

foundKeys = [A, D]

foundKeys = [A]

我还想为子字典键添加条件，例如，为“B”子字典键获取所有存在“c”的主键。这里的输出是：

foundKeys = [A, D]

foundKeys = [A]

关于第一个条件，我提出了以下代码：

myList = list(dict.keys())

foundKeys = []

for i in range(0,len(myList)):
    tmpList = list(dict.get(myList[i],{}).values())
    for j in range(0, len(tmpList)):
        for k in range(0, len(tmpList[j])):
            if "c" in tmpList[j][k]:
                if myList[i] not in foundKeys:
                    foundKeys.append(myList[i])

这使我能够得到所有具有相应值“c”（[a，D]）的键的列表，但我有一个很大的数据集，我意识到可能有更好的方法来处理这个问题

我可以修改此代码以添加子字典键条件并获得输出[A]，但运行它需要更多时间

---

我是Python新手，仍在学习如何优化。您能告诉我如何处理大型数据集时更好地处理它吗？

您可以使用内置的

.keys（）

和

.values（）

分别直接获取键和值

代码：

dict = {'A': {'B': ['a', 'b', 'c'], 'C': ['d', 'c', 'e']}, 'D': {'B': ['f', 'g', 'h'], 'E': ['i', 'j', 'c']}}

listOfKeys = []
for i in dict.keys():
    for j in dict[i].values():
        if 'c' in j:
            if i not in listOfKeys:
                listOfKeys.append(i)

print(listOfKeys)

['A', 'D']

输出：

dict = {'A': {'B': ['a', 'b', 'c'], 'C': ['d', 'c', 'e']}, 'D': {'B': ['f', 'g', 'h'], 'E': ['i', 'j', 'c']}}

listOfKeys = []
for i in dict.keys():
    for j in dict[i].values():
        if 'c' in j:
            if i not in listOfKeys:
                listOfKeys.append(i)

print(listOfKeys)

['A', 'D']

---

您可以通过以下方式在更短的时间内完成：

>>> result = []
>>> for key, subdict in d.items():
...     for sublist in subdict.values():
...         if "c" in sublist:
...             result.append(key)
...             break
... 
>>> print(result)
['A', 'D']

---

注意使用

项

和

值

作为迭代

dict

元素的方法，您正在遍历字典结构中的所有元素。一旦发现事件，应立即中断循环。下面是使用列表理解的一行代码：

d = {'A': {'B': ['a', 'b', 'c'], 'C': ['d', 'c', 'e']}, 'D': {'B': ['f', 'g', 'h'], 'E': ['i', 'j', 'c']}}

found_keys = [k for k, v in d.items() if any("c" in l for l in v.values())]

如果要按子字典键进行筛选，它甚至更短：

found_keys = [k for k, v in d.items() if "c" in v['B']]

---

如果您要执行大量此类查找，那么进行一点预处理将大有帮助

以您在问题中提供的词典为例：

dict = { A: { B: [a, b, c] 
            , C: [d, c, e]
            } 
       , D: { B: [f, g, h]
            , E: [i, j, c]
            }
       }

您可以遍历每一个键值对并构造如下内容

new_dict = { a: { A: {B, C}
                , D: {E}
                }
           , b: { A: {B} 
                }
           , c: { A: {B, C}
                , D: {E}
                } 
           , d: { A: {C}
                }
           , e: { A: {C}
                }
           , f: { D: {B}
                }
           , g: { D: {B}
                }
           , h: { D: {B}
                }
           , i: { D: {E}
                }
           , j: { D: {E}
                }
           }

在上面的字典中，每个值都来自原始字典

dict

是一个键。其中每一个都与自己的字典相关联，其中键是原始字典中的顶级键，值是子字典中的键集

---

这可能需要大量的前期工作，但当您重复执行您提到的那种搜索时，它应该可以节省您的时间

您可以使用递归处理任意深度的输入：

d1 = {'A': {'B': ['a', 'b', 'c'], 'C': ['d', 'c', 'e']}, 'D': {'B': ['f', 'g', 'h'], 'E': ['i', 'j', 'c']}}
def get_keys(d, to_find):
  for a, b in d.items():
     if to_find in b:
       yield a
     if isinstance(b, dict):
       yield from get_keys(b, to_find)

print(list(get_keys(d1, 'c')))

输出：

['B', 'C', 'E']