Python 3.x 根据python3.x中的规则查找dict与dict的交集

我有两个字典，如下所示，希望根据一些逻辑找到字典的交集

dict1= {"1":{"score1": 1.099, "score2":0.45},
       "2": {"score2": 0.099, "score3":1.45},
       "3": {"score2": 10, "score3":10.45}}
dict2= {"1":{"score6": 1.099, "score2":0.45},
       "2": {"score2": 10, "score3":10.45},
       "4": {"score5": 8, "score8":15}}

我想根据以下规则基于给定的两个词典创建词典：

1.基于外键的两个双键的并集

如果外部键在两个字典中都是公共的，则在嵌套的键值对中，仅显示两个字典中值最高的公共键

---

首先，感谢您提供具体的示例，说明您的输入是什么样的，以及您希望输出是什么样的

可能有更有效的方法来实现这一点，但由于没有提到任何性能限制，我的第一反应是求助于Python的

set

操作，使事情变得更简单：

#/usr/bin/env python
#-*-编码：utf-8-*-
第1条={
"1": {
“分数1”：1.099，
“得分2”：0.45
},
"2": {
“分数2”：0.099，
“得分3分”：1.45分
},
"3": {
“分数2”：10分，
“得分3”：10.45分
}
}
第2条={
"1": {
“分数6”：1.099，
“得分2”：0.45
},
"2": {
“分数2”：10分，
“得分3”：10.45分
},
"4": {
“分数5分”：8分，
“得分8分”：15分
}
}
结果_dict={
"1": {
“得分2”：0.45
},
"3": {
“分数2”：10分，
“得分3”：10.45分
},
"2": {
“分数2”：10分，
“得分3”：10.45分
},
"4": {
“分数5分”：8分，
“得分8分”：15分
}
}
联合会（d1、d2）：
“”“应用OP问题中的逻辑
Args：
d1（dict）：以一级嵌套dict作为值的dict
d2（dict）：具有一级嵌套dict作为值的dict
返回：dict
"""
结果={}
k1，k2=set（d1.keys（）），set（d2.keys（））
#没有碰撞，很简单
对于k1中的k，对称_差（k2）：
结果[k]=d1[k]，如果d1中的k与d2[k]
#键出现在两个dict中
对于k1交叉口（k2）中的k：
_k1，_k2=set（d1[k].keys（）），set（d2[k].keys（））
结果[k]={
键：最大值（[d1[k][key]，d2[k][key]）
用于输入交叉口（_k2）
}
返回结果
测试=奇怪的联合（dict1，dict2）
断言结果\u dict==测试
打印（'测试通过'）

其基本思想是分别处理不相交和相交情况。希望这有帮助

更新对评论的回应：

今后，请提前提供此类背景；对两个字典的操作与对任意数量输入的操作大不相同

这里有一种方法：

def invert_dicts（*dicts）：
“”“获取多个dict并返回dict映射
dict索引的键。例如。，
倒置(
{'a'：1，'b'：2}，
{'a'：3，'c'：4}
)
返回
{'a'：[0,1]，'b'：[0]，'c'：[1]}
"""
键映射={}
对于我，在列举中列举（dicts）：
对于k in d.keys（）：
key_map.setdefault（k，[]）.append（i）
返回键映射
工会的定义（*条款）：
“”“将OP问题中的逻辑应用于任意数量的输入。”
>>>奇怪的联盟（d1，d2，…，dn）
Args：
*dicts（dict）：字典，带有一级嵌套dicts作为值
返回：dict
"""
结果={}
#dict将键映射到包含键的“dicts”中的dict索引列表
键映射=反转命令（*命令）
对于键图中的k：
#没有外部键冲突
如果len（键映射[k]）==1：
结果[k]=dicts[key_map[k][0][k]
#外键碰撞
其他：
#不清楚在以下情况下应该发生什么：
#-存在外部密钥冲突
#-没有共享子密钥
#
#此实现假定在这种情况下，k的值为{}
result.setdefault（k，{}）
sub_dicts=元组（键映射[k]中i的dicts[i][k]）
#将'sub_dicts'中的键映射到包含键的'dicts'的索引
子键映射=反转指令（*子指令）
#包含（k，v）的元素，其中k出现在>1个子目录中
仅共享密钥=滤波器（λkv:len（kv[1]）>1，
sub_key_map.items（））
#使用每个共享密钥的最大值更新结果
仅对于共享钥匙中的kv：
最大值=最大值（（千伏[0]，子项[i][千伏[0]），对于千伏[1]中的i，
键=λx:x[1]）
结果[k]。更新（{max_u[0]：max_[1]}）
返回结果

---

试着注释一下，让事情是如何运作的。希望这适用于您的用例。

不要这样做：

sorted（result\u dict）==sorted（test）

首先，它只比较键，其次，您不需要对任何东西进行排序，字典等式是独立于顺序定义的，您只需要

result\u dict==test

这太棒了！但是我碰巧发现我想在5本字典上做同样的事情，所以你能告诉我需要做什么更改吗？

result_dict = {"1":{"score2":0.45},
       "3": {"score2": 10, "score3":10.45},
       "2": {"score2": 10, "score3":10.45},
       "4": {"score5": 8, "score8":15}}```