第二篇章：API 调用入门——和 AI 第一次对话

覆盖内容：HTTP 请求 → 注册 DeepSeek → 第一条 AI 消息 → 模型参数 → System Prompt → 多轮对话 → 流式输出 → Token 计费 → 错误处理 → 实战 最终产出：一个 AI 翻译助手（中英日互译 + 流式输出） 前置要求：完成第一篇 Python 基础 你需要准备：一个 DeepSeek API Key

一、什么是 API？为什么大模型要「调接口」？

大模型不是跑在你电脑上的——它跑在几千公里外的 GPU 集群上。你想让它干活，就通过网络给它发请求，它算完了把结果返回给你。

这个过程叫 API 调用。API 就是「你家到模型」的快递通道。

你的电脑 DeepSeek 服务器
│ │
│ POST /chat/completions │
│ {"model":"deepseek-chat", │
│ "messages":[{"role":"user", │
│ "content":"你好"}]} │
│ ──────────────────────────────────▶ │
│ │ GPU 计算…
│ {"choices":[{"message": │
│ {"content":"你好！…"}}]} │
│ ◀────────────────────────────────── │
│ │

二、HTTP 请求基础（10 分钟速通）

调用 API 的本质就是发 HTTP 请求。Python 用 requests 库：

2.1 装库

pip install requests

2.2 GET 请求

import requests

# 拿一条免费 API 试试 —— 获取一句名言
resp = requests.get("https://api.quotable.io/random")
data = resp.json()
print(data["content"])
print(f"—— {data['author']}")
# 输出示例：Life is what happens when you're busy making other plans. —— John Lennon

2.3 POST 请求

# POST 通常要传数据（JSON body）
resp = requests.post(
"https://httpbin.org/post",
json={"name": "小明", "message": "测试"}
)
print(resp.json())

2.4 状态码

resp = requests.get("https://api.quotable.io/random")
print(resp.status_code) # 200 = 成功，404 = 找不到，500 = 服务器炸了

if resp.status_code == 200:
print("请求成功")
else:
print(f"请求失败：{resp.status_code}")

三、注册 DeepSeek，拿到你的 API Key

DeepSeek 是国产大模型，价格量大管饱，完全兼容 OpenAI 接口格式，新手友好，但目前只支持文本输入。 还可以使用阿里的百炼平台，目前注册限时3个月的免费体验，众多模型任你选，支持多模态。

注册步骤

安全提醒

# ❌ 绝对不要把 Key 写死在代码里提交到 GitHub
api_key = "sk-xxxxxxxxxxxxxx" # 危险！

# ✅ 用环境变量
import os
api_key = os.getenv("DEEPSEEK_API_KEY")

# 在终端设置环境变量
# macOS / Linux
export DEEPSEEK_API_KEY="sk-你的key"

# Windows CMD
set DEEPSEEK_API_KEY=sk-你的key

# Windows PowerShell
$env:DEEPSEEK_API_KEY="sk-你的key"

四、发出人生第一条大模型请求

4.1 装 openai 库

DeepSeek 兼容 OpenAI 的接口格式，直接用 openai 官方库：

pip install openai

4.2 第一条消息

这里注意：每个模型厂商的URL都不一样，可参考对应的api文档查看。

# first_chat.py —— 人生第一条 AI 消息
import os
from openai import OpenAI

# 初始化客户端
client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"), # 你的 API Key
base_url="https://api.deepseek.com" # DeepSeek 的地址
)

# 发消息
response = client.chat.completions.create(
model="deepseek-chat", # 模型名
messages=[
{"role": "user", "content": "用一句话解释什么是大模型"}
]
)

# 拿回答
answer = response.choices[0].message.content
print(answer)

运行：

python first_chat.py

输出示例：

大模型是指基于海量数据和深度神经网络训练而成的、具备强大泛化能力和涌现能力的超大规模人工智能模型。

4.3 拆解返回结果

# response 是个宝藏，能看到很多信息
response = client.chat.completions.create(
model="deepseek-chat",
messages=[{"role": "user", "content": "你是谁？"}]
)

# 完整结构
print(response.model_dump_json(indent=2))

关键字段：

response.id # 请求 ID
response.model # 使用的模型
response.choices[0].message.content # 回复内容
response.choices[0].message.role # "assistant"
response.choices[0].finish_reason # "stop" 表示正常结束
response.usage.total_tokens # 消耗的 token 数
response.usage.prompt_tokens # 输入 token
response.usage.completion_tokens # 输出 token

五、模型参数详解——控制 AI 的「性格」

5.1 temperature（温度，0-2）

控制回答的随机性 / 创造性：

# temperature=0：最确定，每次回答几乎一样（适合代码生成、事实问答）
client.chat.completions.create(
model="deepseek-chat",
messages=[{"role": "user", "content": "写一个冷笑话"}],
temperature=0
)

# temperature=1.5：最狂野，天马行空（适合创意写作、头脑风暴）
client.chat.completions.create(
model="deepseek-chat",
messages=[{"role": "user", "content": "写一个冷笑话"}],
temperature=1.5
)

动手：对比实验

# temperature_test.py —— 感受 temperature 的效果
from openai import OpenAI
import os

client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)

prompt = "用一句话描述雨天"

for temp in [0, 0.5, 1.0, 1.5]:
response = client.chat.completions.create(
model="deepseek-chat",
messages=[{"role": "user", "content": prompt}],
temperature=temp
)
print(f"temperature={temp}: {response.choices[0].message.content}")

5.2 max_tokens（最大输出长度）

# 限制回答最多 50 个 token
response = client.chat.completions.create(
model="deepseek-chat",
messages=[{"role": "user", "content": "写一篇关于 AI 的 500 字文章"}],
max_tokens=50 # 写到 50 token 就停
)

5.3 top_p（核采样，0-1）

temperature 的替代方案，控制候选词范围。一般调 temperature 就够了，top_p 保持默认。

速查表

六、System Prompt——给 AI 一个「人设」

messages = [
{"role": "system", "content": "你是一个毒舌的文学评论家，每句话都必须带讽刺"},
{"role": "user", "content": "评价一下《小时代》"}
]

response = client.chat.completions.create(
model="deepseek-chat",
messages=messages
)
print(response.choices[0].message.content)
# 输出：哦，《小时代》，一部让我深刻意识到奢侈品广告也能拍成电影的旷世杰作……

动手：双人格聊天

# two_personalities.py —— 同一个人问同一句话，不同人设回答
from openai import OpenAI
import os

client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)

question = "我今天不想上班，怎么办？"

personalities = [
{
"name": "毒舌导师",
"system": "你是一个毒舌的职场导师，说话刻薄但有用，喜欢反问"
},
{
"name": "温柔鼓励师",
"system": "你是一个温柔的职场鼓励师，善于共情，说话温暖"
},
{
"name": "鲁迅",
"system": "你模仿鲁迅的口气，语气犀利，喜欢用比喻"
}
]

for p in personalities:
response = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": p["system"]},
{"role": "user", "content": question}
]
)
print(f"\\n{'='*40}")
print(f"【{p['name']}】")
print(response.choices[0].message.content)

System Prompt 常用模式

# 1. 角色设定
{"role": "system", "content": "你是一个高级 Python 后端工程师，有 10 年经验"}

# 2. 格式约束
{"role": "system", "content": "你的回答必须使用 JSON 格式，不要加任何解释文字"}

# 3. 行为约束
{"role": "system", "content": "你不知道就说不知道，不要编造"}

# 4. 组合
{"role": "system", "content": """你是一个资深代码审查员。
规则：
1. 只指出真正的问题，不要吹毛求疵
2. 每个问题给出行号和修复建议
3. 如果没有问题就说「代码没问题」"""}

七、多轮对话——让 AI 记住上下文

7.1 原理

