本节课你将学到

• 理解什么是API以及为什么要用AI API
• 学会申请和配置DeepSeek API密钥
• 掌握Python调用AI API的基本方法
• 实现一个智能问答系统
• 处理API调用中的常见问题

开始之前

环境要求

• Python 3.8+
• 网络连接（用于API调用）
• 一个DeepSeek账号（免费注册）

需要安装的包

pip install openai requests python-dotenv

前置知识

• 第1讲：Python开发环境配置
• 第2讲：Jupyter Notebook使用
• 基本的Python语法

核心概念

什么是API？

API就像餐厅的菜单和服务员：

传统编程：你要自己买菜、洗菜、做菜

• 就像自己训练AI模型，需要大量数据和计算资源

使用AI API：你只需要点菜，厨房直接给你做好的菜

• 就像调用AI服务，直接获得智能对话、文本生成的能力

为什么选择DeepSeek？

DeepSeek是国产优秀的AI服务商，具有以下优势：

• 价格便宜：比国外服务更实惠
• 响应快速：服务器在国内，访问速度快
• 中文友好：对中文理解更准确
• 免费额度：新用户有免费使用额度

API调用的基本流程

1. 准备问题（用户输入）
2. 发送HTTP请求到AI服务器
3. AI处理问题并生成回答
4. 接收并展示回答

代码实战

步骤1：获取API密钥

1. 访问 DeepSeek官网
2. 注册账号并登录
3. 进入"API密钥"页面
4. 创建新的API密钥
5. 重要：复制并保存密钥（只显示一次）

步骤2：安全存储API密钥

创建一个.env文件来安全存储密钥：

# .env 文件内容
DEEPSEEK_API_KEY=你的API密钥

⚠️ 安全提醒：

• 不要把API密钥直接写在代码里
• 不要把.env文件上传到GitHub等公开平台
• 定期更换API密钥

步骤3：基础API调用

# 导入必要的库
import os
from openai import OpenAI  # OpenAI库兼容DeepSeek API
from dotenv import load_dotenv  # 用于加载环境变量

# 加载环境变量
load_dotenv()  # 从.env文件加载配置

# 初始化客户端
# DeepSeek API与OpenAI兼容，所以可以使用OpenAI的Python库
client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),  # 从环境变量获取密钥
    base_url="https://api.deepseek.com"     # DeepSeek的API地址
)

def ask_ai(question):
    """
    向AI提问并获取回答
    
    参数:
        question (str): 要提问的问题
    
    返回:
        str: AI的回答
    """
    try:
        # 发送请求到AI服务
        response = client.chat.completions.create(
            model="deepseek-chat",  # DeepSeek的对话模型
            messages=[
                {
                    "role": "user",        # 角色：用户
                    "content": question    # 问题内容
                }
            ],
            max_tokens=1000,      # 最大回复长度
            temperature=0.7       # 创造性程度（0-1，越高越有创意）
        )
        
        # 提取AI的回答
        answer = response.choices[0].message.content
        return answer
        
    except Exception as e:
        return f"发生错误：{str(e)}"

# 测试基础功能
if __name__ == "__main__":
    # 测试问题
    test_question = "请解释什么是人工智能？"
    
    print("问题：", test_question)
    print("正在思考中...")
    
    # 获取AI回答
    answer = ask_ai(test_question)
    print("AI回答：", answer)

步骤4：添加对话历史功能

def chat_with_history(messages):
    """
    支持对话历史的聊天函数
    
    参数:
        messages (list): 对话历史列表
    
    返回:
        str: AI的回答
    """
    try:
        response = client.chat.completions.create(
            model="deepseek-chat",
            messages=messages,      # 传入完整对话历史
            max_tokens=1000,
            temperature=0.7
        )
        
        return response.choices[0].message.content
        
    except Exception as e:
        return f"发生错误：{str(e)}"

