Question

我正在使用Python 3.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]

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

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]）的所有键的列表，但是我有一个大型数据集，我意识到可能有更好的方法来处理它。 / p>

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

我是Python的新手，还在学习如何优化。您能否建议我在处理大型数据集时如何处理它以更好地处理它？</ p>

Answer 1

您正在循环遍历字典结构中的所有元素。您应该在找到事件后立即中断循环。这是一个使用列表理解的单行：

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

如果您想通过子字符串键进行过滤，则更短：

  resolve: {
    root: __dirname,
    alias: {
      Main: 'app/components/Main.jsx',
      Nav: 'app/components/Nav.jsx'
    },
    extensions: ['', '.js', '.jsx']
  },

Answer 2

您可以使用内置的.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']

Answer 3

你可以用这样的东西做更多的事情：

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

请注意使用items和values作为迭代dict元素的方法。

Answer 4

如果您要执行大量此类查找，那么一些预处理将会有很长的路要走。

获取您在问题中提供的词典：

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是关键。其中每个都与自己的字典相关联，其中键是原始字典中的顶级键，值是子字典中的键集。

这可能需要预先做很多工作，但是当您重复搜索您提到的那种时，它应该可以节省您的时间。

Answer 5

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

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']

如果嵌套字典

5 个答案: