面向对象编程 vs 其他编程范式：LLM 开发该选哪种？

（专栏：Python 从真零基础到纯文本 LLM 全栈实战・特辑 | 场景化对比 | 代码可视化）

---

开篇：LLM 开发中的 “代码混乱” 困境

你有没有过这样的经历？用 Python 写一个简单的 LLM 推理脚本：先写generate_prompt，再写call_api，最后parse_response，几行代码搞定。但当需求升级 —— 要支持多模型、会话管理、Prompt 模板、批量推理时，线性的代码开始变得混乱：全局变量满天飞、函数参数越来越多、改一个功能要牵一发而动全身……

这不是你的代码能力问题，而是编程范式选择的问题。编程范式是开发者思考和组织代码的 “方法论”，不同的范式适合不同的开发场景。本文将聚焦面向对象编程（OOP） 与另外两种主流范式 ——面向过程编程（POP）、函数式编程（FP） 的核心差异，并结合 LLM 开发场景，告诉你该怎么选。

---

一、什么是 “编程范式”？

简单来说，编程范式是一套 “代码组织的规则和习惯”，它决定了你如何拆分问题、如何组织代码、如何思考程序的运行逻辑。当前主流的编程范式有三种：

• 面向过程（Procedure-Oriented Programming, POP）：按 “步骤” 组织代码
• 面向对象（Object-Oriented Programming, OOP）：按 “对象” 组织代码
• 函数式编程（Functional Programming, FP）：按 “纯函数” 组织代码

下面我们将逐一拆解这三种范式，并结合 LLM 开发场景给出代码示例。

---

二、三大范式核心拆解（LLM 场景版）

2.1 面向过程编程（POP）：按 “步骤” 办事的 “流水线”

核心思想

把程序看作一系列按顺序执行的步骤，通过函数封装每个步骤，最终按顺序调用这些函数完成任务。就像工厂的流水线：先 “原料准备”→“加工”→“包装”→“出货”，线性执行。

LLM 场景代码示例：单轮商品文案生成

# 步骤1：生成Prompt
def generate_prompt(product_name):
    return f"请生成{product_name}的电商宣传文案，100字以内，突出性价比"

# 步骤2：调用LLM API
def call_llm_api(prompt, model="gpt-3.5-turbo"):
    # 模拟API调用
    return f"LLM生成文案：{prompt}→【{product_name}：29.9元的快乐！防摔耐磨，颜值在线，性价比拉满！】"

# 步骤3：解析并输出结果
def output_result(response):
    print("生成结果：", response)

# 主流程：按顺序执行步骤
def main():
    product = "苹果15手机壳"
    prompt = generate_prompt(product)
    response = call_llm_api(prompt)
    output_result(response)

if __name__ == "__main__":
    main()

优缺点（LLM 场景视角）

• 优点：简单直接、学习成本低，适合 100 行以内的小脚本（如单轮 LLM 推理、临时语料处理）
• 缺点：耦合度极高（函数间通过参数和全局变量传递数据）、扩展性极差（要加多模型支持？得改call_llm_api的所有参数和逻辑）、维护成本随代码量指数增长

2.2 面向对象编程（OOP）：按 “对象” 交互的 “协作网”

核心思想

把程序看作一系列相互交互的 “对象”，每个对象都有自己的 “属性”（数据）和 “方法”（行为），对象通过调用彼此的方法完成任务。就像奶茶店的运营：“顾客”、“服务员”、“奶茶机” 都是对象，各自有属性（顾客的订单、奶茶机的原料）和行为（顾客点单、服务员制作、奶茶机出茶），通过交互完成服务。

LLM 场景代码示例：多模型文案生成系统

# 1. LLM抽象基类（定义所有LLM的统一接口）
class BaseLLM:
    def __init__(self, model_name, api_key):
        self.model_name = model_name
        self.api_key = api_key
    
    def generate(self, prompt):
        raise NotImplementedError("子类必须实现generate方法")

# 2. 具体LLM类（ChatGPT）
class ChatGPT(BaseLLM):
    def generate(self, prompt):
        return f"ChatGPT生成：{prompt}→【苹果15手机壳：29.9元的快乐！防摔耐磨，颜值在线，性价比拉满！】"

# 3. 具体LLM类（文心一言）
class WenXin(BaseLLM):
    def generate(self, prompt):
        return f"文心一言生成：{prompt}→【苹果15手机壳：29.9元抢！防摔抗造，颜值天花板，性价比之王！】"

# 4. Prompt管理器（独立对象）
class PromptManager:
    def get_prompt(self, template_name, **kwargs):
        templates = {
            "product_copy": "请生成{product}的电商宣传文案，100字以内，突出性价比"
        }
        return templates[template_name].format(**kwargs)

# 5. 文案生成器（核心协调对象）
class CopyGenerator:
    def __init__(self, llm):
        self.llm = llm
        self.prompt_manager = PromptManager()
    
    def generate_copy(self, product):
        prompt = self.prompt_manager.get_prompt("product_copy", product=product)
        return self.llm.generate(prompt)

# 主流程：对象交互
def main():
    # 可快速切换模型
    gpt_llm = ChatGPT("gpt-3.5-turbo", "sk-xxx")
    wx_llm = WenXin("ernie-3.5", "ak-xxx")
    
    generator = CopyGenerator(gpt_llm)
    print("ChatGPT生成：", generator.generate_copy("苹果15手机壳"))
    
    # 切换模型仅需一行代码
    generator.llm = wx_llm
    print("文心一言生成：", generator.generate_copy("苹果15手机壳"))

if __name__ == "__main__":
    main()

优缺点（LLM 场景视角）

• 优点：低耦合（对象间通过接口交互，无需了解内部实现）、高扩展性（加新模型仅需继承BaseLLM）、易维护（每个对象职责单一，修改仅影响自身），适合复杂 LLM 系统（如多模型支持、会话管理、Prompt 模板库）
• 缺点：学习曲线较陡（需理解类、对象、封装、继承、多态等概念），小脚本用 OOP 会显得 “杀鸡用牛刀”

2.3 函数式编程（FP）：按 “纯函数” 组合的 “数学运算”

核心思想

把程序看作一系列数学函数的组合，强调 “无副作用” 和 “不可变性”：

• 纯函数：相同输入必然得到相同输出，且不会修改外部状态（如全局变量、文件、数据库）
• 不可变性：数据一旦创建就不能修改，只能通过函数返回新数据

就像数学计算：f(x)=x+1，不管什么时候调用，输入 2 都会得到 3，且不会影响任何外部变量。

LLM 场景代码示例：语料清洗与批量推理

from functools import compose, partial

# 纯函数1：清洗语料中的特殊字符
def clean_corpus(corpus):
    return [text.replace("\n", "").replace("\t", "") for text in corpus]

# 纯函数2：生成Prompt（无外部依赖）
def generate_prompt(text):
    return f"请总结以下文本：{text}"

# 纯函数3：批量调用LLM（假设LLM调用是无副作用的纯函数）
def batch_call_llm(prompts):
    # 模拟批量API调用，返回新列表
    return [f"总结：{prompt.split('：')[1]}" for prompt in prompts]

# 纯函数4：过滤短总结
def filter_short_summaries(summaries, min_length=10):
    return [summary for summary in summaries if len(summary) >= min_length]

# 组合函数：将多个纯函数组合成流水线
process_corpus = compose(filter_short_summaries, batch_call_llm, generate_prompt, clean_corpus)

# 主流程：调用组合函数
def main():
    raw_corpus = [
        "苹果15手机壳\n防摔耐磨\n性价比高\n",
        "华为Mate60手机壳\t颜值在线\n",
        "小米14手机壳\n轻薄透气\n"
    ]
    result = process_corpus(raw_corpus)
    print("处理结果：", result)

if __name__ == "__main__":
    main()

优缺点（LLM 场景视角）

• 优点：代码简洁、易测试（纯函数无副作用，输入固定输出固定）、并行友好（不可变性适合多线程），适合 LLM 数据处理场景（语料清洗、文本预处理、数据转换）
• 缺点：不适合复杂状态管理（如会话管理、用户状态追踪），学习曲线最高（需理解函子、单子、柯里化等概念）

---

三、三大范式核心差异对比（LLM 场景版）

对比维度	面向过程	面向对象	函数式
核心思想	按步骤线性执行	对象交互完成任务	纯函数组合运算
LLM 适用场景	单轮推理脚本、临时语料处理	复杂 LLM 系统（多模型、会话、Prompt 管理）	语料清洗、数据预处理、批量推理
耦合度	极高（函数依赖参数 / 全局变量）	极低（对象依赖接口）	低（函数依赖输入）
扩展性	极差（修改一个功能需改所有关联函数）	极强（加新功能仅需新增 / 修改类）	中等（需修改函数组合）
调试难度	易（按步骤追踪）	中等（需追踪对象交互）	易（纯函数无副作用）
学习成本	极低	中等	极高
代码量	少（小脚本）→ 极多（大系统）	中等（大系统有优势）	少（数据处理场景）

