第23篇|Python 调用 AI 大模型 API:OpenAI / Claude / 国内模型全对比

这篇文章把主流 AI 大模型 API 全部跑通一遍——OpenAI、Claude、通义千问、Kimi，对比调用方式，实现打字机效果的流式输出，附上价格和能力横向对比表。拿来即用。

前言

这是第三阶段最重磅的一篇。

现在几乎所有的新产品都在接入 AI 大模型。作为开发者，能用 Python 调 API 构建 AI 功能，是 2026 年最值钱的技能之一。

好消息是：这些模型的 API 设计非常相似，学会一个，其他的几乎零成本迁移。

这篇文章目标：

• 把四家主流模型 API 全部跑通
• 实现流式输出（打字机效果）
• 封装一个可复用的统一调用接口
• 给你一张选模型时能用的对比表

安装：

pip install openai anthropic requests python-dotenv

一、OpenAI API

OpenAI 是行业标准，其他很多模型都兼容它的 API 格式。

1.1 基础调用

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

response = client.chat.completions.create(
    model="gpt-4o-mini",       # 性价比最高的选择
    messages=[
        {"role": "system", "content": "你是一个专注于 Python 的技术助手。"},
        {"role": "user", "content": "用一句话解释什么是装饰器？"}
    ],
    temperature=0.7,            # 0=确定性输出，1=更有创意
    max_tokens=500
)

# 提取回复文本
answer = response.choices[0].message.content
print(answer)

# 查看用量（用于计费）
print(f"输入 tokens：{response.usage.prompt_tokens}")
print(f"输出 tokens：{response.usage.completion_tokens}")

1.2 流式输出（打字机效果）

import sys

def chat_stream(prompt: str, system: str = "你是一个有帮助的助手") -> str:
    """流式输出，逐字打印到终端"""
    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

    full_response = ""

    stream = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": prompt}
        ],
        stream=True    # 关键：开启流式输出
    )

    for chunk in stream:
        # 每个 chunk 可能包含 delta 内容
        delta = chunk.choices[0].delta
        if delta.content:
            print(delta.content, end="", flush=True)
            full_response += delta.content

    print()   # 最后换行
    return full_response


# 使用
answer = chat_stream("请用 100 字介绍一下 Python 的 asyncio 模块")

1.3 多轮对话

def multi_turn_chat():
    """维护对话历史，实现多轮对话"""
    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    history = [
        {"role": "system", "content": "你是一个 Python 导师，回答简洁清晰。"}
    ]

    print("开始对话（输入 quit 退出）\n")
    while True:
        user_input = input("你：").strip()
        if user_input.lower() in ("quit", "exit", "q"):
            break
        if not user_input:
            continue

        history.append({"role": "user", "content": user_input})

        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=history
        )
        reply = response.choices[0].message.content
        history.append({"role": "assistant", "content": reply})

        print(f"GPT：{reply}\n")

二、Claude API（Anthropic）

import anthropic
import os

client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

# 基础调用
message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system="你是一个专注于 Python 的技术助手，回答简洁准确。",
    messages=[
        {"role": "user", "content": "解释 Python 的 GIL 是什么，100 字以内"}
    ]
)
print(message.content[0].text)
print(f"输入 tokens：{message.usage.input_tokens}")
print(f"输出 tokens：{message.usage.output_tokens}")

Claude API 和 OpenAI 的主要区别：

# Claude 流式输出
def claude_stream(prompt: str) -> str:
    client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
    full_response = ""

    with client.messages.stream(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}]
    ) as stream:
        for text in stream.text_stream:
            print(text, end="", flush=True)
            full_response += text

    print()
    return full_response

三、通义千问（阿里云）

通义千问兼容 OpenAI 的 API 格式，只需换 base_url 和 api_key：

from openai import OpenAI

# 通义千问直接复用 OpenAI 客户端，只改 base_url
client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

response = client.chat.completions.create(
    model="qwen-plus",    # qwen-turbo(快) / qwen-plus(均衡) / qwen-max(强)
    messages=[
        {"role": "system", "content": "你是一个 Python 技术助手"},
        {"role": "user", "content": "列举 3 个 Python 列表推导式的使用场景"}
    ]
)
print(response.choices[0].message.content)

获取 API Key： 阿里云控制台 → 搜索"模型服务灵积" → API-KEY 管理

四、Kimi（月之暗面）

Kimi 同样兼容 OpenAI 格式，Kimi 的长上下文能力（128K tokens）是亮点：

from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.cn/v1"
)

response = client.chat.completions.create(
    model="moonshot-v1-8k",   # 8k / 32k / 128k
    messages=[
        {"role": "user", "content": "解释 Python 的上下文管理器（with 语句）"}
    ],
    temperature=0.3
)
print(response.choices[0].message.content)

五、封装统一调用接口

实际项目中，最好封装一层，这样换模型时只改一个配置：

# llm_client.py
import os
from enum import Enum
from openai import OpenAI
import anthropic
from dotenv import load_dotenv

load_dotenv()


class ModelProvider(Enum):
    OPENAI = "openai"
    CLAUDE = "claude"
    QWEN = "qwen"
    KIMI = "kimi"


# 各厂商配置
PROVIDER_CONFIG = {
    ModelProvider.OPENAI: {
        "api_key_env": "OPENAI_API_KEY",
        "base_url": None,
        "default_model": "gpt-4o-mini"
    },
    ModelProvider.QWEN: {
        "api_key_env": "DASHSCOPE_API_KEY",
        "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
        "default_model": "qwen-plus"
    },
    ModelProvider.KIMI: {
        "api_key_env": "MOONSHOT_API_KEY",
        "base_url": "https://api.moonshot.cn/v1",
        "default_model": "moonshot-v1-8k"
    },
}