# 示例：多轮对话
def demo_conversation():
    """演示多轮对话功能"""
    
    # 对话历史（用列表存储）
    conversation_history = []
    
    print("=== AI助手启动成功 ===")
    print("输入 'quit' 退出对话\n")
    
    while True:
        # 获取用户输入
        user_input = input("你：")
        
        # 检查退出命令
        if user_input.lower() in ['quit', '退出', 'exit']:
            print("再见！")
            break
        
        # 添加用户消息到历史
        conversation_history.append({
            "role": "user",
            "content": user_input
        })
        
        print("AI正在思考...")
        
        # 获取AI回答
        ai_response = chat_with_history(conversation_history)
        
        # 显示AI回答
        print(f"AI助手：{ai_response}\n")
        
        # 添加AI回答到历史
        conversation_history.append({
            "role": "assistant",
            "content": ai_response
        })

# 运行对话演示
if __name__ == "__main__":
    demo_conversation()

步骤5：智能问答系统增强版

import json
import time
from datetime import datetime

class SmartQASystem:
    """智能问答系统类"""
    
    def __init__(self):
        """初始化系统"""
        # 加载API配置
        load_dotenv()
        
        # 初始化客户端
        self.client = OpenAI(
            api_key=os.getenv("DEEPSEEK_API_KEY"),
            base_url="https://api.deepseek.com"
        )
        
        # 对话历史
        self.conversation_history = []
        
        # 系统提示词（定义AI的角色和行为）
        self.system_prompt = {
            "role": "system",
            "content": """你是一个友善、专业的AI助手。请遵循以下原则：
            1. 用简洁明了的语言回答问题
            2. 如果不确定答案，请诚实地说明
            3. 对于复杂问题，可以分步骤解释
            4. 保持礼貌和耐心
            """
        }
        
        # 初始化对话历史（包含系统提示）
        self.conversation_history.append(self.system_prompt)
    
    def ask(self, question):
        """
        提问函数
        
        参数:
            question (str): 用户问题
        
        返回:
            dict: 包含回答和元信息的字典
        """
        start_time = time.time()
        
        # 添加用户问题到历史
        self.conversation_history.append({
            "role": "user", 
            "content": question
        })
        
        try:
            # 调用API
            response = self.client.chat.completions.create(
                model="deepseek-chat",
                messages=self.conversation_history,
                max_tokens=1500,
                temperature=0.7
            )
            
            # 提取回答
            answer = response.choices[0].message.content
            
            # 添加AI回答到历史
            self.conversation_history.append({
                "role": "assistant",
                "content": answer
            })
            
            # 计算响应时间
            response_time = time.time() - start_time
            
            # 返回结果
            return {
                "success": True,
                "answer": answer,
                "response_time": round(response_time, 2),
                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                "tokens_used": response.usage.total_tokens if hasattr(response, 'usage') else 0
            }
            
        except Exception as e:
            return {
                "success": False,
                "error": str(e),
                "response_time": time.time() - start_time,
                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            }
    
    def save_conversation(self, filename="conversation_log.json"):
        """保存对话记录"""
        try:
            with open(filename, 'w', encoding='utf-8') as f:
                json.dump(self.conversation_history, f, ensure_ascii=False, indent=2)
            print(f"对话记录已保存到 {filename}")
        except Exception as e:
            print(f"保存失败：{e}")
    
    def load_conversation(self, filename="conversation_log.json"):
        """加载对话记录"""
        try:
            with open(filename, 'r', encoding='utf-8') as f:
                self.conversation_history = json.load(f)
            print(f"对话记录已从 {filename} 加载")
        except FileNotFoundError:
            print("未找到对话记录文件")
        except Exception as e:
            print(f"加载失败：{e}")
    
    def clear_history(self):
        """清空对话历史（保留系统提示）"""
        self.conversation_history = [self.system_prompt]
        print("对话历史已清空")
    
    def get_stats(self):
        """获取对话统计信息"""
        user_messages = len([m for m in self.conversation_history if m["role"] == "user"])
        ai_messages = len([m for m in self.conversation_history if m["role"] == "assistant"])
        
        return {
            "total_messages": len(self.conversation_history) - 1,  # 减去系统提示
            "user_messages": user_messages,
            "ai_messages": ai_messages
        }

