以最具python风格的方式迭代和比较两个python字典，以实现快速执行 def formoutput（团队id、专利团队）： """ 用于比较团队id和专利团队以形成默认字典匹配值的函数 ：param teams_id:{（'3879797-2'，'3930281-2'）：1，（'3930282-1'，'3930282-2'）：2，（'3930288-1'，'3930288-2'）：3，…} ：param patent_团队：{3930281:[（'3879797-2'，'3930281-2'）]，3930282:[（'3930282-1'，'3930282-2'）]，3930288:[（'3930288-1'，'3930288-2'）]，…} ：return:defaultdict（，{3930281:defaultdict（，{3879797-2'：[1]，'3930281-2'：[1]}），3930282:defaultdict（，{3930282-1'：[2]，'3930282-2'：[2]}），3930288:defaultdict（，{3930288-1'：[3]，'3930288-2'：[3]}），3930292:defaultdict（，{'3861607-1'：[4]，'3861607-2'：[4]}） """ 打印（“形成输出”） 打印（“团队id=”，团队id） 打印（“专利团队=”，专利团队） 输出_dict=defaultdict（lambda:defaultdict（列表）） 尝试： 对于团队中的k，v_id.items（）： 对于专利团队中的a、b.items（）： 对于b中的i： 如果k在i中： 对于k中的z： 输出指令[a][z]。追加（v） 例外情况除外，如e： 打印（e） 返回输出命令
我有一个函数，以python字典的形式向其传递两个参数。第一个字典的键作为第二个字典中的值出现。我需要比较第一个字典中的每个键是否在第二个字典中存在一个值，然后使用键、第一个字典中的值和第二个字典中的键请看一看上面的代码，这将有助于更好地理解代码。 多个嵌套循环使代码非常慢。我在第一个字典中有5000多万个键值对。在第二个字典中有300多万个键值，每个键值平均包含3个值 代码背后的整个想法是找到所有可能的发明人对，他们曾经以某种组合在专利上工作过，这些都需要作为{patent_id:inventor_team，team_id}的输出.目前，执行相同的代码需要几个小时。我运行了100000个键值对，大约需要2000秒，这是很长的时间以最具python风格的方式迭代和比较两个python字典，以实现快速执行 def formoutput（团队id、专利团队）： """ 用于比较团队id和专利团队以形成默认字典匹配值的函数 ：param teams_id:{（'3879797-2'，'3930281-2'）：1，（'3930282-1'，'3930282-2'）：2，（'3930288-1'，'3930288-2'）：3，…} ：param patent_团队：{3930281:[（'3879797-2'，'3930281-2'）]，3930282:[（'3930282-1'，'3930282-2'）]，3930288:[（'3930288-1'，'3930288-2'）]，…} ：return:defaultdict（，{3930281:defaultdict（，{3879797-2'：[1]，'3930281-2'：[1]}），3930282:defaultdict（，{3930282-1'：[2]，'3930282-2'：[2]}），3930288:defaultdict（，{3930288-1'：[3]，'3930288-2'：[3]}），3930292:defaultdict（，{'3861607-1'：[4]，'3861607-2'：[4]}） """ 打印（“形成输出”） 打印（“团队id=”，团队id） 打印（“专利团队=”，专利团队） 输出_dict=defaultdict（lambda:defaultdict（列表）） 尝试： 对于团队中的k，v_id.items（）： 对于专利团队中的a、b.items（）： 对于b中的i： 如果k在i中： 对于k中的z： 输出指令[a][z]。追加（v） 例外情况除外，如e： 打印（e） 返回输出命令,python,dictionary,for-loop,optimization,numba,Python,Dictionary,For Loop,Optimization,Numba,我有一个函数，以python字典的形式向其传递两个参数。第一个字典的键作为第二个字典中的值出现。我需要比较第一个字典中的每个键是否在第二个字典中存在一个值，然后使用键、第一个字典中的值和第二个字典中的键请看一看上面的代码，这将有助于更好地理解代码。 多个嵌套循环使代码非常慢。我在第一个字典中有5000多万个键值对。在第二个字典中有300多万个键值，每个键值平均包含3个值 代码背后的整个想法是找到所有可能的发明人对，他们曾经以某种组合在专利上工作过，这些都需要作为{patent_id:invent
请为我提供整体解决方案的最佳方法。另外，处理如此大量数据的最佳方法是什么？两种改进方法，看看哪一种对您方便： 首先，我将颠倒循环的顺序：
def formoutput(teams_id, patent_team):
"""
The function to compare team_id and patent_teams to form the default dictionary matching values
:param teams_id: {('3879797-2', '3930281-2'): 1, ('3930282-1', '3930282-2'): 2, ('3930288-1', '3930288-2'): 3, ... }
:param patent_team: {3930281: [[('3879797-2', '3930281-2')]], 3930282: [[('3930282-1', '3930282-2')]], 3930288: [[('3930288-1', '3930288-2')]], ... }
:return: defaultdict(<function formoutput.<locals>.<lambda> at 0x0000022A45228240>, {3930281: defaultdict(<class 'list'>, {'3879797-2': [1], '3930281-2': [1]}), 3930282: defaultdict(<class 'list'>, {'3930282-1': [2], '3930282-2': [2]}), 3930288: defaultdict(<class 'list'>, {'3930288-1': [3], '3930288-2': [3]}), 3930292: defaultdict(<class 'list'>, {'3861607-1': [4], '3861607-2': [4]}), ..}
"""
print("Forming Output")
print("Teams id =", teams_id)
print("Patent_team=", patent_team)
output_dict = defaultdict(lambda: defaultdict(list))
try:
for k,v in teams_id.items():
for a,b in patent_team.items():
for i in b:
if k in i:
for z in k:
output_dict[a][z].append(v)
except Exception as e:
print(e)
return output_dict
patent\u teamsteams\u idteams\u id第二种方法是在合并之前转换数据。您可以尝试将这两个字典整理成表格形式，并将其放入pandas DataFrame中，甚至将其保存到数据库中（在本例中，SQLite会很方便）。这样做的好处是，您可能会从Python解释器中卸载表联接/数据帧合并操作。因此速度更快。有两种改进方法，请查看哪一种更方便： 首先，我将颠倒循环的顺序：
def formoutput(teams_id, patent_team):
"""
The function to compare team_id and patent_teams to form the default dictionary matching values
:param teams_id: {('3879797-2', '3930281-2'): 1, ('3930282-1', '3930282-2'): 2, ('3930288-1', '3930288-2'): 3, ... }
:param patent_team: {3930281: [[('3879797-2', '3930281-2')]], 3930282: [[('3930282-1', '3930282-2')]], 3930288: [[('3930288-1', '3930288-2')]], ... }
:return: defaultdict(<function formoutput.<locals>.<lambda> at 0x0000022A45228240>, {3930281: defaultdict(<class 'list'>, {'3879797-2': [1], '3930281-2': [1]}), 3930282: defaultdict(<class 'list'>, {'3930282-1': [2], '3930282-2': [2]}), 3930288: defaultdict(<class 'list'>, {'3930288-1': [3], '3930288-2': [3]}), 3930292: defaultdict(<class 'list'>, {'3861607-1': [4], '3861607-2': [4]}), ..}
"""
print("Forming Output")
print("Teams id =", teams_id)
print("Patent_team=", patent_team)
output_dict = defaultdict(lambda: defaultdict(list))
try:
for k,v in teams_id.items():
for a,b in patent_team.items():
for i in b:
if k in i:
for z in k:
output_dict[a][z].append(v)
except Exception as e:
print(e)
return output_dict
patent\u teamsteams\u idteams\u id第二种方法是在合并之前转换数据。您可以尝试将这两个字典整理成表格形式，并将其放入pandas DataFrame中，甚至将其保存到数据库中（在本例中，SQLite会很方便）。这样做的好处是，您可能会从Python解释器中卸载表联接/数据帧合并操作。因此速度更快。如果列表包装确实是多余的，并且您忽略了相应的键不在
团队ID中的情况，您可以大大减少循环和成员资格测试的数量关于：
for a,b in patent_team.items():
for i in b:
for k in i:
if k in teams_id:
for z in k:
output_dict[a][z].append(teams_id[k])
与：
确保在文件顶部包含来自itertools导入链的导入。如果列表包装确实是多余的，并且忽略了相应的键不在团队ID中的情况，则可以显著减少此处的循环和成员资格测试数：
for a,b in patent_team.items():
for i in b:
for k in i:
if k in teams_id:
for z in k:
output_dict[a][z].append(teams_id[k])
与：
确保在文件顶部包含来自itertools导入链的导入。我忍不住注意到您的内部defaultdict（列表）
在每个列表中似乎从来没有超过一个条目。你确定你需要一个列表
吗？另外，为什么专利团队
会将一个元素列表
值设置为包含一个元素列表
包含一个两元组
？内部或外部列表
可以t不止一个元素？内部的两个元组是否可以有不同数量的元素？@ShadowRanger，我最初尝试使用defaultdict（int）但是对于不存在的键，它没有append方法，因此我需要添加额外的行代码来检查键是否已经存在，如果不存在，则将其初始化到列表中，为了避免所有这些，我默认情况下将其转换为列表。@ShadowRanger，是的，列表中可以包含多个元素st，我刚刚打印了几个初始值作为参考。它可以是这样的。“”3930857:[（'3930857-1'，'3930857-2'），（'3930857-1'，'3930857-3'），（'3930857-2'，'3930857-3'），[（'3930857-1'，'3930857-2'，'3930857-3'）]，“，”我忍不住注意到你的内部defaultdict（列表）
在每个列表中似乎从来没有超过一个条目。你确定你需要一个列表吗？另外，为什么专利团队
将一个元素列表
中包含一个元素li
for pk, pvs_lists in patent_team.items():
for pvs in chain.from_iterable(pvs_lists):