OpenAI API 零基础入门完全指南

📚 适用对象：零基础编程学习者
🎯 学习目标：系统掌握 OpenAI API 的核心使用方法
⏱️ 预计学习时间：2-3 小时
📅 更新时间：2025年2月

一、基础认知

1.1 什么是 OpenAI API

通俗解释：

想象你有一个超级聪明的助手，但这个助手住在云端。OpenAI API 就是你和这个助手沟通的「电话线」——你通过它发送问题，助手通过它返回答案。

技术定义：

OpenAI API 是 OpenAI 公司提供的一套应用程序接口（Application Programming Interface），让开发者可以在自己的程序中调用 GPT、DALL·E、Whisper 等强大的 AI 模型。

┌─────────────────────────────────────────────────────────────┐
│                    OpenAI API 工作原理                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   你的程序          OpenAI API           AI 模型            │
│   ┌─────┐          ┌─────────┐         ┌─────────┐         │
│   │     │ ──请求──▶│         │──处理──▶│  GPT-4o │         │
│   │ App │          │ 云服务器 │         │ DALL·E  │         │
│   │     │ ◀──响应──│         │◀─返回───│ Whisper │         │
│   └─────┘          └─────────┘         └─────────┘         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

核心价值：

✅ 无需自己训练模型（省钱省时间）
✅ 按用量付费（用多少付多少）
✅ 持续更新升级（自动享受最新技术）
✅ 简单易用（几行代码即可调用）

1.2 核心能力一览 ★

OpenAI API 提供了多种强大的 AI 能力，以下是最常用的几种：

能力	说明	典型用途	对应模型
文本生成 ★	根据提示生成文本	写作、翻译、总结、代码生成	GPT-4o、GPT-4o mini
对话 ★	多轮交互式对话	聊天机器人、客服、助手	GPT-4o、GPT-4o mini
图像生成	根据文字描述生成图片	设计、创意、插图	DALL·E 3
语音转文字	将音频转为文本	会议记录、字幕生成	Whisper
文字转语音	将文本转为音频	有声书、语音播报	TTS-1
文本嵌入	将文本转为向量	语义搜索、相似度计算	text-embedding-3
内容审核	检测敏感/不当内容	内容过滤、安全审核	Moderation

💡 新手建议：先从「文本生成」和「对话」开始学习，这是最基础也是最常用的功能。

1.3 主流模型对比 ★

📊 模型对比表

模型	智能程度	速度	价格	上下文长度	推荐场景
GPT-4o ★	⭐⭐⭐⭐⭐	快	中等	128K	复杂任务、专业场景
GPT-4o mini ★	⭐⭐⭐⭐	很快	最便宜	128K	日常任务、高并发
GPT-4 Turbo	⭐⭐⭐⭐⭐	中等	较贵	128K	需要视觉功能的复杂任务
GPT-4	⭐⭐⭐⭐⭐	慢	贵	8K	特殊需求（已不推荐）
GPT-3.5 Turbo	⭐⭐⭐	很快	便宜	16K	已被 GPT-4o mini 替代
o1-preview	⭐⭐⭐⭐⭐+	最慢	最贵	128K	数学、编程、复杂推理
o1-mini	⭐⭐⭐⭐⭐	慢	贵	128K	代码、科学计算

🔍 参数说明

什么是上下文长度（Context Length）？

简单说就是模型能「记住」多少内容
128K ≈ 约 10 万个汉字 ≈ 一本小说的长度
上下文越长，能处理的内容越多

什么是 Token？

Token 是 API 计费的基本单位
1 个英文单词 ≈ 1 个 Token
1 个汉字 ≈ 1-2 个 Token
例如：「你好，世界」≈ 4-6 个 Token

💰 价格参考（2025年）

模型	输入价格（每百万Token）	输出价格（每百万Token）
GPT-4o	~$2.5	~$10
GPT-4o mini	~$0.15	~$0.6
GPT-4 Turbo	~$10	~$30
GPT-3.5 Turbo	~$0.5	~$1.5

⚠️ 价格可能变动，请以官网为准：https://openai.com/pricing

1.4 如何选择合适的模型 ★

                    模型选择决策树
                         │
                    任务复杂吗？
                    ╱         ╲
                  否           是
                  │            │
            需要快速响应？    需要复杂推理？
            ╱      ╲         ╱      ╲
           是      否       是      否
           │       │        │       │
      GPT-4o    GPT-4o   o1系列  GPT-4o
       mini     mini    (preview)

推荐策略：

场景	推荐模型	理由
日常对话、简单问答	GPT-4o mini	便宜、快速、够用
内容创作、翻译写作	GPT-4o	质量更高
代码开发、技术问题	GPT-4o	理解能力强
数学证明、逻辑推理	o1-preview	专门优化推理
学习测试、个人项目	GPT-4o mini	性价比最高

💡 新手建议：从 GPT-4o mini 开始，它是目前性价比最高的选择！

二、实操步骤

2.1 申请 API Key 完整流程 ★

📋 准备工作

邮箱：一个可用的邮箱地址
手机号：用于验证（国内号码可能需要代理）
支付方式：信用卡或借记卡（Visa/Mastercard）

📝 申请步骤

步骤 1：注册账号
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 访问 https://platform.openai.com/signup
2. 选择邮箱注册或 Google/Microsoft 账号登录
3. 完成邮箱验证
4. 填写个人信息

步骤 2：添加支付方式
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 登录后进入 Settings → Billing
2. 点击 "Add payment method"
3. 填写信用卡信息
4. 设置消费限额（建议新手设 $10-20）

步骤 3：创建 API Key
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. 进入 https://platform.openai.com/api-keys
2. 点击 "Create new secret key"
3. 给 Key 起个名字（如 "my-first-key"）
4. ★ 立即复制并保存！关闭后无法再次查看 ★

⚠️ 重要注意事项

注意项	说明
Key 只显示一次	创建后立即复制保存，关闭窗口后无法再看
设置消费限额	Settings → Limits → 设置月度限额，防止超支
不要泄露 Key	不要把 Key 写在代码里提交到 GitHub
定期轮换	建议每 3-6 个月更换一次 Key
新账号有免费额度	新注册可能有 $5-18 的免费额度（政策变动中）

2.2 Python 环境安装

步骤 1：确认 Python 版本

bash

# 在终端/命令行中执行
python --version
# 或
python3 --version

# 要求：Python 3.8 或更高版本

步骤 2：安装 OpenAI 官方库

bash

# 使用 pip 安装（推荐）
pip install openai

# 或使用 pip3
pip3 install openai

# 如果安装慢，可以使用国内镜像
pip install openai -i https://pypi.tuna.tsinghua.edu.cn/simple

步骤 3：配置 API Key（三种方式）

方式一：环境变量（推荐） ★

bash

# Linux / macOS - 在终端执行
export OPENAI_API_KEY="sk-你的API密钥"

# 永久生效，添加到 ~/.bashrc 或 ~/.zshrc
echo 'export OPENAI_API_KEY="sk-你的API密钥"' >> ~/.bashrc
source ~/.bashrc

# Windows CMD
set OPENAI_API_KEY=sk-你的API密钥

# Windows PowerShell
$env:OPENAI_API_KEY="sk-你的API密钥"

方式二：.env 文件（项目级）

bash

# 1. 创建 .env 文件
echo 'OPENAI_API_KEY=sk-你的API密钥' > .env

# 2. 安装 python-dotenv
pip install python-dotenv

# 3. 在代码中加载

python

from dotenv import load_dotenv
load_dotenv()  # 自动读取 .env 文件

方式三：代码中直接设置（不推荐）

python

# ⚠️ 仅用于学习测试，不要用于生产环境
from openai import OpenAI
client = OpenAI(api_key="sk-你的API密钥")

2.3 最小可行代码 ★

以下是一个可以直接复制运行的最简单示例：

python

"""
OpenAI API 最小可行代码示例
作用：向 GPT 模型发送一条消息，获取回复
"""

# ===== 第一步：导入库 =====
from openai import OpenAI

# ===== 第二步：创建客户端 =====
# 会自动读取环境变量 OPENAI_API_KEY
client = OpenAI()

# ===== 第三步：发送请求 =====
response = client.chat.completions.create(
    # model: 选择使用的模型
    # "gpt-4o-mini" - 便宜快速，推荐新手使用
    # "gpt-4o" - 更强大，价格稍贵
    model="gpt-4o-mini",
    
    # messages: 对话消息列表
    # 每条消息包含 role（角色）和 content（内容）
    messages=[
        {
            "role": "system",      # system: 设定 AI 的行为/角色
            "content": "你是一个友好的助手，用简洁的中文回答问题。"
        },
        {
            "role": "user",        # user: 用户发送的消息
            "content": "你好！请用一句话介绍一下自己。"
        }
    ],
    
    # temperature: 控制回复的随机性（0-2）
    # 0 = 非常确定/一致，1 = 平衡，2 = 非常随机/创意
    temperature=0.7,
    
    # max_tokens: 限制回复的最大长度
    # 防止回复太长导致费用过高
    max_tokens=500
)

# ===== 第四步：获取回复 =====
# response.choices[0].message.content 是 AI 的回复文本
reply = response.choices[0].message.content
print("AI 回复:", reply)

运行结果示例：

AI 回复: 你好！我是一个AI助手，随时准备帮你解答问题、聊天或完成各种任务。

2.4 响应结构解析 ★

当你发送请求后，OpenAI 返回的是一个结构化的响应对象：

python

# 完整响应结构
{
    "id": "chatcmpl-abc123...",           # 本次请求的唯一ID
    "object": "chat.completion",           # 对象类型
    "created": 1707123456,                 # 创建时间戳
    "model": "gpt-4o-mini-2024-07-18",    # 实际使用的模型版本
    "choices": [                           # 回复列表（通常只有1个）
        {
            "index": 0,                    # 回复索引
            "message": {
                "role": "assistant",       # 角色：AI助手
                "content": "AI的回复内容"   # ★ 这是你需要的回复文本
            },
            "finish_reason": "stop"        # 停止原因
        }
    ],
    "usage": {                             # ★ Token 使用统计（计费相关）
        "prompt_tokens": 25,               # 输入消耗的 Token
        "completion_tokens": 30,           # 输出消耗的 Token  
        "total_tokens": 55                 # 总 Token 数
    }
}

常用取值方式：

python

# 获取 AI 回复的文本
reply_text = response.choices[0].message.content

# 获取 Token 使用量（用于计算成本）
input_tokens = response.usage.prompt_tokens
output_tokens = response.usage.completion_tokens
total_tokens = response.usage.total_tokens

# 获取停止原因
# "stop" = 正常结束
# "length" = 达到 max_tokens 限制
# "content_filter" = 内容被过滤
finish_reason = response.choices[0].finish_reason

三、核心场景

3.1 简单对话机器人

以下是一个单轮对话的完整示例：

python

"""
简单对话机器人 - 单轮对话版本
用户输入问题，AI 返回回答
"""

from openai import OpenAI

def chat_once(user_message: str) -> str:
    """
    发送一条消息，获取 AI 回复
    
    参数:
        user_message: 用户输入的问题
    返回:
        AI 的回复文本
    """
    client = OpenAI()
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "你是一个友好、乐于助人的AI助手。"},
            {"role": "user", "content": user_message}
        ],
        temperature=0.7,
        max_tokens=1000
    )
    
    return response.choices[0].message.content


# ===== 使用示例 =====
if __name__ == "__main__":
    # 简单测试
    question = "Python 和 JavaScript 有什么区别？"
    answer = chat_once(question)
    
    print(f"问题: {question}")
    print(f"回答: {answer}")

3.2 多轮对话实现 ★

多轮对话的关键是保存对话历史，让 AI 能够理解上下文：

python

"""
多轮对话机器人 - 支持上下文记忆
核心原理：将历史对话作为 messages 一起发送
"""

from openai import OpenAI

class ChatBot:
    """
    多轮对话机器人类
    
    使用方法:
        bot = ChatBot()
        bot.chat("你好")
        bot.chat("我叫小明")
        bot.chat("我叫什么名字？")  # AI 能记住你叫小明
    """
    
    def __init__(self, system_prompt: str = None):
        """
        初始化聊天机器人
        
        参数:
            system_prompt: 系统提示词，定义 AI 的角色和行为
        """
        self.client = OpenAI()
        
        # 默认系统提示词
        if system_prompt is None:
            system_prompt = """你是一个友好、专业的AI助手。
请遵循以下规则：
1. 用简洁清晰的中文回答
2. 如果不确定，诚实地说"我不确定"
3. 记住用户之前说过的内容"""
        
        # ★ 核心：对话历史列表
        # 每次对话都会把历史记录一起发送给 API
        self.messages = [
            {"role": "system", "content": system_prompt}
        ]
    
    def chat(self, user_input: str) -> str:
        """
        发送消息并获取回复
        
        参数:
            user_input: 用户输入的消息
        返回:
            AI 的回复
        """
        # 1. 将用户消息添加到历史
        self.messages.append({
            "role": "user",
            "content": user_input
        })
        
        # 2. 发送请求（包含完整对话历史）
        response = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=self.messages,  # ★ 发送完整历史
            temperature=0.7,
            max_tokens=1000
        )
        
        # 3. 获取 AI 回复
        assistant_message = response.choices[0].message.content
        
        # 4. 将 AI 回复也添加到历史（为了下次对话）
        self.messages.append({
            "role": "assistant",
            "content": assistant_message
        })
        
        # 5. 返回回复
        return assistant_message
    
    def get_history(self) -> list:
        """获取对话历史"""
        return self.messages
    
    def clear_history(self):
        """清空对话历史，保留系统提示"""
        system_prompt = self.messages[0]
        self.messages = [system_prompt]
    
    def get_token_estimate(self) -> int:
        """
        估算当前对话历史的 Token 数量
        简单估算：中文约 2 字符/Token
        """
        total_chars = sum(len(m["content"]) for m in self.messages)
        return total_chars // 2


# ===== 使用示例 =====
if __name__ == "__main__":
    print("=" * 50)
    print("多轮对话机器人示例")
    print("输入 'quit' 退出，输入 'clear' 清空历史")
    print("=" * 50)
    
    bot = ChatBot()
    
    while True:
        # 获取用户输入
        user_input = input("\n你: ").strip()
        
        # 处理特殊命令
        if user_input.lower() == 'quit':
            print("再见！")
            break
        elif user_input.lower() == 'clear':
            bot.clear_history()
            print("[对话历史已清空]")
            continue
        elif not user_input:
            continue
        
        # 发送消息并获取回复
        try:
            reply = bot.chat(user_input)
            print(f"\nAI: {reply}")
            print(f"[预估 Token: {bot.get_token_estimate()}]")
        except Exception as e:
            print(f"\n[错误] {e}")

运行效果：

==================================================
多轮对话机器人示例
输入 'quit' 退出，输入 'clear' 清空历史
==================================================

你: 你好，我叫小明

AI: 你好小明！很高兴认识你。有什么我可以帮助你的吗？
[预估 Token: 45]

你: 我今年25岁，是一名程序员

AI: 很高兴认识你，小明！25岁的程序员正是充满活力和创造力的年纪。你主要使用什么编程语言呢？
[预估 Token: 89]

你: 我叫什么名字？今年多大？

AI: 你叫小明，今年25岁。你是一名程序员。
[预估 Token: 112]

★ 关键原理：每次调用 API 时，把之前的对话历史一起发送，AI 就能「记住」之前说过的内容。

3.3 流式输出实现

流式输出让 AI 的回复像打字一样逐字显示，提升用户体验：

python

"""
流式输出示例 - 打字机效果
回复会逐字显示，而不是等全部生成完再显示
"""

from openai import OpenAI

def chat_stream(user_message: str):
    """
    流式对话 - 打字机效果
    
    参数:
        user_message: 用户输入
    """
    client = OpenAI()
    
    # ★ 关键：添加 stream=True 参数
    stream = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "你是一个友好的助手。"},
            {"role": "user", "content": user_message}
        ],
        temperature=0.7,
        max_tokens=1000,
        stream=True  # ★ 开启流式输出
    )
    
    print("AI: ", end="", flush=True)
    
    # 遍历流式响应
    full_response = ""
    for chunk in stream:
        # 每个 chunk 包含一小段文本
        if chunk.choices[0].delta.content is not None:
            content = chunk.choices[0].delta.content
            print(content, end="", flush=True)  # 立即打印
            full_response += content
    
    print()  # 换行
    return full_response


# ===== 使用示例 =====
if __name__ == "__main__":
    question = "请用3句话介绍一下人工智能的发展历史。"
    print(f"问题: {question}\n")
    chat_stream(question)

效果：回复会像打字一样一个字一个字地显示出来，而不是等待全部生成完毕。

四、避坑指南

4.1 API Key 安全 ★★★

严重程度：🔴 高危

API Key 泄露可能导致：

💸 账户被盗刷，产生高额费用
⚠️ 账号被封禁
🔒 数据安全风险

❌ 错误做法

python

# ❌ 错误1：把 Key 写在代码里
client = OpenAI(api_key="sk-abc123456789...")

# ❌ 错误2：提交到 Git 仓库
# .env 文件没有加入 .gitignore

# ❌ 错误3：在日志中打印
print(f"Using API Key: {api_key}")

✅ 正确做法

python

# ✅ 正确1：使用环境变量
import os
from openai import OpenAI

client = OpenAI()  # 自动读取 OPENAI_API_KEY 环境变量

# ✅ 正确2：使用 .env 文件 + .gitignore
# .env 文件：
# OPENAI_API_KEY=sk-xxx

# .gitignore 文件：
# .env

# ✅ 正确3：检查 Key 是否存在
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
    raise ValueError("请设置 OPENAI_API_KEY 环境变量")

🛡️ 安全检查清单

[ ] API Key 存储在环境变量中
[ ] .env 文件已加入 .gitignore
[ ] 代码中没有硬编码 Key
[ ] 已在 OpenAI 控制台设置消费限额
[ ] 定期检查 API 使用量

4.2 常见错误及解决 ★

错误 1：AuthenticationError（认证失败）

python

# 错误信息
openai.AuthenticationError: Incorrect API key provided

原因及解决：

原因	解决方法
API Key 错误/无效	检查 Key 是否正确复制（注意开头是 `sk-`）
Key 已被撤销	到控制台重新生成
环境变量未设置	检查 `echo $OPENAI_API_KEY`

python