# 使用示例
def main():
    """主程序"""
    # 创建智能问答系统
    qa_system = SmartQASystem()
    
    print("=== 智能问答系统 v1.0 ===")
    print("支持的命令：")
    print("- 直接输入问题进行对话")
    print("- 'stats' - 查看统计信息")
    print("- 'save' - 保存对话记录")
    print("- 'load' - 加载对话记录") 
    print("- 'clear' - 清空对话历史")
    print("- 'quit' - 退出系统")
    print("-" * 40)
    
    while True:
        try:
            user_input = input("\n你：").strip()
            
            if not user_input:
                continue
                
            # 处理特殊命令
            if user_input.lower() == 'quit':
                print("谢谢使用，再见！")
                break
            elif user_input.lower() == 'stats':
                stats = qa_system.get_stats()
                print(f"📊 对话统计：")
                print(f"   总消息数：{stats['total_messages']}")
                print(f"   用户消息：{stats['user_messages']}")
                print(f"   AI回复：{stats['ai_messages']}")
                continue
            elif user_input.lower() == 'save':
                qa_system.save_conversation()
                continue
            elif user_input.lower() == 'load':
                qa_system.load_conversation()
                continue
            elif user_input.lower() == 'clear':
                qa_system.clear_history()
                continue
            
            # 处理普通问题
            print("🤔 AI正在思考...")
            result = qa_system.ask(user_input)
            
            if result["success"]:
                print(f"\n🤖 AI助手：{result['answer']}")
                print(f"⏱️ 响应时间：{result['response_time']}秒")
                if result['tokens_used'] > 0:
                    print(f"🔢 使用tokens：{result['tokens_used']}")
            else:
                print(f"❌ 出现错误：{result['error']}")
                
        except KeyboardInterrupt:
            print("\n\n程序被用户中断")
            break
        except Exception as e:
            print(f"❌ 程序异常：{e}")

if __name__ == "__main__":
    main()

完整项目

创建项目文件夹结构：

lesson_07_openai_api/
├── README.md
├── requirements.txt
├── .env.example
├── main.py
├── qa_system.py
└── examples/
    ├── basic_example.py
    ├── conversation_example.py
    └── advanced_example.py

main.py（主程序文件）

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
第7讲：OpenAI API使用 - 智能问答系统
实现一个完整的AI问答助手

作者：AI实战60讲
日期：2025年
"""

import os
import sys
import json
import time
from datetime import datetime
from openai import OpenAI
from dotenv import load_dotenv

class DeepSeekQA:
    """DeepSeek智能问答系统"""
    
    def __init__(self):
        """初始化系统"""
        print("🚀 正在初始化DeepSeek智能问答系统...")
        
        # 加载环境变量
        load_dotenv()
        
        # 检查API密钥
        api_key = os.getenv("DEEPSEEK_API_KEY")
        if not api_key:
            print("❌ 错误：未找到DEEPSEEK_API_KEY")
            print("请检查.env文件是否正确配置")
            sys.exit(1)
        
        # 初始化客户端
        try:
            self.client = OpenAI(
                api_key=api_key,
                base_url="https://api.deepseek.com"
            )
            print("✅ DeepSeek客户端初始化成功")
        except Exception as e:
            print(f"❌ 客户端初始化失败：{e}")
            sys.exit(1)
        
        # 初始化对话历史
        self.reset_conversation()
        
        # 统计信息
        self.stats = {
            "total_questions": 0,
            "total_tokens": 0,
            "session_start": datetime.now()
        }
    
    def reset_conversation(self):
        """重置对话历史"""
        self.conversation_history = [
            {
                "role": "system",
                "content": """你是一个专业、友善的AI助手。请遵循以下准则：
