7步掌握封装继承与Python调用大模型：从面向对象到AI实战

图1：封装继承与Python调用大模型 零基础学习框架与核心知识点

一、基础铺垫：面向对象与大模型调用核心概念

面向对象编程（OOP）是Python进阶的核心，封装、继承是其两大核心特性，能大幅提升代码的复用性、可读性和可维护性；而Python调用大模型，是将面向对象思想落地到AI应用的热门场景，无需深入理解大模型原理，即可快速实现AI对话、文本生成等功能。

# 核心概念梳理（小白必记）
1.  面向对象编程：以「对象」为核心，将数据和操作数据的方法封装在一起
2.  封装：隐藏对象内部细节，只对外提供可调用的接口，避免数据被误修改
3.  继承：子类继承父类的属性和方法，同时可自定义新增属性/方法，减少代码冗余
4.  Python调用大模型：通过大模型API，用Python代码实现AI交互
5.  核心关联：用封装思想封装大模型调用逻辑，用继承扩展大模型功能，提升代码复用性

• 解释型语言适配：Python解释型特性，可在Jupyter中逐行运行大模型调用代码，实时查看响应结果
• 大小写敏感：类名、方法名、变量名区分大小写，如LLMBase和llmbase是两个不同类，新手需注意
• 缩进规范：类、方法、循环/条件语句需严格缩进（4个空格），是Python面向对象编程的核心规范
• 注释规则：单行注释用#，多行注释用”””注释内容”””，封装/继承代码逻辑复杂，需多写注释提升可读性

Jupyter中准备大模型调用环境（快速上手）

# 第一步：启动Anaconda+Jupyter
conda activate myenv
jupyter notebook

# 第二步：安装大模型调用必备库
pip install requests

# 第三步：获取大模型API密钥（各大平台均可）
# 注册AI开放平台 → 创建应用 → 复制API Key
print("大模型调用环境准备完成！")

二、Python面向对象核心：封装的实现与用法

封装是面向对象的第一步，核心是「将数据和方法封装到类中」，通过访问控制隐藏内部细节，对外提供简洁的调用接口。Python中无需严格的访问控制关键字，通过命名规范实现封装，是大模型调用逻辑封装的基础。

1. 封装的基本语法（类与对象）

# 封装核心：定义类，将属性（数据）和方法（操作）封装在一起
class 类名():
    # 初始化方法：创建对象时自动执行
    def __init__(self, 属性1, 属性2):
        self.属性1 = 属性1  # 公有属性
        self.__属性2 = 属性2 # 私有属性（双下划线开头）
    
    # 自定义方法
    def 方法名(self, 参数):
        return f"属性1：{self.属性1}"

# 创建对象
对象名 = 类名(属性1值, 属性2值)

# 调用
print(对象名.属性1)
print(对象名.方法名(参数))

2. 封装实战：封装大模型调用基础类

import requests
import json

# 封装大模型基础调用类
class LLMBase:
    def __init__(self, api_key):
        self.api_key = api_key
        self.url = "https://api.example.com/v1/chat/completions"
    
    # 发送请求获取响应
    def get_response(self, prompt):
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        data = {
            "model": "default",
            "messages": [{"role": "user", "content": prompt}]
        }
        try:
            response = requests.post(self.url, headers=headers, json=data)
            result = response.json()
            return result["choices"][0]["message"]["content"]
        except Exception as e:
            return f"调用失败：{str(e)}"

# 使用
llm = LLMBase(api_key="你的API密钥")
print(llm.get_response("什么是Python封装"))

三、Python面向对象核心：继承的实现与用法

继承是在封装的基础上，实现代码复用的核心特性。子类继承父类的所有公有属性和方法，同时可自定义新增功能，避免重复编写相同代码，特别适合扩展大模型调用功能。

1. 继承的基本语法

# 父类
class Parent:
    def __init__(self, name):
        self.name = name
    def show(self):
        return f"名称：{self.name}"