# 调试代码
import os
key = os.getenv("OPENAI_API_KEY")
print(f"Key 前10位: {key[:10] if key else '未设置'}")

错误 2：RateLimitError（频率限制）

python

# 错误信息
openai.RateLimitError: Rate limit reached for gpt-4o-mini

原因及解决：

原因	解决方法
请求太频繁	添加延时：`time.sleep(1)`
账户额度不足	充值或等待下月重置
并发请求太多	控制并发数量

python

import time
from openai import OpenAI

def chat_with_retry(message, max_retries=3):
    """带重试的请求"""
    client = OpenAI()
    
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-4o-mini",
                messages=[{"role": "user", "content": message}]
            )
            return response.choices[0].message.content
        except Exception as e:
            if "rate_limit" in str(e).lower():
                wait_time = 2 ** attempt  # 指数退避：1, 2, 4秒
                print(f"频率限制，等待 {wait_time} 秒后重试...")
                time.sleep(wait_time)
            else:
                raise e
    
    raise Exception("重试次数用尽")

错误 3：InvalidRequestError（请求格式错误）

python

# 错误信息
openai.BadRequestError: Invalid 'messages': empty array

常见原因：

python

# ❌ 错误：messages 为空
messages=[]

# ❌ 错误：缺少 role 或 content
messages=[{"content": "你好"}]

# ❌ 错误：role 值不正确
messages=[{"role": "human", "content": "你好"}]

# ✅ 正确格式
messages=[
    {"role": "system", "content": "你是助手"},
    {"role": "user", "content": "你好"}
]

role 的有效值：

system：系统提示，定义 AI 行为
user：用户消息
assistant：AI 的回复

错误 4：模型不存在

python

# 错误信息
openai.NotFoundError: The model 'gpt-5' does not exist

解决方法：

python

# 可用的模型名称
VALID_MODELS = [
    "gpt-4o",
    "gpt-4o-mini",
    "gpt-4-turbo",
    "gpt-4",
    "gpt-3.5-turbo",
    "o1-preview",
    "o1-mini"
]

# 检查模型是否有效
model = "gpt-4o-mini"
if model not in VALID_MODELS:
    print(f"警告：模型 {model} 可能不存在")

4.3 成本控制技巧 ★

💰 计费原理

费用 = (输入 Token × 输入单价) + (输出 Token × 输出单价)

📊 成本估算示例

场景	输入 Token	输出 Token	GPT-4o-mini 费用	GPT-4o 费用
简单问答	100	200	~$0.0001	~$0.002
长对话（10轮）	2000	3000	~$0.002	~$0.035
文章总结	5000	500	~$0.001	~$0.018

✅ 成本控制最佳实践

python

"""
成本控制工具类
"""

from openai import OpenAI

class CostAwareChat:
    """带成本控制的聊天类"""
    
    # 价格（每百万 Token，以 GPT-4o-mini 为例）
    PRICE_INPUT = 0.15   # $0.15 / 1M tokens
    PRICE_OUTPUT = 0.60  # $0.60 / 1M tokens
    
    def __init__(self, budget_limit: float = 1.0):
        """
        参数:
            budget_limit: 预算上限（美元）
        """
        self.client = OpenAI()
        self.budget_limit = budget_limit
        self.total_cost = 0.0
        self.total_tokens = 0
    
    def chat(self, messages: list, max_tokens: int = 500) -> dict:
        """
        发送消息，同时跟踪成本
        
        返回:
            {"reply": "回复内容", "cost": 本次费用, "tokens": 本次Token}
        """
        # 检查预算
        if self.total_cost >= self.budget_limit:
            raise Exception(f"已达预算上限 ${self.budget_limit}")
        
        response = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            max_tokens=max_tokens
        )
        
        # 计算费用
        input_tokens = response.usage.prompt_tokens
        output_tokens = response.usage.completion_tokens
        
        cost = (input_tokens * self.PRICE_INPUT / 1_000_000 +
                output_tokens * self.PRICE_OUTPUT / 1_000_000)
        
        self.total_cost += cost
        self.total_tokens += response.usage.total_tokens
        
        return {
            "reply": response.choices[0].message.content,
            "cost": cost,
            "total_cost": self.total_cost,
            "tokens": response.usage.total_tokens
        }
    
    def get_stats(self) -> dict:
        """获取使用统计"""
        return {
            "total_cost": f"${self.total_cost:.6f}",
            "total_tokens": self.total_tokens,
            "budget_remaining": f"${self.budget_limit - self.total_cost:.6f}"
        }


# 使用示例
if __name__ == "__main__":
    chat = CostAwareChat(budget_limit=0.01)  # 预算 1 美分
    
    result = chat.chat([
        {"role": "user", "content": "你好"}
    ])
    
    print(f"回复: {result['reply']}")
    print(f"本次费用: ${result['cost']:.6f}")
    print(f"统计: {chat.get_stats()}")

💡 省钱技巧

技巧	说明	效果
使用 GPT-4o-mini	大多数任务足够用	节省 90%+
限制 max_tokens	避免过长回复	节省 30-50%
精简 System Prompt	减少每次请求的输入	节省 10-20%
定期清理对话历史	避免历史过长	节省 50%+
使用 temperature=0	减少无用重试	节省 10-30%

五、速记清单

🚀 30秒速记

OpenAI API 核心要点
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. 模型选择
   └── 日常用 gpt-4o-mini（便宜），复杂用 gpt-4o

2. 核心三要素
   ├── model: 选择模型
   ├── messages: 对话内容（system/user/assistant）
   └── temperature: 随机度（0稳定，1平衡，2创意）

3. 多轮对话
   └── 把历史 messages 一起发送 → AI 就有"记忆"

4. 安全第一
   ├── Key 放环境变量，别写代码里
   └── 设置消费限额，防止超支

5. 费用公式
   └── 费用 = 输入Token×单价 + 输出Token×单价

📋 API 参数速查

参数	类型	必填	说明
`model`	string	✅	模型名称（如 "gpt-4o-mini"）
`messages`	array	✅	对话消息列表
`temperature`	float	❌	随机度 0-2，默认 1
`max_tokens`	int	❌	最大输出长度
`stream`	bool	❌	是否流式输出
`top_p`	float	❌	核采样参数 0-1
`n`	int	❌	生成几个回复
`stop`	array	❌	停止词列表

