如何为类参数依次应用多方法并简化结果存储流程

问题背景 #

我有一个接收两个参数的类，需要将参数依次传入多个方法（前一个方法的输出作为后一个方法的输入），但手动创建大量实例变量存储中间结果既繁琐又不合理。核心需求：

• 类接收初始参数
• 参数按顺序经过多个方法处理
• 前序方法输出作为后续方法输入
• 最终生成两个参数的处理结果供后续使用

现有示例代码：

class Multiple_process:
    def __init__(self, param1, param2):
        self.param1 = param1
        self.param2 = param2

        # 存储中间结果
        self.param1_sq = None
        self.param2_sq = None
        self.param1_mul_10 = None
        self.param2_mul_10 = None

    def _square(self, value):
        sq_val = value ** 2
        return sq_val

    def _mul_10(self, sq_val):
        mul_10 = sq_val * 10
        return mul_10

    def applicaton(self):
        self.param1_sq = self._square(self.param1)
        self.param2_sq = self._square(self.param2)
        self.param1_mul_10 = self._mul_10(self.param1_sq)
        self.param2_mul_10 = self._mul_10(self.param2_sq)
        return self.param1_sq, self.param2_sq, self.param1_mul_10, self.param2_mul_10

test = Multiple_process(5, 4)
print(test.applicaton())  # 输出: (25, 16, 250, 160)

解决方案 #

方案1：链式调用+仅保留最终结果（无需中间变量） #

如果只关心最终输出，直接把方法调用链式串联，不用单独维护中间实例变量，代码更简洁：

class MultipleProcess:
    def __init__(self, param1, param2):
        self.param1 = param1
        self.param2 = param2
        self.final_results = None  # 按需存储最终结果

    def _square(self, value):
        return value ** 2

    def _mul_10(self, value):
        return value * 10

    def process(self):
        # 直接链式处理每个参数
        res1 = self._mul_10(self._square(self.param1))
        res2 = self._mul_10(self._square(self.param2))
        self.final_results = (res1, res2)
        return self.final_results

test = MultipleProcess(5, 4)
print(test.process())  # 输出: (250, 160)

方案2：用字典统一存储中间结果 #

如果需要保留中间结果但不想手动创建大量实例变量，用字典按参数名存储全流程的处理数据，扩展性更强：

class MultipleProcess:
    def __init__(self, param1, param2):
        # 用字典存储每个参数的所有处理阶段结果
        self.processing_data = {
            "param1": [param1],
            "param2": [param2]
        }
        # 定义处理步骤的方法序列，新增步骤只需追加到列表
        self.process_steps = [self._square, self._mul_10]

    def _square(self, value):
        return value ** 2

    def _mul_10(self, value):
        return value * 10

    def process(self):
        # 遍历每个参数，依次执行所有处理步骤
        for param_name in self.processing_data:
            current_val = self.processing_data[param_name][0]
            for step_func in self.process_steps:
                current_val = step_func(current_val)
                self.processing_data[param_name].append(current_val)
        
        # 提取最终结果
        final_res1 = self.processing_data["param1"][-1]
        final_res2 = self.processing_data["param2"][-1]
        return final_res1, final_res2

test = MultipleProcess(5, 4)
print(test.process())  # 输出: (250, 160)
# 查看param1的全流程结果
print(test.processing_data["param1"])  # 输出: [5, 25, 250]

方案3：管道模式动态组合处理步骤 #

把每个处理步骤做成独立可组合的函数，通过管道模式动态传入处理顺序，后续新增步骤无需修改类结构，灵活性拉满：

class MultipleProcess:
    def __init__(self, param1, param2):
        self.params = [param1, param2]

    @staticmethod
    def _square(value):
        return value ** 2

    @staticmethod
    def _mul_10(value):
        return value * 10

    def pipe_process(self, *steps):
        # 对每个参数依次执行传入的所有处理步骤
        processed = []
        for param in self.params:
            current = param
            for step in steps:
                current = step(current)
            processed.append(current)
        return tuple(processed)

test = MultipleProcess(5, 4)
# 按顺序传入处理步骤
print(test.pipe_process(MultipleProcess._square, MultipleProcess._mul_10))  # 输出: (250, 160)
# 后续新增步骤直接传入即可，比如加一个+5的步骤
def add_5(value):
    return value + 5
print(test.pipe_process(MultipleProcess._square, MultipleProcess._mul_10, add_5))  # 输出: (255, 165)

内容的提问来源于stack exchange，提问作者Partha Pratim Sarma