1. 用清晰、准确的中文回答问题
2. 对于不确定的信息，请诚实说明
3. 提供实用、可行的建议
4. 保持耐心和礼貌的态度
5. 必要时可以要求澄清问题"""
            }
        ]
    
    def ask(self, question):
        """
        向AI提问
        
        参数:
            question (str): 用户问题
            
        返回:
            dict: 包含回答和元信息
        """
        if not question.strip():
            return {"success": False, "error": "问题不能为空"}
        
        start_time = time.time()
        
        # 添加用户问题
        self.conversation_history.append({
            "role": "user",
            "content": question.strip()
        })
        
        try:
            # 调用API
            response = self.client.chat.completions.create(
                model="deepseek-chat",
                messages=self.conversation_history,
                max_tokens=2000,
                temperature=0.7,
                stream=False
            )
            
            # 提取回答
            answer = response.choices[0].message.content
            tokens_used = response.usage.total_tokens
            
            # 添加AI回答到历史
            self.conversation_history.append({
                "role": "assistant", 
                "content": answer
            })
            
            # 更新统计
            self.stats["total_questions"] += 1
            self.stats["total_tokens"] += tokens_used
            
            return {
                "success": True,
                "answer": answer,
                "tokens": tokens_used,
                "response_time": round(time.time() - start_time, 2)
            }
            
        except Exception as e:
            return {
                "success": False,
                "error": str(e),
                "response_time": round(time.time() - start_time, 2)
            }
    
    def show_stats(self):
        """显示统计信息"""
        session_time = datetime.now() - self.stats["session_start"]
        hours, remainder = divmod(session_time.seconds, 3600)
        minutes, seconds = divmod(remainder, 60)
        
        print(f"\n📊 会话统计信息")
        print(f"{'='*30}")
        print(f"🕐 会话时长：{hours:02d}:{minutes:02d}:{seconds:02d}")
        print(f"❓ 提问次数：{self.stats['total_questions']}")
        print(f"🔢 使用Tokens：{self.stats['total_tokens']:,}")
        print(f"💬 对话轮数：{(len(self.conversation_history)-1)//2}")
        
        if self.stats['total_questions'] > 0:
            avg_tokens = self.stats['total_tokens'] // self.stats['total_questions']
            print(f"📈 平均每问Tokens：{avg_tokens}")
    
    def save_conversation(self, filename=None):
        """保存对话记录"""
        if filename is None:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"conversation_{timestamp}.json"
        
        try:
            # 准备保存数据
            save_data = {
                "metadata": {
                    "session_start": self.stats["session_start"].isoformat(),
                    "save_time": datetime.now().isoformat(),
                    "total_questions": self.stats["total_questions"],
                    "total_tokens": self.stats["total_tokens"]
                },
                "conversation": self.conversation_history[1:]  # 排除系统提示
            }
            
            # 创建输出目录
            os.makedirs("output", exist_ok=True)
            filepath = os.path.join("output", filename)
            
            # 保存文件
            with open(filepath, 'w', encoding='utf-8') as f:
                json.dump(save_data, f, ensure_ascii=False, indent=2)
            
            print(f"✅ 对话记录已保存到：{filepath}")
            
        except Exception as e:
            print(f"❌ 保存失败：{e}")
    
    def run(self):
        """运行主程序"""
        print("\n🎉 DeepSeek智能问答系统启动成功！")
        print("\n可用命令：")
        print("  📝 直接输入问题开始对话")
        print("  📊 输入 'stats' 查看统计信息")
        print("  💾 输入 'save' 保存对话记录")
        print("  🔄 输入 'reset' 重置对话历史")
        print("  🚪 输入 'quit' 或 'exit' 退出系统")
        print("="*50)
        
        while True:
            try:
                # 获取用户输入
                user_input = input("\n💭 你的问题：").strip()
                
                if not user_input:
                    continue
                
                # 处理命令
                if user_input.lower() in ['quit', 'exit', '退出']:
                    print("\n👋 感谢使用DeepSeek智能问答系统！")
                    if self.stats["total_questions"] > 0:
                        self.show_stats()
                    break
                
                elif user_input.lower() == 'stats':
                    self.show_stats()
                    continue
                
                elif user_input.lower() == 'save':
                    self.save_conversation()
                    continue
                
                elif user_input.lower() == 'reset':
                    self.reset_conversation()
                    self.stats["total_questions"] = 0
                    self.stats["total_tokens"] = 0
                    print("🔄 对话历史已重置")
                    continue
                
                # 处理问题
                print("🤔 AI正在思考中...")
                result = self.ask(user_input)
                
                if result["success"]:
                    print(f"\n🤖 DeepSeek：{result['answer']}")
                    print(f"\n⚡ 响应时间：{result['response_time']}秒 | "
                          f"🔢 本次tokens：{result['tokens']}")
                else:
                    print(f"\n❌ 出现错误：{result['error']}")
                    if "API" in result['error']:
                        print("💡 请检查：")
                        print("  1. 网络连接是否正常")
                        print("  2. API密钥是否正确")
                        print("  3. 是否还有剩余额度")
                
            except KeyboardInterrupt:
                print("\n\n⚠️ 检测到中断信号")
                save_choice = input("是否保存当前对话？(y/n): ").lower()
                if save_choice in ['y', 'yes', '是']:
                    self.save_conversation()
                print("再见！")
                break
                
            except Exception as e:
                print(f"\n❌ 程序异常：{e}")
                continue

def check_environment():
    """检查运行环境"""
    print("🔍 正在检查运行环境...")
    
    # 检查Python版本
    if sys.version_info < (3, 8):
        print("❌ Python版本过低，需要Python 3.8+")
        return False
    
    # 检查必要的包
    required_packages = ['openai', 'python-dotenv']
    missing_packages = []
    
    for package in required_packages:
        try:
            __import__(package.replace('-', '_'))
        except ImportError:
            missing_packages.append(package)
    
    if missing_packages:
        print(f"❌ 缺少依赖包：{', '.join(missing_packages)}")
        print(f"请运行：pip install {' '.join(missing_packages)}")
        return False
    
    # 检查.env文件
    if not os.path.exists('.env'):
        print("⚠️ 未找到.env文件")
        print("请创建.env文件并添加DEEPSEEK_API_KEY=你的密钥")
        
        # 创建示例文件
        with open('.env.example', 'w') as f:
            f.write("# DeepSeek API配置\n")
            f.write("DEEPSEEK_API_KEY=你的API密钥\n")
        print("已创建.env.example文件作为模板")
        return False
    
    print("✅ 环境检查通过")
    return True

def main():
    """主函数"""
    print("🚀 AI实战60讲 - 第7讲：OpenAI API使用")
    print("🎯 目标：学会使用DeepSeek API构建智能问答系统")
    print("="*60)
    
    # 检查环境
    if not check_environment():
        return
    
    # 启动系统
    try:
        qa_system = DeepSeekQA()
        qa_system.run()
    except Exception as e:
        print(f"❌ 系统启动失败：{e}")

if __name__ == "__main__":
    main()

requirements.txt

# 第7讲：OpenAI API使用 - 依赖包列表

# 核心依赖
openai>=1.0.0              # OpenAI官方SDK（兼容DeepSeek）
python-dotenv>=1.0.0       # 环境变量管理
requests>=2.28.0           # HTTP请求库

# 可选依赖（用于增强功能）
rich>=13.0.0               # 美化控制台输出
colorama>=0.4.6            # 跨平台彩色终端

# 开发工具（可选）
jupyter>=1.0.0             # Jupyter Notebook
ipython>=8.0.0             # 增强的Python交互环境

# 安装命令：
# pip install -r requirements.txt

.env.example

# DeepSeek API配置示例
# 复制此文件为.env并填入真实的API密钥

# DeepSeek API密钥
# 获取地址：https://platform.deepseek.com/
DEEPSEEK_API_KEY=你的DeepSeek_API密钥

# 可选配置
# API_BASE_URL=https://api.deepseek.com
# DEFAULT_MODEL=deepseek-chat
# MAX_TOKENS=2000
# TEMPERATURE=0.7

运行效果

控制台输出示例

🚀 AI实战60讲 - 第7讲：OpenAI API使用
🎯 目标：学会使用DeepSeek API构建智能问答系统
============================================================
🔍 正在检查运行环境...
✅ 环境检查通过
🚀 正在初始化DeepSeek智能问答系统...
✅ DeepSeek客户端初始化成功

🎉 DeepSeek智能问答系统启动成功！

可用命令：
  📝 直接输入问题开始对话
  📊 输入 'stats' 查看统计信息  
  💾 输入 'save' 保存对话记录
  🔄 输入 'reset' 重置对话历史
  🚪 输入 'quit' 或 'exit' 退出系统
==================================================

💭 你的问题：什么是机器学习？
🤔 AI正在思考中...

🤖 DeepSeek：机器学习是人工智能的一个重要分支，它让计算机能够从数据中自动学习和改进，而无需被明确编程。

简单来说，机器学习就像教孩子认东西的过程：
- 传统编程：我们告诉计算机具体的规则和步骤
- 机器学习：我们给计算机大量的数据样本，让它自己发现规律

主要类型包括：
1. **监督学习**：有标准答案的学习，比如垃圾邮件识别
2. **无监督学习**：没有标准答案，自己发现规律，比如客户分群
3. **强化学习**：通过试错来学习，比如游戏AI

机器学习广泛应用于推荐系统、图像识别、语音识别等领域，正在改变我们的生活方式。

⚡ 响应时间：1.23秒 | 🔢 本次tokens：156

💭 你的问题：stats

📊 会话统计信息
==============================
🕐 会话时长：00:02:15
❓ 提问次数：1
🔢 使用Tokens：156
💬 对话轮数：1
📈 平均每问Tokens：156

生成的文件

运行程序后会生成：

• output/conversation_20250623_143052.json: 对话记录文件

对话记录JSON格式示例

{
  "metadata": {
    "session_start": "2025-06-23T14:30:45",
    "save_time": "2025-06-23T14:35:12", 
    "total_questions": 3,
    "total_tokens": 445
  },
  "conversation": [
    {
      "role": "user",
      "content": "什么是机器学习？"
    },
    {
      "role": "assistant", 
      "content": "机器学习是人工智能的一个重要分支，它让计算机能够从数据中自动学习和改进..."
    },
    {
      "role": "user",
      "content": "能举个具体的例子吗？"
    },
    {
      "role": "assistant",
      "content": "当然可以！让我举几个生活中常见的例子..."
    }
  ]
}

常见问题

Q1: 出现 “Invalid API key” 错误

原因： API密钥配置错误或已过期

解决方法：

1. 检查.env文件中的密钥是否正确
2. 确认密钥没有多余的空格或换行符
3. 登录DeepSeek平台检查密钥状态
4. 如果密钥过期，重新生成新密钥

# 调试代码：检查API密钥
import os
from dotenv import load_dotenv

load_dotenv()
api_key = os.getenv("DEEPSEEK_API_KEY")
print(f"API密钥长度: {len(api_key) if api_key else 0}")
print(f"API密钥前10位: {api_key[:10] if api_key else 'None'}")

Q2: 网络连接超时

原因： 网络问题或防火墙限制

解决方法：

# 添加超时和重试机制
import time

def ask_with_retry(client, messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="deepseek-chat",
                messages=messages,
                timeout=30  # 30秒超时
            )
            return response
        except Exception as e:
            print(f"第{attempt+1}次尝试失败: {e}")
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)  # 指数退避
            else:
                raise e

Q3: 返回结果为空或不完整

原因： max_tokens设置过小或模型参数不当

解决方法：

# 优化参数设置
response = client.chat.completions.create(
    model="deepseek-chat",
    messages=messages,
    max_tokens=2000,        # 增加最大token数
    temperature=0.7,        # 平衡创造性和准确性
    top_p=0.9,             # 核心采样
    frequency_penalty=0.1,  # 减少重复
    presence_penalty=0.1    # 鼓励多样性
)

Q4: 费用消耗过快

原因： 对话历史过长或频繁调用

解决方法：

def manage_conversation_length(conversation_history, max_length=20):
    """管理对话历史长度，避免token消耗过多"""
    if len(conversation_history) > max_length:
        # 保留系统提示和最近的对话
        system_msg = conversation_history[0]
        recent_msgs = conversation_history[-(max_length-1):]
        conversation_history = [system_msg] + recent_msgs
    return conversation_history

# 使用示例
self.conversation_history = manage_conversation_length(
    self.conversation_history, 
    max_length=10
)

Q5: 中文回答质量不佳

原因： 系统提示词不够明确

解决方法：

# 优化中文系统提示词
system_prompt = {
    "role": "system", 
    "content": """你是一个专业的中文AI助手，请严格遵循以下要求：

