要进行AI编程，OOP+模块设计还是凸显重要。今天聊聊两者结合下，应该怎么去理解和应用。想象你正在搭建一座房子：模块化就像预制好的门窗、墙体等构件，让你能快速组合出不同户型；而面向对象（OOP）则像每个房间的布局逻辑 —— 卧室要放床，厨房要配炉灶，这些 "数据" 和 "行为" 的绑定让房子真正能用。在 AI 编程中，优秀的设计往往是这两种思想的联姻。

一、 识别模块与类

假设你在开发一个 AI 图像识别工具，首先要面对的问题是：哪些代码该放进模块，哪些该封装成类？

1、模块：功能的 "工具箱"

模块更适合作为功能集合存在，就像家里的工具箱 —— 螺丝刀、锤子各自独立，但都服务于修理这个场景。当功能更侧重 "做什么" 而非 "是什么" 时，模块函数是更好的选择。

# 模块: image_utils.py (图像处理工具集)

import cv2

import numpy as np

def load_image(path: str) -> np.ndarray:

"""加载图像的工具函数"""

return cv2.imread(path)

def resize_image(img: np.ndarray, size: tuple) -> np.ndarray:

"""调整图像尺寸的工具函数"""

return cv2.resize(img, size)

def save_image(img: np.ndarray, path: str) -> None:

"""保存图像的工具函数"""

cv2.imwrite(path, img)

这类模块通常有这些特点：

• 函数之间相对独立，主要通过参数传递数据

• 适合放置通用工具、配置项或无状态的功能

• 像config.py（配置中心）、utils.py（工具集）都是典型代表

2、类：数据与行为的 "生命体"

当需要同时处理数据和操作数据的行为时，类会更合适。就像一个 "相机" 不仅有像素、品牌等属性，还有拍照、对焦等行为，这些绑定在一起才是完整的概念。

# 类: 图像识别器 (数据+行为的封装)

class ImageClassifier:

def __init__(self, model_path: str):

self.model = self._load_model(model_path) # 数据: 模型实例

self.labels = self._load_labels() # 数据: 分类标签

def _load_model(self, path: str):

"""私有方法: 加载模型（内部行为）"""

return load_image_model(path) # 调用模块函数

def predict(self, img: np.ndarray) -> str:

"""公开方法: 预测图像类别（核心行为）"""

processed_img = preprocess(img) # 调用模块函数

return self.model.predict(processed_img)

判断准则可以简化为：如果一段代码需要 "记住" 状态（比如模型参数、中间结果），就用类；如果只是单纯完成一件事（比如格式转换、计算），用模块函数更简洁。

二、 设计模式基础

设计模式不是刻板的模板，而是前人总结的 "解题思路"。当模块化遇上 OOP，这些模式能让代码更灵活、更易维护。

1、工厂模式

就像餐馆的后厨统一制作菜品，工厂模式把对象创建的逻辑集中管理，避免客户端直接和具体类打交道。模块非常适合作为工厂的 "场地"。

# 模块: model_factory.py (工厂模式的实现)

from classification import CNNModel, RNNModel, TransformerModel

class ModelFactory:

@staticmethod

def create_model(model_type: str, params: dict):

"""根据类型创建不同模型（集中化创建逻辑）"""

if model_type == "cnn":

return CNNModel(**params)

elif model_type == "rnn":

return RNNModel(** params)

elif model_type == "transformer":

return TransformerModel(**params)

else:

raise ValueError(f"不支持的模型类型: {model_type}")

# 客户端使用（无需知道具体类）

from model_factory import ModelFactory

model = ModelFactory.create_model("cnn", {"layers": 5, "filters": 64})

model.train()

这种模式的好处是：当需要新增模型类型时，只需修改工厂模块，不用改动所有使用模型的地方 —— 这就是 "开放 - 封闭原则" 的体现。

2、策略模式

策略模式像电视遥控器，不同按钮对应不同频道（算法），但操作方式保持一致。通过组合而非继承，让算法可以灵活替换。

# 模块: optimization_strategies.py

from abc import ABC, abstractmethod

# 策略接口（抽象基类）

class OptimizerStrategy(ABC):

@abstractmethod

def optimize(self, model, data):

pass

# 具体策略1: 梯度下降

class GradientDescent(OptimizerStrategy):

def optimize(self, model, data):

print("使用梯度下降优化")

# 具体实现...

# 具体策略2: 遗传算法

class GeneticAlgorithm(OptimizerStrategy):

def optimize(self, model, data):

print("使用遗传算法优化")

# 具体实现...

# 上下文类（使用策略）

class ModelTrainer:

def __init__(self, optimizer: OptimizerStrategy):

self.optimizer = optimizer # 注入策略

def train(self, model, data):

self.optimizer.optimize(model, data)

# 使用示例

trainer = ModelTrainer(GradientDescent())

trainer.train(my_model, train_data)

# 切换策略只需换参数

trainer = ModelTrainer(GeneticAlgorithm())

模块在这里定义了策略家族，而 OOP 的抽象类保证了策略替换时的兼容性。

3、观察者模式

就像微信公众号和订阅者的关系，一个对象（主题）的状态变化会自动通知所有依赖它的对象（观察者）。模块可以统一管理这些基类定义。

# 模块: observer.py

class Subject:

def __init__(self):

self._observers = []

def attach(self, observer):

self._observers.append(observer)

def notify(self, data):

for observer in self._observers:

observer.update(data)

class Observer:

def update(self, data):

# 子类实现具体逻辑

pass

# 具体主题: 模型训练器

class ModelTrainer(Subject):

def train(self):

for epoch in range(10):

# 训练逻辑...

self.notify(f"第{epoch}轮训练完成，准确率: {0.8+epoch*0.01}")

# 具体观察者1: 日志记录器

class Logger(Observer):

def update(self, data):

print(f"日志: {data}")

# 具体观察者2: 进度显示器

class ProgressBar(Observer):

def update(self, data):

print(f"进度: {data}")

# 使用示例

trainer = ModelTrainer()

trainer.attach(Logger())

trainer.attach(ProgressBar())

trainer.train() # 自动通知所有观察者

4、单例模式

单例模式确保一个类只有一个实例，比如配置管理、日志系统通常只需要一个全局实例。在 Python 中，模块级变量天然是单例（因为模块只加载一次）。

# 模块: config.py (天然单例)

class Config:

def __init__(self):

self._settings = {

"batch_size": 32,

"learning_rate": 0.001

}

def get(self, key):

return self._settings.get(key)

# 模块级实例（全局唯一）

config = Config()

# 使用方式（任何地方导入都是同一个实例）

from config import config

print(config.get("batch_size")) # 32

用类实现单例则需要重写__new__方法，但要谨慎使用 —— 过度依赖单例可能导致代码耦合过高，就像把所有控制按钮都塞进一个总开关。

三、 依赖管理与解耦

想象一辆汽车：如果发动机和车身焊死在一起，换发动机就得拆整车；但如果用螺丝固定（低耦合），更换就很方便。依赖注入就是代码中的 "螺丝"。

1、依赖注入

不要在类内部硬编码依赖，而是从外部传入 —— 这就是依赖注入（DI）的核心思想。

# 反面例子：硬编码依赖（高耦合）

class ModelTrainer:

def __init__(self):

self.db = MySQLDatabase("localhost:3306") # 硬编码依赖

self.logger = FileLogger("train.log") # 难以替换

# 正面例子：依赖注入（低耦合）

class ModelTrainer:

def __init__(self, db, logger):

self.db = db # 外部注入依赖

self.logger = logger # 可替换为任何实现

def save_results(self, metrics):

self.db.insert(metrics)

self.logger.info(f"保存结果: {metrics}")

# 使用时注入具体实现

from databases import MySQLDatabase, MongoDB

from loggers import FileLogger, ConsoleLogger

# 灵活组合不同依赖

trainer = ModelTrainer(

db=MongoDB("localhost:27017"),

logger=ConsoleLogger()

)

2、模块作为 "装配中心"

大型项目中，通常用专门的模块（如app.py）负责创建对象并注入依赖，就像工厂的装配线。

# 模块: app.py (依赖装配中心)

from trainers import ModelTrainer

from databases import MySQLDatabase

from loggers import FileLogger

from models import CNNModel

def create_app():

# 创建依赖对象

db = MySQLDatabase("config/db.ini")

logger = FileLogger("logs/train.log")

model = CNNModel("models/cnn_weights.h5")

# 注入依赖

trainer = ModelTrainer(db, logger)

return trainer

# 启动应用

if __name__ == "__main__":

app = create_app()

app.train(model, train_data)

这种方式让依赖关系一目了然，修改配置只需调整装配模块。

四、 构建服务层与领域模型

就像医院分急诊室、化验科、药房等部门，软件也可以按职责分层，每层专注做一件事。

1、领域模型：业务核心的 "DNA"

领域模型是包含核心业务逻辑的类，就像生物的 DNA 承载遗传信息。它们通常放在models/目录下。

# 模块: models/user.py (领域模型)

class User:

def __init__(self, user_id: str, name: str):

self.user_id = user_id

self.name = name

self.models = [] # 用户训练的模型

def add_model(self, model):

if len(self.models) >= 5:

raise ValueError("每个用户最多创建5个模型")

self.models.append(model)

def get_model_metrics(self, model_id):

model = next(m for m in self.models if m.id == model_id)

return model.metrics

2、服务层：业务流程的 "指挥中心"

服务层协调多个领域对象完成复杂业务，就像医院的主治医生统筹各科室。它们通常放在services/目录。

# 模块: services/training_service.py (服务层)

from models.user import User

from models.model import Model

from databases.db_service import DBService

class TrainingService:

def __init__(self, db_service: DBService):

self.db_service = db_service

def train_user_model(self, user_id: str, model_params: dict):

# 1. 获取用户

user = self.db_service.get_user(user_id)

if not user:

raise ValueError("用户不存在")

# 2. 创建模型

model = Model(**model_params)

# 3. 调用领域模型的业务逻辑

user.add_model(model)

# 4. 保存结果

self.db_service.save_model(model)

self.db_service.update_user(user)

return model.id

3、接口层：用户交互的 "窗口"

接口层处理用户输入输出，就像医院的挂号台，不处理核心业务，只负责传递请求。它们通常放在api/或web/目录。

# 模块: api/endpoints/training.py (接口层)

from fastapi import APIRouter, Depends

from services.training_service import TrainingService

from dependencies import get_training_service

router = APIRouter()

@router.post("/train")

def train_model(

user_id: str,

model_params: dict,

service: TrainingService = Depends(get_training_service)

):

model_id = service.train_user_model(user_id, model_params)

return {"status": "success", "model_id": model_id}

这种分层架构的好处是：每层可以独立修改（比如换数据库不影响接口），也方便团队分工（前端开发者只需关注接口层）。

最后小结：

模块化和 OOP 不是对立的 —— 模块提供了代码的物理组织边界，类提供了逻辑抽象的封装单元。在 AI 编程中，我们既需要用模块划分功能边界（如data/、models/、services/），也需要用类封装数据和行为（如Dataset、Model、Trainer）。设计模式是连接两者的桥梁，而依赖注入则是降低耦合的关键技术。记住：好的设计不是一开始就完美的，而是在不断重构中逐渐清晰的 —— 就像雕塑家在凿击中慢慢让作品浮现。未完待续.......