def chat(
    prompt: str,
    provider: ModelProvider = ModelProvider.OPENAI,
    system: str = "你是一个有帮助的助手",
    model: str = None,
    stream: bool = False,
    temperature: float = 0.7,
    max_tokens: int = 1024
) -> str:
    """
    统一调用接口，支持多家模型

    Args:
        prompt: 用户输入
        provider: 使用哪家模型
        system: 系统提示词
        model: 指定模型（不填则用默认）
        stream: 是否流式输出
        temperature: 创造性（0-1）
        max_tokens: 最大输出 tokens

    Returns:
        模型回复文本
    """

    # Claude 走独立 SDK
    if provider == ModelProvider.CLAUDE:
        return _call_claude(prompt, system, model, stream, max_tokens)

    # 其余走 OpenAI 兼容接口
    config = PROVIDER_CONFIG[provider]
    api_key = os.getenv(config["api_key_env"])
    if not api_key:
        raise ValueError(f"未找到环境变量：{config['api_key_env']}")

    client_kwargs = {"api_key": api_key}
    if config["base_url"]:
        client_kwargs["base_url"] = config["base_url"]

    client = OpenAI(**client_kwargs)
    chosen_model = model or config["default_model"]

    if stream:
        return _openai_stream(client, chosen_model, system, prompt, temperature, max_tokens)
    else:
        response = client.chat.completions.create(
            model=chosen_model,
            messages=[
                {"role": "system", "content": system},
                {"role": "user", "content": prompt}
            ],
            temperature=temperature,
            max_tokens=max_tokens
        )
        return response.choices[0].message.content


def _openai_stream(client, model, system, prompt, temperature, max_tokens) -> str:
    full = ""
    stream = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": prompt}
        ],
        temperature=temperature,
        max_tokens=max_tokens,
        stream=True
    )
    for chunk in stream:
        delta = chunk.choices[0].delta
        if delta.content:
            print(delta.content, end="", flush=True)
            full += delta.content
    print()
    return full


def _call_claude(prompt, system, model, stream, max_tokens) -> str:
    api_key = os.getenv("ANTHROPIC_API_KEY")
    if not api_key:
        raise ValueError("未找到环境变量：ANTHROPIC_API_KEY")

    client = anthropic.Anthropic(api_key=api_key)
    chosen_model = model or "claude-sonnet-4-6"

    if stream:
        full = ""
        with client.messages.stream(
            model=chosen_model,
            max_tokens=max_tokens,
            system=system,
            messages=[{"role": "user", "content": prompt}]
        ) as s:
            for text in s.text_stream:
                print(text, end="", flush=True)
                full += text
        print()
        return full
    else:
        message = client.messages.create(
            model=chosen_model,
            max_tokens=max_tokens,
            system=system,
            messages=[{"role": "user", "content": prompt}]
        )
        return message.content[0].text


# ── 使用示例 ──
if __name__ == "__main__":
    question = "用 Python 写一个快速排序，并解释思路"

    print("=== OpenAI GPT-4o-mini ===")
    print(chat(question, provider=ModelProvider.OPENAI))

    print("\n=== Claude Sonnet ===")
    print(chat(question, provider=ModelProvider.CLAUDE))

    print("\n=== 通义千问 Plus（流式）===")
    chat(question, provider=ModelProvider.QWEN, stream=True)

六、实战：AI 代码审查工具

把这个统一接口用起来，做一个小工具——给 Python 代码做 AI 审查：

# code_reviewer.py
import sys
from pathlib import Path
from llm_client import chat, ModelProvider


CODE_REVIEW_PROMPT = """请对以下 Python 代码进行代码审查，从这几个维度分析：

1. **代码质量**：命名规范、可读性、是否符合 PEP 8
2. **潜在 Bug**：可能出错的地方
3. **性能优化**：有没有可以优化的点
4. **安全性**：是否有安全隐患（如果适用）
5. **改进建议**：给出具体的改写示例

代码如下：
```python



def review_file(filepath: str, provider: ModelProvider = ModelProvider.OPENAI) -> None:
    path = Path(filepath)
    if not path.exists():
        print(f"❌ 文件不存在：{filepath}")
        return

    code = path.read_text(encoding="utf-8")
    print(f"🔍 正在审查：{filepath}（{len(code)} 字符）\n")

    prompt = CODE_REVIEW_PROMPT.format(code=code)
    chat(prompt, provider=provider, stream=True, max_tokens=2048)


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("用法：python code_reviewer.py <文件路径>")
        sys.exit(1)

    review_file(sys.argv[1])

python code_reviewer.py my_script.py

七、模型选型参考

选模型的简单原则：

• 先用 gpt-4o-mini 或 qwen-plus 开发和测试（便宜）
• 效果不够再换 gpt-4o 或 claude-sonnet-4-6（强但贵）
• 需要处理超长文档用 Kimi 或 Claude
• 国内合规要求、不能访问境外 API 用通义千问或文心一言

小结

3 个实践建议：

1. 做统一封装层，业务代码不直接依赖具体 SDK，方便随时换模型
2. 流式输出（stream=True）让用户体验好得多，几乎所有场景都值得用
3. 把 API Key 全部放 .env，通过 os.getenv() 读取，绝对不要写死在代码里