messages 数组就是「对话历史」。你把每次对话都拼进去，AI 就记住了。

# 不带记忆（每次都是新话题）
messages = [{"role": "user", "content": "我叫小明"}]
# AI: 你好小明

messages = [{"role": "user", "content": "我叫什么？"}]
# AI: 我不知道你叫什么

# 带记忆（把之前的对话也传回去）
messages = [
{"role": "user", "content": "我叫小明"},
{"role": "assistant", "content": "你好小明！"},
{"role": "user", "content": "我叫什么？"}
]
# AI: 你叫小明

7.2 实现一个命令行聊天机器人

# chatbot.py —— 有记忆的命令行聊天机器人
from openai import OpenAI
import os

client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)

# 存对话历史
messages = [
{"role": "system", "content": "你是一个友好的助手"}
]

print("=" * 50)
print(" 🤖 命令行聊天机器人（输入 quit 退出）")
print("=" * 50)

while True:
user_input = input("\\n你：")
if user_input.lower() == "quit":
print("再见！")
break

# 把用户消息加到历史
messages.append({"role": "user", "content": user_input})

# 调用 API
response = client.chat.completions.create(
model="deepseek-chat",
messages=messages
)

assistant_msg = response.choices[0].message.content
print(f"AI：{assistant_msg}")

# 把 AI 回复也加到历史
messages.append({"role": "assistant", "content": assistant_msg})

试一下：

你：你好，我是小啾啾
AI：你好呀，小啾啾！很高兴认识你，有什么需要帮忙的吗？无论是日常问题、知识解答、心情陪伴还是其他任何事情，我都在这里哦~ (๑˃̵ᴗ˂̵)و
……

你：我正在学习ai大模型应用开发
AI：哇，太棒了！小啾啾同学，你正在踏入一个超级酷的领域！🎉
……

你：还记得我叫什么吗？
AI：哈哈，当然记得！你是小啾啾呀～ 我不仅记得名字，还记得你在学AI大模型应用开发呢！😎

7.3 上下文窗口限制

messages 太长了会超。简单处理：只保留最近 N 条。虽然目前也支持最大1m的上下文窗口。

MAX_HISTORY = 20 # 只保留最近 20 条消息

if len(messages) > MAX_HISTORY:
# 保留 system prompt + 最近的消息
messages = messages[:1] + messages[–(MAX_HISTORY – 1):]

八、流式输出——打字机效果

不用等 AI 全部算完才看到回答，一个字一个字往外蹦。

# stream_chat.py —— 流式输出，打字机效果
from openai import OpenAI
import os

client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)

messages = [{"role": "user", "content": "用 200 字介绍武汉"}]

# stream=True 开启流式
stream = client.chat.completions.create(
model="deepseek-chat",
messages=messages,
stream=True
)

print("AI：", end="", flush=True)
for chunk in stream:
if chunk.choices[0].delta.content:
content = chunk.choices[0].delta.content
print(content, end="", flush=True) # 逐字打印

print() # 最后的换行

效果：文字像打字机一样逐字出现在屏幕上。

九、Token 与计费（知道花了多少钱）

9.1 什么是 Token

Token 是模型理解文本的最小单位——不完全是「字」，更接近「词根」。

Token 用量计算

token 是模型用来表示自然语言文本的基本单位，也是我们的计费单元，可以直观的理解为“字”或“词”；通常 1 个中文词语、1 个英文单词、1 个数字或 1 个符号计为 1 个 token。 一般情况下模型中 token 和字数的换算比例大致如下： 1 个英文字符 ≈ 0.3 个 token。 1 个中文字符 ≈ 0.6 个 token。 但因为不同模型的分词不同，所以换算比例也存在差异，每一次实际处理 token 数量以模型返回为准，您可以从返回结果的 usage 中查看。 以上是deepseek官方给出的说明。

9.2 统计 Token

# 从 response 里直接拿用量
response = client.chat.completions.create(
model="deepseek-chat",
messages=[{"role": "user", "content": "你好"}]
)

usage = response.usage
print(f"输入 token: {usage.prompt_tokens}")
print(f"输出 token: {usage.completion_tokens}")
print(f"总计: {usage.total_tokens}")

# DeepSeek 价格（极低）
# 输入：1 元 / 100 万 token
# 输出：2 元 / 100 万 token
cost_input = usage.prompt_tokens / 1_000_000 * 1
cost_output = usage.completion_tokens / 1_000_000 * 2
print(f"本次花费：{cost_input + cost_output:.6f} 元")
# 输出：本次花费：0.000005 元

9.3 做一个用量追踪器

# token_tracker.py
class TokenTracker:
def __init__(self):
self.total_prompt = 0
self.total_completion = 0

def add(self, usage):
self.total_prompt += usage.prompt_tokens
self.total_completion += usage.completion_tokens

def summary(self):
total = self.total_prompt + self.total_completion
cost = (self.total_prompt / 1_000_000 * 1 +
self.total_completion / 1_000_000 * 2)
print(f"\\n📊 用量统计")
print(f" 输入 token: {self.total_prompt:,}")
print(f" 输出 token: {self.total_completion:,}")
print(f" 总计 token: {total:,}")
print(f" 预估费用: ¥{cost:.4f}")

# 使用
tracker = TokenTracker()
# 每次调用 API 后：tracker.add(response.usage)
# 结束时：tracker.summary()

十、错误处理——程序不崩

10.1 常见错误类型

from openai import (
APIError, # 服务器错误
APIConnectionError, # 网络不通
RateLimitError, # 请求太频繁
APITimeoutError, # 超时
AuthenticationError,# API Key 不对
)

try:
response = client.chat.completions.create(
model="deepseek-chat",
messages=[{"role": "user", "content": "你好"}],
timeout=30 # 30 秒超时
)
except AuthenticationError:
print("❌ API Key 无效，检查环境变量")
except RateLimitError:
print("❌ 请求太频繁，等一下再试")
except APITimeoutError:
print("❌ 请求超时，网络可能有问题")
except APIConnectionError:
print("❌ 连接失败，检查网络")
except APIError as e:
print(f"❌ API 错误：{e}")
except Exception as e:
print(f"❌ 未知错误：{e}")

10.2 带重试的请求

import time

def chat_with_retry(client, messages, max_retries=3):
"""带重试的 API 调用"""
for attempt in range(max_retries):
try:
response = client.chat.completions.create(
model="deepseek-chat",
messages=messages,
timeout=30
)
return response
except RateLimitError:
if attempt < max_retries – 1:
wait = 2 ** attempt # 指数退避：1s, 2s, 4s
print(f"⏳ 请求太频繁，{wait}秒后重试…")
time.sleep(wait)
else:
raise
except (APITimeoutError, APIConnectionError):
if attempt < max_retries – 1:
print(f"⏳ 网络问题，重试中（{attempt + 1}/{max_retries}）…")
time.sleep(1)
else:
raise

十一、阶段实战：AI 翻译助手

综合运用本篇全部知识，做一个支持流式输出的命令行翻译助手。

# translator.py —— 第二篇章毕业作品
import os
import time
from openai import OpenAI, APIError, RateLimitError, APITimeoutError, APIConnectionError

# ─── 初始化 ───
client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)

LANGUAGES = {
"1": {"name": "中文", "prompt": "中文"},
"2": {"name": "English", "prompt": "English"},
"3": {"name": "日本語", "prompt": "日本語"},
"4": {"name": "한국어", "prompt": "한국어"},
}

# Token 统计
total_prompt_tokens = 0
total_completion_tokens = 0

def translate(text, target_lang, stream=True):
"""翻译文本"""
global total_prompt_tokens, total_completion_tokens

system_prompt = (
f"你是一个专业的翻译助手。"
f"将用户输入的文本翻译成{target_lang}。"
f"只输出翻译结果，不要加任何解释。"
f"保持原文的语气和风格。"
)

