查找与另一个字典中的键、值对匹配的字典的 Pythonic 方法

Question

我正在尝试找到一种将一个字典的键、值对与另一个匹配的方法。 第一个字典record是一个记录，其键数为 static 不变（尽管每个键的值当然可以更改），但第二个字典potential_outputs是用户定义的，并且具有可变的键和值。 用户从他们想要分配的record中选择哪些键，为其分配一个值，然后分配一个 output 值，该值在找到匹配项时使用。

例子：

record = [
    {"Name": "John Smith", "Class": "c1", "Plan": "p1",},
    {"Name": "Jane Doe", "Class": "c2", "Plan": "p2",},
]

potential_outputs = [
    {"Class": "c1", "Plan": "p1", "Output": "o11"},
    {"Class": "c1", "Plan": "p2", "Output": "o12"},
    {"Class": "c2", "Plan": "p1", "Output": "o21"},
    {"Class": "c2", "Plan": "p2", "Output": "o22"},
]

程序需要能够遍历record列表中的每个字典，确定potential_outputs中哪个字典匹配键、值对，然后从匹配的potential_outputs字典中返回“输出”。

预期的 output 将类似于：

[
    {"Name": "John Smith", "Output": "o11"},
    {"Name": "Jane Doe", "Output": "o22"},
]

我还想指出，我不致力于使用字典来解决这个问题。

谢谢！

Answer 1

您可以使用(Class, Plan)元组键对输出进行分组，然后使用列表推导 output 找到找到的 output 字典。

使用 output 查找字典进行O(1)查找允许解决方案为O(N + M) ，而不是O(N * M) ，其中N是record中的字典数量，而M是字典中的数量potential_outputs 。

record = [
    {"Name": "John Smith", "Class": "c1", "Plan": "p1",},
    {"Name": "Jane Doe", "Class": "c2", "Plan": "p2",},
]

potential_outputs = [
    {"Class": "c1", "Plan": "p1", "Output": "o11"},
    {"Class": "c1", "Plan": "p2", "Output": "o12"},
    {"Class": "c2", "Plan": "p1", "Output": "o21"},
    {"Class": "c2", "Plan": "p2", "Output": "o22"},
]

outputs = {(output["Class"], output["Plan"]): output["Output"] for output in potential_outputs}

result = [{"Name": r["Name"], "Output": outputs[r["Class"], r["Plan"]]} for r in record]

print(result)

Output：

[{'Name': 'John Smith', 'Output': 'o11'}, {'Name': 'Jane Doe', 'Output': 'o22'}]

Answer 2

为避免嵌套循环和 M*N 复杂性，您可以预处理record

from collections import defaultdict

rec = defaultdict(lambda: defaultdict(list))
for r in record:
    rec[r['Class']][r['Plan']].append(r['Name'])

在遍历potential_outputs之前

result = [{"Name": name, "Output": po["Output"]} 
          for po in potential_outputs 
          for name in rec[po['Class']][po['Plan']]]
result
# [{'Name': 'John Smith', 'Output': 'o11'}, {'Name': 'Jane Doe', 'Output': 'o22'}]

Answer 3

可以通过创建第三个字典用作索引来做到这一点，并且具有比线性性能更好的性能。 索引字典上的“键”应该是一组键/值对，它们可以是所需 output 记录的有效标识符。 看起来如果您使用包含元组的 FrosenSets 生成此索引 - 类似于：

def make_index(data):
    result_index = {}
    for row in data:
        work_row = row.copy()
        work_row.pop("Output")
        while work_row:
            key = frozenset((key, value) for key, value in work_row.items())
            result_index.setdefault(key, []).append(row)
            work_row.pop(next(iter(work_row))) 
    return result_index


def search(index, row_key):
    row_key = row_key.copy()
    row_key.pop("Name", None)
    key = frozenset((key, value) for key, value in row_key.items())
    return index[key]

如果“potential_outputs”具有除“Name”之外的所有键，则此方法有效：

In [35]: search(index, record[0])                                                                                                                    
Out[35]: [{'Class': 'c1', 'Plan': 'p1', 'Output': 'o11'}]

In [36]: index = make_index(potential_outputs)                                                                                                       

In [37]: search(index, record[0])                                                                                                                    
Out[37]: [{'Class': 'c1', 'Plan': 'p1', 'Output': 'o11'}]

如果您希望 mtches 出现的匹配键较少，而不仅仅是剥离名称，则相同的索引有效，但必须更改“搜索”代码。 然后我们必须确切知道要查询的所需匹配项是什么。 如果 "class" 和 "plan" 匹配不同的记录，是否都应该返回？ 还是没有？ 给定记录中的一行，您可能会在itertools中找到一些东西来生成您想要搜索的所有键。

同时，无论如何，如果一切匹配，此代码已经适合恢复多个结果：

In [39]: search(index, {"Plan": "p2"})                                                                                                               
Out[39]: 
[{'Class': 'c1', 'Plan': 'p2', 'Output': 'o12'},
 {'Class': 'c2', 'Plan': 'p2', 'Output': 'o22'}]

Answer 4

这是使用pandas处理它的一种非常简单的方法：

import pandas as pd

# Read your list of dicts into DataFrames.
dfr = pd.DataFrame(record)
dfp = pd.DataFrame(potential_outputs)

# Merge the two DataFrames on `Class` and `Plan` and return the result.
result = pd.merge(dfr, 
                  dfp, 
                  how='inner', 
                  on=['Class', 'Plan']).drop(['Class', 'Plan'], axis=1)

输出1：

作为 DataFrame：

    Name    Output
0   John Smith  o11
1   Jane Doe    o22

输出2：

作为一个列表：

result2 = [i for i in result.T.to_dict().values()]

[{'Name': 'John Smith', 'Output': 'o11'}, {'Name': 'Jane Doe', 'Output': 'o22'}]

Answer 5

如果您将 potential_outputs {("c1","p1"): "o11"}形式的字典，您可以这样做：

result = []
for a in record:
    if (a["Class"], a["Plan"]) in potential_outputs:
         result.append({"Name": a["Name"], "Output": potential_outputs[(a["Class"], a["Plan"])]})

这可能不是最好的方式，但会是纯粹的 Python 方式。

Answer 6

如果你对单线感兴趣

result = [{"Name": r["Name"], "Output": o["Output"]} for r in record for o in potential_outputs if r["Class"] == o["Class"] and r["Plan"] == o["Plan"]]

Answer 7

您可以将您的potential_outputs重组为字典：

potential_output_dict = {
    f"{o['Class']}_{o['Plan']}": o['Output'] for o in potential_outputs
}

output = []
for r in record:
    plan_key = f"{r['Class']}_{r['Plan']}"
    plan = potential_output_dict.get(plan_key)
    if not plan:
        continue

    output.append({
        "Name": r['Name'],
        "Plan": plan,
     })

print(output)

这样您就可以使用get() ，这比多次迭代字典列表要好一些。

（代码未测试）