如何使用 Python 调用 DeepSeek API：完整指南（2026）

2026-05-05 — by Global API Team

deepseek-api python-tutorial deepseek-python llm-api openai-sdk-python deepseek-chat ai-api-tutorial deepseek-v4-flash tutorial

如何使用 Python 调用 DeepSeek API：完整指南（2026）

DeepSeek 的模型以极低的成本提供 GPT-4 级别的性能——DeepSeek V4 Flash 的定价为 $0.14/1M 输入 tokens 和 $0.28/1M 输出 tokens。本指南将带你逐步了解用 Python 调用 DeepSeek API 的全部知识：安装、身份认证、聊天补全、流式响应、函数调用、错误处理和成本优化模式。

太长不看：DeepSeek 的 API 完全兼容 OpenAI。安装 openai，将 base_url 指向 https://global-apis.com/v1，你现有的 OpenAI 代码就能直接运行——成本降低 74%。

前置条件

Python 3.9+
一个 DeepSeek API key —— 免费获取（100 额度，无需信用卡）：https://global-apis.com/register
基本的 Python 和 REST API 使用经验

1. 安装

DeepSeek 的 API 遵循 OpenAI 规范，因此你直接使用官方的 openai Python 包——不需要特定厂商的 SDK。

pip install openai

就这些。基本使用无需额外安装其他包。

2. 身份认证与客户端设置

方案 A：环境变量（推荐）

将 API key 设为环境变量，避免在源文件中硬编码：

# Linux / macOS
export DEEPSEEK_API_KEY="a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4"

# Windows (PowerShell)
$env:DEEPSEEK_API_KEY = "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4"

然后初始化客户端：

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://global-apis.com/v1",
)

方案 B：内联（仅用于快速测试）

from openai import OpenAI

client = OpenAI(
    api_key="a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4",  # 替换为你的 key
    base_url="https://global-apis.com/v1",
)

⚠️ 永远不要将真实的 API key 提交到版本控制中。在生产环境中使用环境变量或密钥管理器。

3. 你的第一次聊天补全

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://global-apis.com/v1",
)

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "你是一个有用的 Python 编程助手。"},
        {"role": "user", "content": "写一个 Python 函数来展平嵌套列表。"},
    ],
    temperature=0.7,
    max_tokens=512,
)

print(response.choices[0].message.content)
print(f"\nToken 用量 — 输入：{response.usage.prompt_tokens}，输出：{response.usage.completion_tokens}")

示例输出：

def flatten(nested_list):
    result = []
    for item in nested_list:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result

Token 用量 — 输入：38，输出：71

4. 选择合适的模型

Global API 提供两个 DeepSeek 模型：

| 模型 | 最适合 | 输入价格 | 输出价格 | |-------|----------|-------------|--------------| | deepseek-chat | 日常任务：摘要、代码辅助、问答、翻译 | $0.14/1M tokens | $0.28/1M tokens | | deepseek-reasoner | 复杂推理：数学证明、多步逻辑、代码调试 | $0.55/1M tokens | $2.19/1M tokens |

经验法则：从 deepseek-chat 开始。仅当任务真正需要多步逻辑推理时才切换到 deepseek-reasoner——它的输出 token 价格大约贵 8 倍。

# 对于复杂推理任务
response = client.chat.completions.create(
    model="deepseek-reasoner",
    messages=[
        {"role": "user", "content": "证明根号 2 是无理数。"}
    ],
    max_tokens=1024,
)

5. 流式响应

对于聊天机器人 UI 或任何对延迟敏感的场景，使用流式输出来在 token 生成时即时显示：

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://global-apis.com/v1",
)

stream = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "user", "content": "用简单的语言解释 Python 的 async/await。"}
    ],
    stream=True,
)

print("响应：", end="", flush=True)
for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content is not None:
        print(delta.content, end="", flush=True)

print()  # 末尾换行

流式输出可将首个 token 的到达时间从约 2 秒缩短到约 200 毫秒，大幅提升交互式应用的感知性能。

6. 多轮对话

为了在多轮对话中保持上下文，在每次请求中传递完整的对话历史：

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://global-apis.com/v1",
)

def chat(messages: list[dict]) -> str:
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=messages,
        temperature=0.7,
    )
    return response.choices[0].message.content

# 构建对话历史
history = [
    {"role": "system", "content": "你是一个简洁的技术助手。"}
]

