Kedro节点如何惰性输出两个分区数据集并避免重复计算

你当前实现中两个独立字典推导式生成的lambda是完全隔离的：当Kedro依次触发两个输出分区数据集的保存逻辑时，每个分区对应的两个lambda会各自独立调用一次_normalize_plate，直接导致单分区计算重复执行两次，同时代码需要两次遍历分区列表，冗余度高。

核心思路是为每个分区构建共享缓存的惰性计算闭包，仅通过单次循环生成两个输出字典的条目：第一次触发任意一个输出条目的调用时执行计算并缓存结果，后续取另一类返回值时直接读取缓存，完全避免重复计算，同时保留原方案惰性加载、单分区内存占用的优势。

优化后的实现代码如下：

from typing import Dict, Callable, Any

def normalize_plates(
    partitioned_standardized_profiles: Dict[str, Callable[[], Any]],
    df_reference_plate,
    df_descriptors,
    model,
) -> tuple[Dict[str, Callable[[], Any]], Dict[str, Callable[[], Any]]]:
    # 初始化两个输出分区对应的结果字典
    out_type1: Dict[str, Callable[[], Any]] = {}
    out_type2: Dict[str, Callable[[], Any]] = {}

    for partition_key, partition_load_func in sorted(partitioned_standardized_profiles.items()):
        # 每个分区独立创建缓存，避免跨分区数据污染
        partition_cache = {}

        def _get_cached_result(
            load_func=partition_load_func,
            cache=partition_cache
        ):
            # 仅首次调用时执行实际计算，结果写入缓存
            if not cache:
                res1, res2 = _normalize_plate(
                    load_func(),
                    df_reference_plate,
                    df_descriptors,
                    model
                )
                cache["result"] = (res1, res2)
            return cache["result"]

        # 两个输出字典的lambda共享同一个缓存计算逻辑
        out_type1[partition_key] = lambda: _get_cached_result()[0]
        out_type2[partition_key] = lambda: _get_cached_result()[1]

    return out_type1, out_type2

• 完全保留原有惰性特性：未触发分区保存动作时不会加载任何原始分区数据、不会执行计算，内存中仅保留当前正在处理的单个分区数据，符合Kedro分区数据集的社区最佳实践
• 无重复计算：每个分区的_normalize_plate逻辑仅会执行一次，后续读取两类输出时直接复用缓存结果，计算效率提升一倍
• 仅需单次遍历分区列表，代码结构更清晰易维护
• 无额外内存负担：单个分区的两类数据都写入目标存储后，对应的闭包、缓存、临时DataFrame会被自动回收，不会长期占用内存

注意：实现中保留了默认参数传递partition_load_func和cache的写法，是为了规避Python闭包的晚绑定问题，和你原有代码的避坑逻辑一致，不要随意删除这部分默认参数传值。

内容的提问来源于stack exchange，提问作者SprigganCG