1. 语言要求：
   - 使用标准的简体中文回答
   - 语言自然流畅，符合中文表达习惯
   - 避免机器翻译的生硬表达

2. 回答质量：
   - 内容准确、逻辑清晰
   - 根据问题复杂程度调整回答详细程度
   - 必要时提供具体例子说明

3. 交互方式：
   - 保持友善、耐心的态度
   - 如果问题不清楚，主动要求澄清
   - 承认不确定的信息，不要编造答案
"""
}

课后练习

基础练习

• 修改系统提示词，让AI扮演不同角色（如编程助手、写作助手）
• 添加对话轮数限制功能
• 实现简单的敏感词过滤

进阶练习

• 添加流式输出功能（实时显示AI回答）
• 集成语音识别，实现语音问答
• 添加多模态功能，支持图片输入

项目拓展

• 开发Web界面版本
• 集成多个AI模型，支持模型切换
• 添加知识库功能，实现RAG问答

拓展代码示例：流式输出

def ask_stream(self, question):
    """流式输出版本的问答"""
    self.conversation_history.append({
        "role": "user",
        "content": question
    })
    
    try:
        # 启用流式输出
        stream = self.client.chat.completions.create(
            model="deepseek-chat",
            messages=self.conversation_history,
            max_tokens=2000,
            temperature=0.7,
            stream=True  # 启用流式输出
        )
        
        print("🤖 DeepSeek：", end="", flush=True)
        full_response = ""
        
        # 逐块显示回答
        for chunk in stream:
            if chunk.choices[0].delta.content:
                content = chunk.choices[0].delta.content
                print(content, end="", flush=True)
                full_response += content
        
        print()  # 换行
        
        # 添加完整回答到历史
        self.conversation_history.append({
            "role": "assistant",
            "content": full_response
        })
        
        return {"success": True, "answer": full_response}
        
    except Exception as e:
        return {"success": False, "error": str(e)}

技术扩展

1. 多模型支持

class MultiModelQA:
    """支持多个AI模型的问答系统"""
    
    def __init__(self):
        self.models = {
            "deepseek": {
                "client": OpenAI(
                    api_key=os.getenv("DEEPSEEK_API_KEY"),
                    base_url="https://api.deepseek.com"
                ),
                "model_name": "deepseek-chat"
            },
            "openai": {
                "client": OpenAI(api_key=os.getenv("OPENAI_API_KEY")),
                "model_name": "gpt-3.5-turbo"
            }
        }
        self.current_model = "deepseek"
    
    def switch_model(self, model_name):
        """切换模型"""
        if model_name in self.models:
            self.current_model = model_name
            print(f"已切换到 {model_name} 模型")
        else:
            print(f"不支持的模型: {model_name}")

2. 插件系统

class PluginManager:
    """插件管理器"""
    
    def __init__(self):
        self.plugins = {}
    
    def register_plugin(self, name, plugin_func):
        """注册插件"""
        self.plugins[name] = plugin_func
    
    def execute_plugin(self, name, *args, **kwargs):
        """执行插件"""
        if name in self.plugins:
            return self.plugins[name](*args, **kwargs)
        return None

# 示例插件：天气查询
def weather_plugin(city):
    """天气查询插件（示例）"""
    # 这里可以接入真实的天气API
    return f"{city}的天气：晴天，25°C"

# 注册插件
plugin_manager = PluginManager()
plugin_manager.register_plugin("weather", weather_plugin)

---

🎉 恭喜！你已经掌握了AI API的使用方法，可以构建属于自己的智能问答系统了！

下节预告： 第8讲将学习云端开发环境的使用，让你在任何地方都能进行AI开发。