# 子类继承父类
class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)  # 调用父类初始化
        self.age = age
    
    # 新增方法
    def show_age(self):
        return f"年龄：{self.age}"

# 使用
child = Child("AI工具", 1)
print(child.show())
print(child.show_age())

2. 继承实战：扩展大模型功能

# 继承基础大模型类，扩展连续对话功能
class AdvancedLLM(LLMBase):
    def __init__(self, api_key):
        super().__init__(api_key)
        self.history = []  # 对话历史
    
    # 带历史的连续对话
    def chat(self, prompt):
        self.history.append({"role": "user", "content": prompt})
        res = super().get_response(prompt)
        self.history.append({"role": "assistant", "content": res})
        return res

# 使用
ai = AdvancedLLM("你的API密钥")
print(ai.chat("什么是继承"))
print(ai.chat("它和封装的区别"))

四、大模型调用进阶：参数配置与生成控制

掌握封装继承后，进一步优化大模型调用逻辑，学习核心参数配置（控制生成效果），让大模型输出更符合需求，适配对话、写作、代码生成等不同场景。

# 带参数配置的高级大模型类
class LLMAdvanced(LLMBase):
    def __init__(self, api_key):
        super().__init__(api_key)
        # 核心参数
        self.temperature = 0.7  # 随机性
        self.max_tokens = 512   # 长度
    
    # 自定义参数调用
    def chat_with_config(self, prompt, temperature=0.7):
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        data = {
            "model": "default",
            "messages": [{"role": "user", "content": prompt}],
            "temperature": temperature,
            "max_tokens": self.max_tokens
        }
        response = requests.post(self.url, headers=headers, json=data)
        return response.json()["choices"][0]["message"]["content"]

# 严谨模式 / 创意模式
print(LLMAdvanced("key").chat_with_config("解释封装", temperature=0.2))

五、完整实战案例：封装继承+大模型综合应用

结合以上所有核心知识点，编写一个「AI对话工具」实战案例，整合封装、继承、大模型调用、参数配置，实现连续对话、文本生成、响应格式化功能，在Jupyter中直接运行。

# 完整实战：AI对话助手
import requests

class LLMBase:
    def __init__(self, api_key):
        self.api_key = api_key
        self.url = "https://api.example.com/v1/chat/completions"
    
    def get_response(self, prompt):
        try:
            headers = {"Authorization": f"Bearer {self.api_key}"}
            data = {"model": "default", "messages": [{"role":"user","content":prompt}]}
            res = requests.post(self.url, headers=headers, json=data)
            return res.json()["choices"][0]["message"]["content"]
        except:
            return "请求失败"

class AIAssistant(LLMBase):
    def __init__(self, api_key):
        super().__init__(api_key)
        self.chat_history = []
    
    def talk(self, msg):
        self.chat_history.append(f"用户：{msg}")
        reply = self.get_response(msg)
        self.chat_history.append(f"AI：{reply}")
        return reply

# 运行测试
ai = AIAssistant("你的API密钥")
print(ai.talk("用Python写一个HelloWorld"))

在实际开发中，我们还可以基于这套封装继承的架构，进一步扩展更多实用功能：比如给AI对话工具添加角色设定，让大模型以「Python技术专家」「代码调试助手」的身份回复；或者接入多轮对话记忆、上下文理解，让AI工具更智能。同时，我们也可以参考Python官方面向对象文档，深入学习类与对象的高级用法，让代码更规范、更健壮。

对于新手来说，学习这套技术的最佳路径是：先跑通基础的大模型调用代码，再逐步用封装隐藏细节，用继承扩展功能，每一步都在Jupyter中验证效果，遇到报错优先排查缩进、API密钥、依赖库这三个高频问题，就能快速上手，从Python基础顺利过渡到AI应用开发。

图2：封装继承+大模型调用实战案例Jupyter运行效果

六、新手避坑指南（100%高频踩坑）

七、学习路线与总结