---

四、实战对比：三种范式写同一个 LLM 任务

任务需求

开发一个 LLM 商品文案生成工具，支持：

1. 生成电商宣传文案
2. 支持 ChatGPT 和文心一言两种模型
3. 可扩展支持新模型

1. 面向过程版（约 30 行，扩展性差）

def generate_prompt(product):
    return f"生成{product}的电商文案"

def call_chatgpt(prompt):
    return f"ChatGPT：{prompt}"

def call_wenxin(prompt):
    return f"文心一言：{prompt}"

def main():
    product = "苹果15手机壳"
    prompt = generate_prompt(product)
    print(call_chatgpt(prompt))
    print(call_wenxin(prompt))
    # 加新模型需新增call_newmodel函数，改main流程

2. 面向对象版（约 60 行，扩展性强）

class BaseLLM:
    def generate(self, prompt):
        pass

class ChatGPT(BaseLLM):
    def generate(self, prompt):
        return f"ChatGPT：{prompt}"

class WenXin(BaseLLM):
    def generate(self, prompt):
        return f"文心一言：{prompt}"

class CopyGenerator:
    def __init__(self, models):
        self.models = models
    
    def generate(self, product):
        prompt = f"生成{product}的电商文案"
        return [model.generate(prompt) for model in self.models]

def main():
    generator = CopyGenerator([ChatGPT(), WenXin()])
    print(generator.generate("苹果15手机壳"))
    # 加新模型仅需继承BaseLLM，改models列表

3. 函数式版（约 20 行，仅适合无状态场景）

from functools import partial

def call_llm(model_name, prompt):
    return f"{model_name}：{prompt}"

def generate_copy(product, models):
    prompt = f"生成{product}的电商文案"
    return [partial(call_llm, model_name)(prompt) for model_name in models]

def main():
    print(generate_copy("苹果15手机壳", ["ChatGPT", "文心一言"]))
    # 加新模型仅需加model_name
    # 但无法处理复杂模型配置（如API密钥）

---

五、LLM 开发中的范式选择建议

1. 小任务用 POP

• 适用场景：单轮 LLM 推理脚本、临时语料处理、100 行以内的小工具
• 优点：快速开发，无需考虑复杂结构

2. 复杂系统用 OOP

• 适用场景：支持多模型的 LLM 服务、会话管理系统、Prompt 模板库、企业级 LLM 应用
• 优点：低耦合、高扩展，长期维护成本低
• 关键技巧：
  • 用抽象基类定义统一接口
  • 每个类只负责一个功能（单一职责原则）
  • 用组合代替继承（避免类层次过深）

3. 数据处理用 FP

• 适用场景：LLM 语料清洗、文本预处理、批量数据转换
• 优点：代码简洁、易测试、并行友好
• 关键技巧：
  • 尽量使用纯函数
  • 用functools组合函数
  • 避免修改外部状态

4. 混合使用是常态

在实际 LLM 开发中，三种范式往往混合使用：

• 用 OOP 构建 LLM 系统的骨架（如模型管理、会话管理）
• 用 FP 处理系统中的数据环节（如语料清洗、文本转换）
• 用 POP 处理系统中的简单线性流程（如日志打印、配置加载）

---

六、总结：范式没有 “好坏”，只有 “合适”

编程范式不是 “武功秘籍”，没有 “最强” 之说，只有 “最适合” 当前场景的选择。在 LLM 开发中：

• 如果你写的是临时脚本，用面向过程
• 如果你构建的是复杂系统，用面向对象
• 如果你处理的是批量数据，用函数式

理解不同范式的核心差异，能让你在 LLM 开发中既不会为了 “秀技术” 用 OOP 写小脚本，也不会为了 “省时间” 用面向过程写复杂系统。最终目标只有一个：写出易维护、可扩展、符合需求的 LLM 应用。

下一篇我们将学习《Python 文件 IO：LLM 语料与对话历史的持久化》，讲解如何在面向对象的 LLM 系统中实现数据持久化。