user_inputs = [
    "什么是 Python 装饰器？",
    "能给我一个实用示例吗？",
    "现在把它改成重试装饰器。",
]

for user_message in user_inputs:
    history.append({"role": "user", "content": user_message})
    reply = chat(history)
    history.append({"role": "assistant", "content": reply})
    print(f"用户：{user_message}")
    print(f"助手：{reply}\n{'─' * 60}")

技巧提示：在长对话中控制成本，当对话超出你的 token 预算时，从 history 中裁剪旧消息。保留系统提示和最后 N 轮对话即可。

7. 函数调用（工具使用）

DeepSeek 支持兼容 OpenAI 的函数调用。这让模型可以决定何时调用你的代码：

import json
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://global-apis.com/v1",
)

# 定义可用工具
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取某个城市的当前天气",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称，例如 '北京'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "温度单位"
                    }
                },
                "required": ["city"],
            },
        },
    }
]

def get_weather(city: str, unit: str = "celsius") -> dict:
    """演示桩函数——替换为真实的天气 API 调用。"""
    return {"city": city, "temperature": 22, "unit": unit, "condition": "晴天"}

messages = [{"role": "user", "content": "东京的天气怎么样？"}]

# 第一次 API 调用——模型决定是否调用函数
response = client.chat.completions.create(
    model="deepseek-chat",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

message = response.choices[0].message

# 检查模型是否想调用函数
if message.tool_calls:
    tool_call = message.tool_calls[0]
    fn_name = tool_call.function.name
    fn_args = json.loads(tool_call.function.arguments)

    # 执行函数
    fn_result = get_weather(**fn_args)

    # 追加函数结果并获取最终响应
    messages.append(message)
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": json.dumps(fn_result),
    })

    final_response = client.chat.completions.create(
        model="deepseek-chat",
        messages=messages,
    )
    print(final_response.choices[0].message.content)
else:
    print(message.content)

8. 错误处理与重试

生产代码需要健壮的错误处理。这是一个带指数退避的模式：

import os
import time
import random
from openai import OpenAI, RateLimitError, APITimeoutError, APIConnectionError

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://global-apis.com/v1",
    timeout=30.0,
)

def chat_with_retry(messages: list[dict], max_retries: int = 3, **kwargs) -> str:
    """在发生瞬时错误时，以指数退避重试调用 API。"""
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="deepseek-chat",
                messages=messages,
                **kwargs,
            )
            return response.choices[0].message.content

        except RateLimitError:
            if attempt == max_retries - 1:
                raise
            wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"速率受限。{wait:.1f} 秒后重试...")
            time.sleep(wait)

        except (APITimeoutError, APIConnectionError) as e:
            if attempt == max_retries - 1:
                raise
            wait = (2 ** attempt) + random.uniform(0, 1)
            print(f"网络错误：{e}。{wait:.1f} 秒后重试...")
            time.sleep(wait)

    raise RuntimeError("超过最大重试次数")  # 正常流程不应到达此处

# 使用
result = chat_with_retry(
    messages=[{"role": "user", "content": "用一段话总结 Python GIL。"}],
    temperature=0.5,
    max_tokens=200,
)
print(result)

9. 追踪 Token 用量与成本

以 DeepSeek V4 Flash 的定价（$0.14/1M 输入，$0.28/1M 输出），即使是重度工作负载成本也非常低。以下是如何仪表化成本追踪：

import os
from dataclasses import dataclass, field
from openai import OpenAI

INPUT_COST_PER_TOKEN  = 0.14 / 1_000_000   # $0.14 每 1M 输入 tokens
OUTPUT_COST_PER_TOKEN = 0.28 / 1_000_000   # $0.28 每 1M 输出 tokens

@dataclass
class UsageTracker:
    total_input_tokens: int = 0
    total_output_tokens: int = 0
    request_count: int = 0
    total_cost_usd: float = field(init=False, default=0.0)

    def record(self, usage):
        self.total_input_tokens  += usage.prompt_tokens
        self.total_output_tokens += usage.completion_tokens
        self.request_count       += 1
        self.total_cost_usd = (
            self.total_input_tokens  * INPUT_COST_PER_TOKEN +
            self.total_output_tokens * OUTPUT_COST_PER_TOKEN
        )

    def report(self):
        print(f"请求数：       {self.request_count}")
        print(f"输入 tokens：   {self.total_input_tokens:,}")
        print(f"输出 tokens：   {self.total_output_tokens:,}")
        print(f"预估成本：     ${self.total_cost_usd:.6f}")

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://global-apis.com/v1",
)
tracker = UsageTracker()

