第二篇章：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个月的免费体验，众多模型任你选，支持多模态。
注册步骤
- 打开 https://platform.deepseek.com/
- 用手机号 / 微信扫码注册
- 进入控制台 → 左侧 「API keys」
- 点 「创建 API key」，取个名字（如
ai-learning） - 立刻复制保存，关掉弹窗后就看不到了
- 点击充值，充值1元，学习阶段够用了，用完了再冲
安全提醒
# ❌ 绝对不要把 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 保持默认。
速查表
| 参数 | 作用 | 推荐值 |
|---|---|---|
temperature |
随机性，越大越狂野 | 代码/事实 0-0.3，聊天 0.7，创意 1.0+ |
max_tokens |
限制输出长度 | 按需设置 |
top_p |
核采样 | 保持默认 1.0 |
stream |
流式输出 | 聊天场景 True |
frequency_penalty |
降低重复词 | 重复问题时设为 0.5 |
六、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 自动判断是哪种语言，然后翻译成用户指定的目标语言。
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
16
0- 0
已为社区贡献3条内容
所有评论(0)