📝 Messages 格式

python

messages = [
    {"role": "system", "content": "定义AI角色和行为"},
    {"role": "user", "content": "用户的问题"},
    {"role": "assistant", "content": "AI的回复"},
    {"role": "user", "content": "用户的追问"},
    # ... 继续交替
]

六、学习资源

📚 官方资源

资源	链接	说明
OpenAI 官方文档	https://platform.openai.com/docs	最权威的参考
API 参考手册	https://platform.openai.com/docs/api-reference	详细 API 规范
中文翻译文档	https://ai-doc.it-docs.cn	中文友好
Cookbook 示例	https://cookbook.openai.com	实战代码集
官方 Playground	https://platform.openai.com/playground	在线测试工具

🛠️ 推荐工具

工具	用途
Postman	API 请求测试
curl	命令行测试
Python REPL	快速实验
VS Code + Python	开发环境

📖 学习路径

入门（1-2天）
├── 1. 注册账号，获取 API Key
├── 2. 运行最小代码示例
└── 3. 实现简单对话机器人

进阶（3-7天）
├── 1. 理解 Token 和计费
├── 2. 掌握流式输出
├── 3. 学习 Function Calling
└── 4. 了解 RAG 应用

高级（1-2周）
├── 1. 微调自己的模型
├── 2. 构建 AI Agent
├── 3. 优化性能和成本
└── 4. 生产环境部署

附录：完整代码模板

🔧 通用对话模板

python

"""
OpenAI API 通用对话模板
可以直接复制使用
"""

import os
from openai import OpenAI

def create_chat():
    """创建一个聊天客户端"""
    # 检查 API Key
    if not os.getenv("OPENAI_API_KEY"):
        raise ValueError(
            "请设置 OPENAI_API_KEY 环境变量\n"
            "Linux/Mac: export OPENAI_API_KEY='sk-xxx'\n"
            "Windows: set OPENAI_API_KEY=sk-xxx"
        )
    return OpenAI()

def chat(client, messages, model="gpt-4o-mini", **kwargs):
    """
    发送聊天请求
    
    参数:
        client: OpenAI 客户端
        messages: 消息列表
        model: 模型名称
        **kwargs: 其他参数（temperature, max_tokens等）
    """
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        **kwargs
    )
    return response.choices[0].message.content

# ===== 使用示例 =====
if __name__ == "__main__":
    client = create_chat()
    
    messages = [
        {"role": "system", "content": "你是一个有帮助的助手。"},
        {"role": "user", "content": "你好！"}
    ]
    
    reply = chat(client, messages)
    print(reply)

附录B：Chat Completions API 完整参数手册 ★

📡 接口基本信息

接口地址: POST https://api.openai.com/v1/chat/completions

请求头:
├── Authorization: Bearer YOUR_API_KEY
└── Content-Type: application/json

📥 请求参数（Request Parameters）

一、必填参数

参数名	类型	必填	说明
model ★	string	✅	模型名称，如 `gpt-4o`、`gpt-4o-mini`、`gpt-3.5-turbo`
messages ★	array	✅	对话消息列表，是多轮对话的核心

二、messages 字段详解 ★★★

messages 是一个对象数组，每个对象代表对话中的一轮发言：

python

messages = [
    {"role": "system", "content": "系统提示"},
    {"role": "user", "content": "用户消息"},
    {"role": "assistant", "content": "AI回复"},
    {"role": "user", "content": "用户追问"},
    # ... 继续交替
]

角色（role）说明：

角色	说明	使用场景
system	系统提示词	定义 AI 的角色、行为、背景信息（如："你是一个专业的翻译助手"）
user	用户消息	用户发送的问题或指令
assistant	AI 回复	AI 之前的回复，用于多轮对话保持上下文
tool	工具调用结果	Function Calling 场景中返回工具执行结果

Message 对象完整结构：

python

# 基础格式
{"role": "user", "content": "你好"}

# 带名称的格式（可选）
{"role": "user", "content": "你好", "name": "张三"}

# 多模态格式（图片输入，仅部分模型支持）
{
    "role": "user",
    "content": [
        {"type": "text", "text": "这张图片里有什么？"},
        {"type": "image_url", "image_url": {"url": "https://xxx.jpg"}}
    ]
}

三、可选参数 - 输出控制类

参数名	类型	默认值	范围	说明
temperature ★	number	1.0	0-2	控制输出随机性 • 0 = 非常确定/一致 • 1 = 平衡 • 2 = 非常随机/创意
top_p	number	1.0	0-1	核采样参数，与 temperature 二选一 • 0.1 = 只考虑概率最高的 10% tokens
max_tokens ★	integer	模型默认	1-模型上限	限制输出的最大 Token 数 • 防止回复过长、控制成本
max_completion_tokens	integer	-	-	新版参数，同 max_tokens
n	integer	1	1-128	返回几个不同的回复 • 用于生成多个候选答案
stop	string/array	null	-	停止词列表，遇到这些词就停止生成 • 如：`["\n", "###"]`

temperature vs top_p 对比：

┌─────────────────────────────────────────────────────────────┐
│            temperature 和 top_p 的效果对比                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  temperature=0 ──────────────────── temperature=2           │
│       │                                   │                 │
│    确定性强                            随机性强              │
│    事实性任务                          创意性任务            │
│    代码生成                            故事创作              │
│                                                             │
│  ⚠️ 建议：只调整其中一个，不要同时修改两者                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

四、可选参数 - 惩罚与偏置类

参数名	类型	默认值	范围	说明
frequency_penalty	number	0	-2 到 2	频率惩罚：降低重复相同文本的可能性 • 正值 = 减少重复 • 负值 = 增加重复
presence_penalty	number	0	-2 到 2	存在惩罚：鼓励谈论新话题 • 正值 = 更多新话题 • 负值 = 更集中于已有话题
logit_bias	object	null	-	调整特定 token 的出现概率 • 格式：`{token_id: bias_value}`

惩罚参数使用场景：

场景	frequency_penalty	presence_penalty
减少重复啰嗦	0.5 ~ 1.0	0
鼓励发散思维	0	0.5 ~ 1.0
严格跟随格式	-0.5	-0.5
创意写作	0.3	0.6

五、可选参数 - 格式与流式类