prompts = [
    "解释列表推导式。",
    "什么是 Python 上下文管理器？",
    "什么时候应该用生成器而不是列表？",
]

for prompt in prompts:
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=200,
    )
    tracker.record(response.usage)

tracker.report()
# 输出（近似）：
# 请求数：       3
# 输入 tokens：   51
# 输出 tokens：   462
# 预估成本：     $0.000136

10. 使用 `asyncio` 异步调用

对于高吞吐量应用，使用异步客户端并发运行多个请求：

import asyncio
import os
from openai import AsyncOpenAI

async_client = AsyncOpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://global-apis.com/v1",
)

async def summarize(text: str) -> str:
    response = await async_client.chat.completions.create(
        model="deepseek-chat",
        messages=[
            {"role": "system", "content": "用一句话总结以下内容。"},
            {"role": "user",   "content": text},
        ],
        max_tokens=100,
    )
    return response.choices[0].message.content

async def main():
    documents = [
        "Python 由 Guido van Rossum 创建，于 1991 年发布...",
        "机器学习是人工智能的一个子集，它...",
        "REST API 使用 HTTP 方法对资源执行 CRUD 操作...",
    ]

    # 并发运行所有请求
    results = await asyncio.gather(*[summarize(doc) for doc in documents])

    for doc, summary in zip(documents, results):
        print(f"原文：   {doc[:60]}...")
        print(f"摘要：   {summary}\n")

asyncio.run(main())

并发运行 3 个请求将总延迟从约 6 秒（顺序执行）缩短到约 2 秒（并行执行）。

11. 成本优化技巧

1. 每个请求都设置 `max_tokens`

不设置 max_tokens 时，模型可能生成非常长的响应。设置合理上限：

# 不好 — 无限制输出，成本不可预测
response = client.chat.completions.create(model="deepseek-chat", messages=[...])

# 好 — 限制在 500 tokens
response = client.chat.completions.create(model="deepseek-chat", messages=[...], max_tokens=500)

2. 裁剪对话历史

多轮对话中的每一轮都按完整上下文长度计费。大约 10 轮之后，总结旧消息：

def trim_history(history: list[dict], max_turns: int = 6) -> list[dict]:
    system = [m for m in history if m["role"] == "system"]
    non_system = [m for m in history if m["role"] != "system"]
    return system + non_system[-max_turns * 2:]

3. 大多数任务使用 `deepseek-chat`

deepseek-reasoner 贵大约 8 倍。仅将真正复杂的推理任务路由到它：

def pick_model(prompt: str) -> str:
    reasoning_keywords = {"证明", "推导", "优化", "调试", "逐步分析"}
    if any(kw in prompt.lower() for kw in reasoning_keywords):
        return "deepseek-reasoner"
    return "deepseek-chat"

4. 缓存频繁的提示

如果用户反复提出相同的问题，使用 Redis 或本地字典缓存响应：

import hashlib, json

_cache: dict[str, str] = {}

def cached_chat(messages: list[dict]) -> str:
    key = hashlib.md5(json.dumps(messages, sort_keys=True).encode()).hexdigest()
    if key in _cache:
        return _cache[key]
    result = chat_with_retry(messages)  # 来自第 8 节
    _cache[key] = result
    return result

实际成本估算

| 使用场景 | 月用量 | 预估成本 | |----------|---------------|----------------| | 内部 Slack 机器人（简短问答） | 5 万次请求 / 1 亿 tokens | ~$21/月 | | 客服聊天机器人 | 20 万次请求 / 5 亿 tokens | ~$98/月 | | 代码审查流水线（CI/CD） | 1 万次 PR / 2 亿 tokens | ~$42/月 | | 文档摘要（RAG） | 100 万份文档 / 20 亿 tokens | ~$420/月 |

相比之下，GPT-4o（$2.50/1M 输入，$10/1M 输出）在相同用量下：仅 Slack 机器人一项就要花费 $330/月——贵了 15 倍。

想要永不过期且无月费的额度？查看 Global API 额度包。

快速参考

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://global-apis.com/v1",
)