for attempt in range(3):
try:
response = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": text}
],
stream=stream,
temperature=0.3,
timeout=30
)
break
except RateLimitError:
if attempt < 2:
time.sleep(2 ** attempt)
else:
raise
except (APITimeoutError, APIConnectionError):
if attempt < 2:
time.sleep(1)
else:
raise

if stream:
result = ""
print(f"\\n🌐 翻译结果 ({target_lang})：")
print("-" * 50)
for chunk in response:
if chunk.choices[0].delta.content:
content = chunk.choices[0].delta.content
print(content, end="", flush=True)
result += content
print("\\n" + "-" * 50)

# 流式模式无法获取精确 token 数，这里只做粗略统计
estimated_tokens = len(text) // 2 + len(result) // 2
total_prompt_tokens += estimated_tokens
total_completion_tokens += estimated_tokens
else:
content = response.choices[0].message.content
total_prompt_tokens += response.usage.prompt_tokens
total_completion_tokens += response.usage.completion_tokens
result = content

return result

def main():
print("=" * 50)
print(" 🌐 AI 翻译助手 · 第二篇章毕业作品")
print("=" * 50)

while True:
print("\\n支持语言：")
for key, lang in LANGUAGES.items():
print(f" {key}. {lang['name']}")

print("\\n输入 'q' 退出，输入 's' 查看用量统计")
choice = input("翻译到（输入编号）：").strip()

if choice.lower() == 'q':
break
elif choice.lower() == 's':
show_stats()
continue

if choice not in LANGUAGES:
print("❌ 无效选择")
continue

target = LANGUAGES[choice]

print(f"\\n请输入要翻译成 {target['name']} 的文字（输入空行结束）：")
lines = []
while True:
line = input()
if line == "":
break
lines.append(line)

if not lines:
continue

text = "\\n".join(lines)
translate(text, target["prompt"])

def show_stats():
total = total_prompt_tokens + total_completion_tokens
cost = total_prompt_tokens / 1_000_000 * 1 + total_completion_tokens / 1_000_000 * 2
print(f"\\n📊 本次会话用量统计")
print(f" 预估 token: {total:,}")
print(f" 预估费用: ¥{cost:.6f}")

if __name__ == "__main__":
try:
main()
except APIError as e:
print(f"\\n❌ API 错误：{e}")
except KeyboardInterrupt:
print("\\n\\n👋 已退出")
show_stats()

运行效果

==================================================
🌐 AI 翻译助手 · 第二篇章毕业作品
==================================================

支持语言：
1. 中文
2. English
3. 日本語
4. 한국어

翻译到（输入编号）：2

请输入要翻译成 English 的文字：
恭喜你，完成第二章学习，API调用入门，请继续努力吧！

🌐 翻译结果 (English)：
————————————————–
Congratulations on completing Chapter 2: Getting Started with API Calls. Keep up the good work!
————————————————–

本篇总结

知识点 你学会了什么
──────────────────────────────────────────────
HTTP 请求 requests 库，GET/POST，状态码
DeepSeek 注册 API Key，openai 库，base_url
第一条 AI 消息 client.chat.completions.create，messages 格式
模型参数 temperature / max_tokens / top_p
System Prompt 给 AI 人设、行为约束、格式约束
多轮对话 messages 数组做对话历史，上下文窗口
流式输出 stream=True，打字机效果
Token 计费 usage 字段，费用估算
错误处理 异常类型 / 重试 / 指数退避
实战 AI 翻译助手，支持 4 种语言 + 流式输出

下一篇预告

第三篇章：Prompt Engineering——Few-shot、Chain of Thought、结构化输出、文本分类、情感分析、SQL 生成。让 AI 稳定输出你想要的格式。

作业：给翻译助手加一个「自动检测源语言」的功能——用户不用手动选，输入文字后 AI 自动判断是哪种语言，然后翻译成用户指定的目标语言。