参数名	类型	默认值	说明
stream ★	boolean	false	是否流式输出 • true = 打字机效果，逐字返回 • false = 等待全部生成后返回
stream_options	object	null	流式选项 • `{"include_usage": true}` 流式时包含 usage
response_format	object		输出格式 • `{"type": "text"}` 纯文本 • `{"type": "json_object"}` JSON 格式

response_format 使用示例：

python

# 强制输出 JSON 格式
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "你是一个助手，请用 JSON 格式回复"},
        {"role": "user", "content": "列出三种水果"}
    ],
    response_format={"type": "json_object"}  # 强制 JSON 输出
)

# 输出：{"fruits": ["苹果", "香蕉", "橙子"]}

六、可选参数 - 高级功能类

参数名	类型	说明
tools	array	定义可调用的工具/函数列表（Function Calling）
tool_choice	string/object	控制工具调用策略 • `"auto"` 自动决定 • `"none"` 禁止调用 • `{"type": "function", "function": {"name": "xxx"}}` 强制调用
parallel_tool_calls	boolean	是否允许并行调用多个工具
seed	integer	随机种子，用于可重现的输出
user	string	终端用户标识，用于监控和滥用检测
logprobs	boolean	是否返回 token 的对数概率
top_logprobs	integer	返回每个位置最可能的 N 个 token

📤 响应参数（Response Parameters）

完整响应结构

python

{
    "id": "chatcmpl-abc123",           # 请求唯一 ID
    "object": "chat.completion",        # 对象类型
    "created": 1707123456,              # Unix 时间戳（秒）
    "model": "gpt-4o-mini-2024-07-18", # 实际使用的模型版本
    "choices": [                        # 回复列表
        {
            "index": 0,                 # 回复索引
            "message": {                # 消息对象
                "role": "assistant",    # 角色
                "content": "回复内容",   # ★ 核心：AI 的回复文本
                "tool_calls": null      # 工具调用（如果有）
            },
            "finish_reason": "stop",    # 结束原因
            "logprobs": null            # 对数概率（如果请求了）
        }
    ],
    "usage": {                          # ★ Token 使用统计
        "prompt_tokens": 25,            # 输入 Token 数
        "completion_tokens": 30,        # 输出 Token 数
        "total_tokens": 55              # 总 Token 数
    },
    "system_fingerprint": "fp_abc123"   # 系统指纹
}

choices 数组详解

字段	类型	说明
index	integer	当前回复的索引（当 n>1 时有多个）
message	object	消息对象
message.role	string	固定为 `"assistant"`
message.content	string/null	★ AI 的回复文本（主要内容）
message.tool_calls	array/null	工具调用请求（Function Calling 时）
finish_reason	string	结束原因（见下表）
logprobs	object/null	Token 概率信息

finish_reason 取值说明 ★：

值	说明	处理建议
stop	正常结束（遇到停止词或自然结束）	直接使用回复
length	达到 max_tokens 限制	考虑增加 max_tokens 或分段处理
content_filter	内容被安全过滤器拦截	检查输入是否违规
tool_calls	模型请求调用工具	执行工具后继续对话
function_call	旧版函数调用（已废弃）	建议迁移到 tool_calls

usage 对象详解 ★

字段	类型	说明	计费关系
prompt_tokens	integer	输入消耗的 Token 数	按输入价格计费
completion_tokens	integer	输出消耗的 Token 数	按输出价格计费
total_tokens	integer	总 Token 数	总费用 = 输入费用 + 输出费用

费用计算公式：

费用（美元）= prompt_tokens × 输入单价 + completion_tokens × 输出单价

# 以 GPT-4o-mini 为例（假设价格）：
# 输入：$0.15 / 1M tokens = $0.00000015 / token
# 输出：$0.60 / 1M tokens = $0.00000060 / token

示例：prompt_tokens=100, completion_tokens=200
费用 = 100 × 0.00000015 + 200 × 0.00000060 
     = $0.000015 + $0.00012 
     = $0.000135 ≈ ¥0.001

📡 流式响应结构（stream=true）

当 stream=true 时，响应以 Server-Sent Events (SSE) 格式返回：

data: {"id":"chatcmpl-abc","object":"chat.completion.chunk","created":1707123456,"model":"gpt-4o-mini","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}

data: {"id":"chatcmpl-abc","object":"chat.completion.chunk","created":1707123456,"model":"gpt-4o-mini","choices":[{"index":0,"delta":{"content":"你"},"finish_reason":null}]}

data: {"id":"chatcmpl-abc","object":"chat.completion.chunk","created":1707123456,"model":"gpt-4o-mini","choices":[{"index":0,"delta":{"content":"好"},"finish_reason":null}]}

data: {"id":"chatcmpl-abc","object":"chat.completion.chunk","created":1707123456,"model":"gpt-4o-mini","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: [DONE]

流式响应特点：

普通响应	流式响应
`object: "chat.completion"`	`object: "chat.completion.chunk"`
`choices[].message`	`choices[].delta`
一次性返回完整内容	逐块返回增量内容
等待全部生成	实时输出（打字机效果）

流式响应 Python 处理：

python

stream = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "你好"}],
    stream=True
)

full_response = ""
for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        content = chunk.choices[0].delta.content
        print(content, end="", flush=True)  # 实时打印
        full_response += content

📋 参数速查表

常用参数组合推荐

场景	model	temperature	max_tokens	其他
日常对话	gpt-4o-mini	0.7	1000	-
代码生成	gpt-4o	0.2	2000	-
创意写作	gpt-4o	0.9	2000	presence_penalty=0.6
数据提取	gpt-4o-mini	0	500	response_format=json
实时聊天	gpt-4o-mini	0.7	500	stream=true
长文总结	gpt-4o	0.3	1000	-

参数优先级建议

必须设置 ─────────────────────────────────────────────
├── model          → 决定能力和成本
├── messages       → 核心输入
└── max_tokens     → 防止超支

建议设置 ─────────────────────────────────────────────
├── temperature    → 控制创意度
└── stream         → 提升体验

按需设置 ─────────────────────────────────────────────
├── response_format → JSON 输出时
├── stop           → 控制输出格式
├── frequency_penalty → 减少重复
└── tools          → 需要 Function Calling 时

📝 文档版本：v1.1
📅 更新日期：2025年2月
🔗 参考来源：https://ai-doc.it-docs.cn/