# 聊天补全
r = client.chat.completions.create(
    model="deepseek-chat",          # 或 "deepseek-reasoner"
    messages=[{"role": "user", "content": "你好！"}],
    temperature=0.7,                # 0 = 确定，1 = 创造性
    max_tokens=512,
    stream=False,
)
print(r.choices[0].message.content)
print(r.usage.prompt_tokens, r.usage.completion_tokens)

| 参数 | 值 | 默认值 | |-----------|--------|---------| | model | deepseek-chat, deepseek-reasoner | — | | temperature | 0.0 – 2.0 | 1.0 | | max_tokens | 1 – 8192 | 模型最大值 | | stream | True / False | False | | top_p | 0.0 – 1.0 | 1.0 |

常见问题

我需要为 DeepSeek 安装特殊的 SDK 吗？
不需要。DeepSeek 的 API 是 OpenAI 兼容的。只需要 pip install openai。

上下文窗口有多大？
deepseek-chat 每个请求最多支持 64K tokens（输入 + 输出合并计算）。

API 有速率限制吗？
Global API 对每个账号设有速率限制。对于高用量场景，请联系我们——我们提供自定义速率限制提升。

我能将 LangChain 或 LlamaIndex 与 DeepSeek 一起使用吗？
可以。在 LangChain 中设置 openai_api_base，或在 LlamaIndex 中设置 openai_base_url 为 https://global-apis.com/v1。你现有的链路无需修改即可运行。

额度如何运作？
1 额度 = $0.01。DeepSeek V4 Flash 每 1M 输入 tokens 消耗 14 额度，每 1M 输出 tokens 消耗 28 额度。额度永不过期。

立即开始

你现在已经掌握用 Python 调用 DeepSeek API 的所有必备知识——身份认证、聊天补全、流式输出、函数调用、异步使用和成本追踪。

免费开始： https://global-apis.com/register — 100 免费额度，无需信用卡。
了解定价： https://global-apis.com/pricing — 额度包从 $19.99 起。

有问题或遇到困难？通过面板给我们发送消息——我们很乐意帮助。

开始使用 Global API 构建

注册即获 100 免费额度——无需信用卡。用一个兼容 OpenAI 的 API key 访问 180+ AI 模型（DeepSeek、Qwen、Kimi、GLM、Doubao 等）。

👉 免费开始 →

支持 PayPal（Visa、Mastercard、Amex）。5 分钟即可完成设置。

如何使用 Python 调用 DeepSeek API：完整指南（2026）

如何使用 Python 调用 DeepSeek API：完整指南（2026）

前置条件

1. 安装

2. 身份认证与客户端设置

方案 A：环境变量（推荐）

方案 B：内联（仅用于快速测试）

3. 你的第一次聊天补全

4. 选择合适的模型

5. 流式响应

6. 多轮对话

7. 函数调用（工具使用）

8. 错误处理与重试

9. 追踪 Token 用量与成本

10. 使用 `asyncio` 异步调用

11. 成本优化技巧

1. 每个请求都设置 `max_tokens`

2. 裁剪对话历史

3. 大多数任务使用 `deepseek-chat`

4. 缓存频繁的提示

实际成本估算

快速参考

常见问题

立即开始

相关文章

开始使用 Global API 构建

Part of DeepSeek API Complete Guide

Related Articles

Start Building with Global API

如何使用 Python 调用 DeepSeek API：完整指南（2026）

如何使用 Python 调用 DeepSeek API：完整指南（2026）

前置条件

1. 安装

2. 身份认证与客户端设置

方案 A：环境变量（推荐）

方案 B：内联（仅用于快速测试）

3. 你的第一次聊天补全

4. 选择合适的模型

5. 流式响应

6. 多轮对话

7. 函数调用（工具使用）

8. 错误处理与重试

9. 追踪 Token 用量与成本

10. 使用 asyncio 异步调用

11. 成本优化技巧

1. 每个请求都设置 max_tokens

2. 裁剪对话历史

3. 大多数任务使用 deepseek-chat

4. 缓存频繁的提示

实际成本估算

快速参考

常见问题

立即开始

相关文章

开始使用 Global API 构建

Part of DeepSeek API Complete Guide

Related Articles

Start Building with Global API

10. 使用 `asyncio` 异步调用

1. 每个请求都设置 `max_tokens`

3. 大多数任务使用 `deepseek-chat`