Python编写使用多模型类的最佳实践

你的场景是标准的策略模式应用场景，所有仿真模型对外暴露相同的simulate方法，按下面的规范写可以保证代码可维护性、鲁棒性，避免后续加新模型出问题。

1. 定义抽象基类锁死接口契约 #

不要让各个模型类自己随便写simulate方法，先通过抽象基类把方法的参数规范、返回值规范、通用校验逻辑定死，从根源避免不同模型的同名方法参数不一致、返回值格式/形状不匹配的问题。
注意把不符合Python语法/PEP8规范的命名改掉：你原来写的Number of simulation带空格根本不能当参数名，统一改成蛇形命名n_simulations，steps改成n_steps语义更清晰。

from abc import ABC, abstractmethod
import numpy as np
from numpy.typing import NDArray


class BaseSimulationModel(ABC):
    """所有仿真模型的统一基类"""
    @abstractmethod
    def __init__(self, **model_params):
        pass

    @abstractmethod
    def simulate(self, n_steps: int, n_simulations: int) -> NDArray[np.float64]:
        """
        执行仿真计算
        :param n_steps: 仿真步长，必须为正整数
        :param n_simulations: 仿真路径条数，必须为正整数
        :return: 形状固定为(n_steps, n_simulations)的浮点型结果数组
        """
        # 通用参数校验逻辑写在基类，所有子类自动复用，不用重复写
        if n_steps <= 0:
            raise ValueError(f"仿真步长必须为正整数，当前传入值：{n_steps}")
        if n_simulations <= 0:
            raise ValueError(f"仿真次数必须为正整数，当前传入值：{n_simulations}")

后续新增的所有模型类，都继承这个基类实现即可：

class Model1(BaseSimulationModel):
    def __init__(self, drift: float, volatility: float):
        self.drift = drift
        self.volatility = volatility

    def simulate(self, n_steps: int, n_simulations: int) -> NDArray[np.float64]:
        # 先调用基类的通用校验
        super().simulate(n_steps, n_simulations)
        # 写Model1专属的仿真逻辑
        # res = ...
        return res


class Model2(BaseSimulationModel):
    def __init__(self, mean_rev_speed: float, long_term_mean: float):
        self.mean_rev_speed = mean_rev_speed
        self.long_term_mean = long_term_mean

    def simulate(self, n_steps: int, n_simulations: int) -> NDArray[np.float64]:
        super().simulate(n_steps, n_simulations)
        # 写Model2专属的仿真逻辑
        # res = ...
        return res

2. 解耦定价逻辑和模型实例化逻辑 #

你原来的写法是把模型类直接传入get_price，在方法内部实例化模型，这种写法耦合度很高：

• 模型初始化参数、仿真参数、定价计算参数会全部挤在get_price的入参列表里，参数多了根本分不清归属
• 传入不符合接口要求的类时，要运行到simulate调用那行才会抛错，排查成本高
• 后续如果要复用已经初始化好的模型实例（比如多组定价参数复用同一个模型、模型带预加载缓存/预训练权重），这种写法完全支持不了

推荐用依赖注入的方式改造：get_price直接接收已经初始化好的模型实例，通过类型提示明确要求传入的是BaseSimulationModel的子类，IDE可以提前做类型检查，传错对象立刻预警。另外你原来的类名Object太泛，容易和Python内置的object类型重名，建议改成有业务含义的名字比如Pricer：

class Pricer:
    def __init__(self, risk_free_rate: float):
        self.risk_free_rate = risk_free_rate

    def get_price(self, model: BaseSimulationModel, n_steps: int, n_simulations: int, **calc_params) -> NDArray[np.float64]:
        # 不需要关心传入的是Model1还是Model2，只要符合基类接口就能正常调用
        sim_array = model.simulate(n_steps=n_steps, n_simulations=n_simulations)
        # 后续通用的定价计算逻辑
        # price_array = ... 基于sim_array做计算
        return sim_array

3. 调用示例 #

if __name__ == "__main__":
    # 模型单独初始化，参数归属清晰
    model1 = Model1(drift=0.03, volatility=0.2)
    model2 = Model2(mean_rev_speed=0.5, long_term_mean=100)
    
    pricer = Pricer(risk_free_rate=0.025)
    # 传入不同模型即可得到对应定价结果，不需要修改Pricer类的任何代码
    price_res1 = pricer.get_price(model=model1, n_steps=252, n_simulations=10000)
    price_res2 = pricer.get_price(model=model2, n_steps=252, n_simulations=10000)

额外规范建议 #

• 所有标识符严格遵循PEP8规范：类名用大驼峰，方法、变量、参数用蛇形命名，不要出现带空格的参数名
• 所有方法补全类型提示，尤其是simulate的返回值，要明确标注数组的形状和数据类型，避免出现不同模型返回数组维度顺序不一致的低级错误（比如有的模型返回(n_steps, n_sims)，有的返回(n_sims, n_steps)，后续计算全错）
• 通用逻辑全部下沉到基类实现，不要在每个模型类里重复写参数校验、结果格式校验的代码
• 如果你确实需要动态根据配置创建模型实例，单独写一个模型工厂函数处理实例化逻辑，不要把模型创建的逻辑混在定价方法里

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