如果键作为子值存在于第一个中，则在第二个中比较两个字典和更改键

Question

如果 d2 的键与 d1 中 id 的值匹配，则需要帮助重新映射它们。如果有不匹配的密钥，请删除它们。

d1={'A':{'id':'a'},'B':{'id':'b'}}
d2={'a':1,'b':2, 'c':3}

预期输出：

{'A': 1, 'B': 2}

Answer 1

您可以遍历 d1 并使用 d2 作为查找来修改值：

for k, d in d1.items():
    d1[k] = d2.get(d['id'])

如果你想修改 df2，你可以使用字典理解：

d2 = {k: d2.get(d['id']) for k, d in d1.items()}

或使用两个循环（一次修改 df1 中存在的键的值，一次删除 df1 中不存在的任何键）：

for k, d in d1.items():
    d2[k] = d2.pop(d['id'])
for k in list(d2.keys() - d1.keys()):
    d2.pop(k)

输出：

{'A': 123, 'B': 123}

Answer 2

这可能就是您想要的

d1={'A':{'id':'a'},'B':{'id':'b'}}
d2={'a':123,'b':123}

for key, id_map in d1.copy().items():  # view over soft copy won't mutate
    try:
        d1[key] = d2[id_map["id"]]
    except KeyError:
        pass

>>> d1
{'A': 123, 'B': 123}

但是，未映射的值将保持不变（即如果有 C，但其映射中没有 id，或者 d2 中没有 c。 )

>>> d1={'A':{'id':'a'},'B':{'id':'b'},'C':{'id':'c'}}
[..]
>>> d1
{'A': 123, 'B': 123, 'C': {'id': 'c'}}

如果你想丢弃未映射的值，你可以在此处使用 del d1[key] 在 except 中这样做，或者简单地创建一个新的字典来将键和值打包到（如果引发 KeyError 则永远不会添加）
或者，如果这是一个错误（即 C 必须存在），您可以简单地让 KeyError 向调用者提出并让它处理后果

Answer 3

只要每个 'val' 在 d1 的子词典中最多出现一次（即 d1 中的键：{'id': val} 对），您可以像这样遍历 d1 的项目：

d1 = {'A': {'id': 'a'}, 'B': {'id': 'b'}, 'C': {'id': 'c'}}
d2 = {'a': 123, 'b': 12, 'd': 8}

d3 = {k: d2[v['id']] for k, v in d1.items() if v['id'] in d2}
print(d3)

>>> {'A': 123, 'B': 12}

由于您需要检查 d1 中的所有 key-value 对，就时间和 space 效率而言，这是您可以做的最好的事情。

但是，如果您将 're-keying' 很多 d2 词典具有相同的 d1，构建一个 reverse-index 以供重用可能会更快：

reverse_mapping = {v['id']: k for k, v in d1.items()}
def rekey(dict_to_rekey, reverse_map):
    return {reverse_map[k]: dict_to_rekey[k] 
            for k in dict_to_rekey.keys() & reverse_map.keys()}

d3 = rekey(d2, reverse_mapping)

如果键作为子值存在于第一个中，则在第二个中比较两个字典和更改键

Compare two dict and change keys in second if keys exists as sub-value in first

python

dictionary

nested

matching