补充1

OpenAI 流式响应同样基于 SSE（Server-Sent Events），但逻辑比 Anthropic 更简洁：无「内容块生命周期」概念，所有增量内容都通过统一的 delta 字段返回，单条响应即可独立解析。

一、流式响应的基础格式规则

1. 传输层格式（SSE 通用规则）

和 Anthropic 一致，但结束标识不同：

text

data: <JSON字符串>  # 核心数据行
# 空行分隔不同事件（可选）
data: [DONE]        # 整个流式响应结束的标识（最后一行）

解析步骤：过滤空行 → 去掉 data: 前缀 → 解析 JSON（若剩余内容是 [DONE] 则停止）；
注意：OpenAI 部分老版本接口可能返回 data: {} 空对象，需过滤。

2. 数据层核心字段（所有有效 JSON 都包含）

字段名	必选/可选	含义	取值范围
`object`	必选	响应对象类型	固定为 `chat.completion.chunk`（流式专属）
`choices`	必选	结果数组（仅1个元素，因为 `n=1`）	数组，长度固定为1
`created`	必选	响应创建时间戳	整数（Unix 时间）
`model`	必选	所用模型版本	如 `gpt-4o-2024-05-13`、`gpt-3.5-turbo-0125`

二、核心增量字段（choices 数组内的规则）

OpenAI 把所有增量内容都封装在 choices[0] 里，核心是 delta 和 finish_reason 两个字段，这是解析的关键。

1. choices[0] 固定结构

json

{
  "choices": [
    {
      "index": 0,  // 固定为0（仅1个结果）
      "delta": {<增量内容>},  // 核心：文本/工具调用/函数调用的增量
      "finish_reason": <结束原因>  // null/stop/tool_calls/length等
    }
  ]
}

2. delta 字段的多场景规则

delta 是 OpenAI 流式响应的唯一增量载体，不同场景（纯文本/工具调用/函数调用）对应不同子字段：

场景	delta 内核心字段	示例
纯文本响应	`content`	`"delta": {"content": "你好，"}`
文本响应开始	`role`（仅首次返回）	`"delta": {"role": "assistant", "content": ""}`
文本响应结束	无 `content`（delta 为空）	`"delta": {}`
工具/函数调用启动	`tool_calls`/`function_call`	`"delta": {"tool_calls": [{"index":0, "id":"call_123", "type":"function", "function":{"name":"get_weather"}}]}`
工具/函数调用增量	`tool_calls`（补充参数）	`"delta": {"tool_calls": [{"index":0, "function":{"arguments": "\"city\":\"北京\""}}]}`

3. finish_reason 字段规则

作用：标识当前分片是否是最后一个（替代 Anthropic 的 message_stop）；

取值与含义：

取值	含义
`null`	非最后一个分片，还有增量内容
`stop`	正常结束（文本/工具调用完成）
`tool_calls`	触发工具/函数调用，需返回结果后继续
`length`	达到 token 上限被截断
`content_filter`	内容审核拦截

三、不同场景的完整流式响应示例

示例1：纯文本响应（最常见）

text

# 第一个分片：仅返回role（无实际内容）
data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1716234567,"model":"gpt-4o-2024-05-13","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

# 第二个分片：返回文本增量
data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1716234567,"model":"gpt-4o-2024-05-13","choices":[{"index":0,"delta":{"content":"你好，"},"finish_reason":null}]}

# 第三个分片：继续返回文本增量
data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1716234567,"model":"gpt-4o-2024-05-13","choices":[{"index":0,"delta":{"content":"我是OpenAI的GPT-4o。"},"finish_reason":null}]}

# 最后一个分片：delta为空，finish_reason=stop
data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1716234567,"model":"gpt-4o-2024-05-13","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

# 传输层结束
data: [DONE]

拼接所有 delta.content 得到完整文本：你好，我是OpenAI的GPT-4o。（注意跳过第一个空content的分片）。

示例2：工具/函数调用响应（关键场景）

text

# 第一个分片：启动函数调用（返回名称）
data: {"id":"chatcmpl-456","object":"chat.completion.chunk","created":1716234568,"model":"gpt-4o-2024-05-13","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call_789","type":"function","function":{"name":"get_weather"}}]},"finish_reason":null}]}

# 第二个分片：增量返回函数参数（JSON片段）
data: {"id":"chatcmpl-456","object":"chat.completion.chunk","created":1716234568,"model":"gpt-4o-2024-05-13","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\"city\":\"北京\",\"date\":\"2026-03-01\""}}]}},"finish_reason":null}]}

# 最后一个分片：finish_reason=tool_calls
data: {"id":"chatcmpl-456","object":"chat.completion.chunk","created":1716234568,"model":"gpt-4o-2024-05-13","choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}]}

# 传输层结束
data: [DONE]

解析要点：
1. 从第一个分片提取函数名 get_weather 和调用ID call_789；
2. 拼接 function.arguments 得到完整参数：{"city":"北京","date":"2026-03-01"}；
3. finish_reason=tool_calls 表示需要执行函数并返回结果。

示例3：异常场景（错误返回）

OpenAI 流式响应的错误不会分散在SSE分片中，而是直接返回 HTTP 错误码（如400/429/500），响应体为：

json

{
  "error": {
    "message": "Invalid API key provided",
    "type": "invalid_request_error",
    "param": null,
    "code": "invalid_api_key"
  }
}

四、OpenAI vs Anthropic 核心差异（避坑关键）

维度	OpenAI	Anthropic
核心增量载体	统一的 `delta` 字段	分阶段：`content_block`（start）/`delta`（delta）
生命周期管理	无内容块概念，单分片独立	内容块分 start/delta/end 三阶段
结束标识	`finish_reason!=null` + `[DONE]`	`message_stop` + `[DONE]`
工具调用返回	参数增量拼接（JSON片段）	启动阶段一次性返回完整参数
角色标识	首个分片返回 `role: assistant`	无独立role字段（在message元数据）

五、解析逻辑核心步骤

逐行读取SSE响应，过滤空行和非data:开头的行；
去掉data: 前缀，若为[DONE]则停止解析；
解析JSON，提取choices[0]：
- 若delta.content存在且非空，拼接文本；
- 若delta.tool_calls存在，提取/拼接函数调用信息；
- 若finish_reason!=null，标记响应结束；
忽略delta为空的分片（仅最后一个分片会出现）。

总结

OpenAI 流式响应核心是 choices[0].delta，所有增量内容（文本/工具调用）都通过这个字段返回，无复杂的内容块生命周期；
纯文本场景只需拼接 delta.content，工具调用场景需拼接 tool_calls[0].function.arguments；
finish_reason 是判断响应是否结束的核心，替代了 Anthropic 的 message_stop。

OpenAI API 零基础入门完全指南 ​

目录 ​

一、基础认知 ​

1.1 什么是 OpenAI API ​

1.2 核心能力一览 ★ ​

1.3 主流模型对比 ★ ​

📊 模型对比表 ​

🔍 参数说明 ​

💰 价格参考（2025年） ​

1.4 如何选择合适的模型 ★ ​

二、实操步骤 ​

2.1 申请 API Key 完整流程 ★ ​

📋 准备工作 ​

📝 申请步骤 ​

⚠️ 重要注意事项 ​

2.2 Python 环境安装 ​

步骤 1：确认 Python 版本 ​

步骤 2：安装 OpenAI 官方库 ​

步骤 3：配置 API Key（三种方式） ​

2.3 最小可行代码 ★ ​

2.4 响应结构解析 ★ ​

三、核心场景 ​

3.1 简单对话机器人 ​

3.2 多轮对话实现 ★ ​

3.3 流式输出实现 ​

四、避坑指南 ​

4.1 API Key 安全 ★★★ ​

❌ 错误做法 ​

✅ 正确做法 ​

🛡️ 安全检查清单 ​

4.2 常见错误及解决 ★ ​

错误 1：AuthenticationError（认证失败） ​

错误 2：RateLimitError（频率限制） ​

错误 3：InvalidRequestError（请求格式错误） ​

错误 4：模型不存在 ​

4.3 成本控制技巧 ★ ​

💰 计费原理 ​

📊 成本估算示例 ​

✅ 成本控制最佳实践 ​

💡 省钱技巧 ​

五、速记清单 ​

🚀 30秒速记 ​

📋 API 参数速查 ​

📝 Messages 格式 ​

六、学习资源 ​

📚 官方资源 ​

🛠️ 推荐工具 ​

📖 学习路径 ​

附录：完整代码模板 ​

🔧 通用对话模板 ​

附录B：Chat Completions API 完整参数手册 ★ ​

📡 接口基本信息 ​

📥 请求参数（Request Parameters） ​

一、必填参数 ​

二、messages 字段详解 ★★★ ​

三、可选参数 - 输出控制类 ​

四、可选参数 - 惩罚与偏置类 ​

五、可选参数 - 格式与流式类 ​

六、可选参数 - 高级功能类 ​

📤 响应参数（Response Parameters） ​

完整响应结构 ​

choices 数组详解 ​

usage 对象详解 ★ ​

📡 流式响应结构（stream=true） ​

📋 参数速查表 ​

常用参数组合推荐 ​

参数优先级建议 ​

补充1 ​

一、流式响应的基础格式规则 ​

1. 传输层格式（SSE 通用规则） ​

2. 数据层核心字段（所有有效 JSON 都包含） ​

二、核心增量字段（choices 数组内的规则） ​

1. choices[0] 固定结构 ​

2. delta 字段的多场景规则 ​

3. finish_reason 字段规则 ​

三、不同场景的完整流式响应示例 ​

示例1：纯文本响应（最常见） ​

示例2：工具/函数调用响应（关键场景） ​

示例3：异常场景（错误返回） ​

四、OpenAI vs Anthropic 核心差异（避坑关键） ​

OpenAI API 零基础入门完全指南

目录

一、基础认知

1.1 什么是 OpenAI API

1.2 核心能力一览 ★

1.3 主流模型对比 ★

📊 模型对比表

🔍 参数说明

💰 价格参考（2025年）

1.4 如何选择合适的模型 ★

二、实操步骤

2.1 申请 API Key 完整流程 ★

📋 准备工作

📝 申请步骤

⚠️ 重要注意事项

2.2 Python 环境安装

步骤 1：确认 Python 版本

步骤 2：安装 OpenAI 官方库

步骤 3：配置 API Key（三种方式）

2.3 最小可行代码 ★

2.4 响应结构解析 ★

三、核心场景

3.1 简单对话机器人

3.2 多轮对话实现 ★

3.3 流式输出实现

四、避坑指南

4.1 API Key 安全 ★★★

❌ 错误做法

✅ 正确做法

🛡️ 安全检查清单

4.2 常见错误及解决 ★

错误 1：AuthenticationError（认证失败）

错误 2：RateLimitError（频率限制）

错误 3：InvalidRequestError（请求格式错误）

错误 4：模型不存在

4.3 成本控制技巧 ★

💰 计费原理

📊 成本估算示例

✅ 成本控制最佳实践

💡 省钱技巧

五、速记清单

🚀 30秒速记

📋 API 参数速查

📝 Messages 格式

六、学习资源

📚 官方资源

🛠️ 推荐工具

📖 学习路径

附录：完整代码模板

🔧 通用对话模板

附录B：Chat Completions API 完整参数手册 ★

📡 接口基本信息

📥 请求参数（Request Parameters）

一、必填参数

二、messages 字段详解 ★★★

三、可选参数 - 输出控制类

四、可选参数 - 惩罚与偏置类

五、可选参数 - 格式与流式类

六、可选参数 - 高级功能类

📤 响应参数（Response Parameters）

完整响应结构

choices 数组详解

usage 对象详解 ★

📡 流式响应结构（stream=true）

📋 参数速查表

常用参数组合推荐

参数优先级建议

补充1

一、流式响应的基础格式规则

1. 传输层格式（SSE 通用规则）

2. 数据层核心字段（所有有效 JSON 都包含）

二、核心增量字段（choices 数组内的规则）

1. choices[0] 固定结构

2. delta 字段的多场景规则

3. finish_reason 字段规则

三、不同场景的完整流式响应示例

示例1：纯文本响应（最常见）

示例2：工具/函数调用响应（关键场景）

示例3：异常场景（错误返回）

四、OpenAI vs Anthropic 核心差异（避坑关键）