保姆级指南：用Python调用AI大模型接口

PeterMap
13 阅读23分钟

保姆级指南：用Python调用AI大模型接口（多平台实战+通义千问专项优化，新手直接抄）

大家好，我是PeterLi。随着AI大模型的普及，越来越多开发者希望将GPT、通义千问、DeepSeek等大模型的能力集成到自己的Python项目中——无论是做对话机器人、文本生成，还是智能分析，调用大模型接口都是最直接、最高效的方式。

很多新手会觉得“调用接口很难，需要懂复杂的网络请求”，其实不然。Python的requests库或OpenAI SDK就能轻松搞定，核心逻辑简单易懂，只要掌握关键步骤，就能快速实现调用。

今天这篇博客，在原有多平台实战的基础上，重点补充阿里云通义千问（含阿里云百炼平台）的专项接入、安全优化方案，同时详解大模型对话角色体系，覆盖OpenAI、通义千问、DeepSeek三大主流平台，代码可直接复制运行，新手也能零踩坑！

一、前期准备：3件事搞定，避免踩坑

在调用任何大模型接口前，必须完成3个基础准备，这是所有操作的前提，少一步都可能调用失败。

1. 安装核心依赖库

Python调用接口的核心依赖的库分两种场景，按需安装即可，命令如下：

# 基础依赖（必装，适用于requests直接调用）
pip install requests

# 可选：处理JSON格式更便捷（非必需）
pip install json5

# 通义千问专项依赖（OpenAI SDK兼容调用+密钥安全管理）
pip install python-dotenv openai

安装完成后，根据调用方式导入对应库即可，后续实战会详细说明。

2. 获取对应平台的API密钥（关键步骤）

API密钥是大模型平台识别你身份、控制调用权限和计费的关键，不同平台的获取方式略有不同，这里以三大主流平台为例，一步一步教你获取：

⚠️ 注意：API密钥属于个人隐私，绝对不能泄露（避免被他人盗用产生额外费用），建议放在环境变量中，不要直接写在代码里，后续会详解安全优化方案。

（1）OpenAI（GPT系列）

  1. 访问OpenAI官网（需要科学上网），注册/登录账号；

  2. 进入「Personal → View API keys」页面；

  3. 点击「Create new secret key」，输入密钥名称，生成后复制保存（仅显示一次，务必记好）；

  4. 注意：OpenAI接口需要充值计费（新账号有少量免费额度），调用前确保账号有余额。

（2）阿里云通义千问（含阿里云百炼平台）

阿里云通义千问可通过两种方式获取API密钥，分别对应直接调用和阿里云百炼平台调用，按需选择：

方式1：直接调用通义千问

  1. 访问阿里云通义千问官网，注册/登录阿里云账号；

  2. 进入「控制台 → 访问控制 → AccessKey」页面；

  3. 点击「创建AccessKey」，完成身份验证后，获取「AccessKey ID」和「AccessKey Secret」（两者都需要，后续会用到）；

  4. 新手可领取免费调用额度，足够日常测试使用。

方式2：阿里云百炼平台调用（推荐，模型更丰富）

  1. 访问阿里云百炼平台官网，注册/登录阿里云账号；

  2. 进入平台后，在「个人中心 → API Keys」页面，点击「生成新密钥」；

  3. 复制生成的API密钥，保存备用（百炼平台集成了通义系列所有模型，还支持第三方模型）；

  4. 新账号可领取免费调用额度，不同模型额度不同，具体可查看平台额度说明。

（3）DeepSeek

  1. 访问DeepSeek官网，注册/登录账号；

  2. 进入「个人中心 → API Keys」页面；

  3. 点击「生成新密钥」，复制保存即可；

  4. 新账号有免费调用额度，支持多种大模型（如DeepSeek-7B、DeepSeek-Coder）。

3. 了解接口调用的核心逻辑（新手必看）

无论哪个平台的大模型接口，调用逻辑都大同小异，主要分为两种方式，核心逻辑如下：

方式1：requests库调用（通用方式）

本质是「客户端（Python代码）向服务器（大模型平台）发送HTTP请求，服务器处理后返回响应，客户端解析响应获取结果」，核心流程：

  1. 确定接口地址（每个平台的接口URL不同，官方文档可查）；

  2. 构造请求头（Header）：主要包含API密钥，用于身份验证；

  3. 构造请求体（Body）：包含对话内容、模型参数（如模型名称、温度、最大token数）；

  4. 发送POST请求（几乎所有大模型接口都用POST方式）；

  5. 解析响应结果（通常是JSON格式），提取需要的内容（如大模型的回答）。

方式2：OpenAI SDK调用（推荐，简洁高效）

OpenAI SDK是OpenAI官方推出的Python工具包，无需手动处理HTTP请求、身份验证等底层细节，许多平台（如阿里云百炼）均兼容此SDK，核心流程：

  1. 导入openai库，配置API密钥（api_key）和平台接口地址（base_url）；

  2. 通过client.chat.completions.create()方法，传入模型名称、对话消息等参数；

  3. 解析返回的ChatCompletion对象，提取大模型的回答。

二、多平台实战：Python代码直接复制使用

下面分别针对OpenAI、通义千问（两种调用方式）、DeepSeek三个平台，编写完整的调用代码，新手只需替换自己的API密钥，就能直接运行，每行代码都加了详细注释，看不懂的地方可以对照注释理解。

实战1：调用OpenAI接口（GPT-3.5/GPT-4）

适用模型：gpt-3.5-turbo（最常用，性价比高）、gpt-4（功能更强，费用更高），接口地址固定为https://api.openai.com/v1/chat/completions，这里提供两种调用方式，按需选择。

方式1：requests库调用
import requests
import json

# 1. 替换为自己的OpenAI API密钥
api_key = "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # 替换成你的密钥

# 2. 接口地址（固定不变）
url = "https://api.openai.com/v1/chat/completions"

# 3. 构造请求头（身份验证）
headers = {
    "Content-Type": "application/json",  # 固定格式，标识请求体是JSON类型
    "Authorization": f"Bearer {api_key}"  # 身份验证格式，Bearer + 空格 + API密钥
}

# 4. 构造请求体（核心参数，可根据需求调整）
payload = {
    "model": "gpt-3.5-turbo",  # 模型名称，可替换为gpt-4
    "messages": [  # 对话历史，可包含多轮对话
        {"role": "user", "content": "用Python写一个快速排序算法，附带中文注释"}  # 用户的问题/指令
    ],
    "temperature": 0.7,  # 随机性，0-1之间，越小越严谨，越大越灵活
    "max_tokens": 1000  # 最大输出token数，避免输出过长
}

# 5. 发送POST请求，调用接口
try:
    # 发送请求，timeout设置超时时间（避免网络问题卡住）
    response = requests.post(url, headers=headers, data=json.dumps(payload), timeout=10)
    # 检查请求是否成功（状态码200表示成功）
    response.raise_for_status()
    # 解析响应结果（JSON格式转Python字典）
    result = response.json()
    # 提取大模型的回答（核心内容）
    answer = result["choices"][0]["message"]["content"]
    # 打印结果
    print("OpenAI 响应结果：")
    print(answer)
except Exception as e:
    # 捕获异常，打印错误信息（方便排查问题）
    print(f"调用失败：{str(e)}")
    # 若有响应，打印完整响应（辅助排查）
    if "response" in locals():
        print(f"响应详情：{response.text}")
方式2：OpenAI SDK调用
from openai import OpenAI

# 1. 替换为自己的OpenAI API密钥
client = OpenAI(
    api_key="sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",  # 替换成你的密钥
    base_url="https://api.openai.com/v1"  # OpenAI官方接口地址，固定不变
)

# 2. 调用模型，构造对话参数
completion = client.chat.completions.create(
    model="gpt-3.5-turbo",  # 模型名称，可替换为gpt-4
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': '用Python写一个快速排序算法，附带中文注释'}
    ],
    temperature=0.7,
    max_tokens=1000
)

# 3. 提取并打印结果
print("OpenAI 响应结果：")
print(completion.choices[0].message.content)

⚠️ 注意：如果出现“网络连接失败”，需检查是否科学上网；如果出现“API key invalid”，需检查密钥是否正确。

实战2：调用阿里云通义千问接口（重点专项）

通义千问支持两种调用方式：requests库直接调用（需处理签名）、OpenAI SDK兼容调用（推荐，简洁高效），同时补充密钥安全优化方案，适配阿里云百炼平台所有通义系列模型（如qwen-max、qwen-plus、qwen-flash）。

方式1：requests库调用（传统方式，需处理签名）

接口地址根据模型不同略有差异，这里以常用的「qwen-max」模型为例，签名逻辑已封装，新手只需替换AccessKey即可。

import requests
import json
import hmac
import hashlib
import base64
from datetime import datetime
from urllib.parse import quote_plus

# 1. 替换为自己的阿里云AccessKey ID和AccessKey Secret
access_key_id = "LTAIxxxxxxxxxxxxxxxx"  # 替换成你的AccessKey ID
access_key_secret = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # 替换成你的AccessKey Secret

# 2. 接口相关配置（模型为qwen-max，可替换为qwen-plus、qwen-flash等）
model = "qwen-max"
url = f"https://chatqwen.cn-hangzhou.aliyuncs.com/v1/chat/completions"

# 3. 构造请求头（通义千问需要额外处理签名，这里直接封装好，无需修改）
def get_aliyun_header():
    # 生成时间戳（固定格式）
    date = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
    # 构造待签名字符串
    canonical_uri = "/v1/chat/completions"
    canonical_querystring = ""
    canonical_headers = f"content-type:application/json\nhost:chatqwen.cn-hangzhou.aliyuncs.com\nx-acs-date:{date}\n"
    signed_headers = "content-type;host;x-acs-date"
    payload_str = json.dumps(payload)
    canonical_request = f"POST\n{canonical_uri}\n{canonical_querystring}\n{canonical_headers}\n{signed_headers}\n{hashlib.sha256(payload_str.encode()).hexdigest()}"
    # 生成签名
    string_to_sign = f"ACS3-HMAC-SHA256\n{date}\n{hashlib.sha256(canonical_request.encode()).hexdigest()}"
    signature = hmac.new(access_key_secret.encode(), string_to_sign.encode(), hashlib.sha256).digest()
    signature = base64.b64encode(signature).decode()
    # 构造请求头
    headers = {
        "Content-Type": "application/json",
        "X-ACS-Date": date,
        "Authorization": f"ACS3-HMAC-SHA256 AccessKeyId={access_key_id}, SignedHeaders={signed_headers}, Signature={signature}"
    }
    return headers

# 4. 构造请求体（和OpenAI类似，参数可调整）
payload = {
    "model": model,
    "messages": [
        {"role": "user", "content": "解释什么是提示词工程，用300字以内，适配新手"}
    ],
    "temperature": 0.7,
    "max_tokens": 500
}

# 5. 发送请求，调用接口
try:
    headers = get_aliyun_header()
    response = requests.post(url, headers=headers, data=json.dumps(payload), timeout=10)
    response.raise_for_status()
    result = response.json()
    answer = result["choices"][0]["message"]["content"]
    print("通义千问 响应结果：")
    print(answer)
except Exception as e:
    print(f"调用失败：{str(e)}")
    if "response" in locals():
        print(f"响应详情：{response.text}")
方式2：OpenAI SDK兼容调用（推荐，阿里云百炼平台通用）

阿里云提供OpenAI兼容接口地址，可直接使用OpenAI SDK调用，无需处理复杂签名，同时结合python-dotenv库实现密钥安全管理，避免明文泄露。

from openai import OpenAI
from dotenv import load_dotenv
import os

# 1. 加载.env配置文件，读取环境变量（避免密钥明文硬编码）
load_dotenv()

# 2. 配置客户端（替换为自己的阿里云API密钥和兼容接口地址）
client = OpenAI(
    api_key=os.getenv("api_key"),  # 从环境变量读取API密钥
    base_url=os.getenv("base_url"),  # 阿里云OpenAI兼容接口地址
)

# 3. 调用模型（模型可替换为qwen-max、qwen-flash等，需在阿里云百炼平台确认可用）
completion = client.chat.completions.create(
    # 模型列表参考：https://help.aliyun.com/zh/model-studio/getting-started/models
    model="qwen-plus",  # qwen-plus 属于 qwen3 模型，能力均衡，适合中等复杂任务
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': '你是谁？'}
    ],
    temperature=0.7,
    max_tokens=500
)

# 4. 提取并打印结果
print("通义千问 响应结果：")
print(completion.choices[0].message.content)

说明：此方式适配阿里云百炼平台所有通义系列模型，调用逻辑和OpenAI完全一致，新手可快速上手，同时通过环境变量管理密钥，安全性更高。

通义千问调用安全优化方案（重点）

核心是通过python-dotenv库避免API Key明文硬编码，防止密钥泄露，这是行业标准的安全实践，完整步骤如下：

1. 完整优化代码（可直接复制运行）
from openai import OpenAI
from dotenv import load_dotenv
import os

# 加载 .env 文件（自动读取环境变量，避免密钥明文）
load_dotenv()

# 配置客户端，所有敏感信息从环境变量读取
client = OpenAI(
    api_key=os.getenv("api_key"),
    base_url=os.getenv("base_url"),
)

# 调用模型
completion = client.chat.completions.create(
    model="qwen-plus",  # 可替换为qwen-max、qwen-flash等模型
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': '你是谁？'}
    ]
)
print(completion.choices[0].message.content)
2. 核心优化逻辑

（1）新增依赖与环境加载：引入python-dotenv库，通过load_dotenv()方法自动加载项目根目录下的.env配置文件，将环境变量注入系统，供代码读取。

from dotenv import load_dotenv
import os
load_dotenv()

（2）环境变量读取：从环境变量中读取api_key和base_url，替代硬编码的明文，代码中不再出现敏感信息，即使代码上传到Git等平台，也不会泄露密钥。

api_key=os.getenv("api_key"),
base_url=os.getenv("base_url"),
3. 完整使用步骤

步骤1：安装依赖库（已在前期准备中说明）

pip install python-dotenv openai

步骤2：创建.env配置文件

在项目根目录新建.env文件，写入你的密钥和接口地址，注意不要提交到Git：

# .env 文件内容（不要提交到Git）
api_key=你的阿里云通义千问API Key
base_url=https://dashscope.aliyuncs.com/compatible-mode/v1

步骤3：配置.gitignore（关键）

在.gitignore文件中添加.env，防止配置文件被误提交到代码仓库：

# .gitignore
.env

步骤4：运行代码

直接执行优化后的Python脚本，即可正常调用大模型，同时保证密钥安全。

4. 常见问题与补充说明

（1）若运行报错ModuleNotFoundError: No module named 'dotenv'，需重新执行pip install python-dotenv；

（2）若API Key读取为空，需检查.env文件路径是否正确（必须在项目根目录，且文件名正确）；

（3）不要将.env文件上传到任何公开平台，避免密钥被盗用；

（4）适用场景：该方案适用于所有需要隐藏API密钥、数据库密码等敏感信息的Python项目；

（5）进阶优化：可在.env中配置模型名称、超时时间等参数，统一管理配置；生产环境可结合Docker、K8s的环境变量注入，进一步提升安全性。

实战3：调用DeepSeek接口

DeepSeek的接口调用逻辑和OpenAI非常相似，支持requests库和OpenAI SDK两种方式，上手难度最低，适合新手快速测试，这里以「deepseek-chat」模型为例。

方式1：requests库调用
import requests
import json

# 1. 替换为自己的DeepSeek API密钥
api_key = "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # 替换成你的密钥

# 2. 接口地址（固定不变）
url = "https://api.deepseek.com/v1/chat/completions"

# 3. 构造请求头
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {api_key}"
}

# 4. 构造请求体（参数和OpenAI基本一致，可直接参考）
payload = {
    "model": "deepseek-chat",  # 模型名称，可替换为deepseek-coder（代码专用）
    "messages": [
        {"role": "user", "content": "帮我排查一段Python代码的报错，代码：print('Hello World')x，报错信息：SyntaxError: invalid syntax"}
    ],
    "temperature": 0.5,
    "max_tokens": 500
}

# 5. 发送请求，调用接口
try:
    response = requests.post(url, headers=headers, data=json.dumps(payload), timeout=10)
    response.raise_for_status()
    result = response.json()
    answer = result["choices"][0]["message"]["content"]
    print("DeepSeek 响应结果：")
    print(answer)
except Exception as e:
    print(f"调用失败：{str(e)}")
    if "response" in locals():
        print(f"响应详情：{response.text}")
方式2：OpenAI SDK调用
from openai import OpenAI

# 1. 替换为自己的DeepSeek API密钥
client = OpenAI(
    api_key="sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",  # 替换成你的密钥
    base_url="https://api.deepseek.com/v1"  # DeepSeek接口地址，固定不变
)

# 2. 调用模型
completion = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': '帮我排查一段Python代码的报错，代码：print("Hello World")x，报错信息：SyntaxError: invalid syntax'}
    ],
    temperature=0.5,
    max_tokens=500
)

# 3. 打印结果
print("DeepSeek 响应结果：")
print(completion.choices[0].message.content)

优势：DeepSeek的免费额度充足，调用速度快，适合代码调试、文本生成等日常场景，新手可以优先用这个平台测试。

三、核心参数解析：按需调整，让输出更贴合需求

上面的代码中，有几个核心参数几乎所有平台都通用，调整这些参数可以改变大模型的输出效果，根据自己的需求灵活设置：

1. model（模型名称）

指定调用的大模型，不同平台的模型名称不同，常见可选值：

  • OpenAI：gpt-3.5-turbo、gpt-4、gpt-4-turbo；

  • 通义千问（阿里云百炼）：qwen-max（复杂任务）、qwen-plus（均衡）、qwen-flash（简单任务，速度快、成本低）、qwen-coder（代码专用）；

  • DeepSeek：deepseek-chat（通用对话）、deepseek-coder（代码专用）。

2. temperature（温度）

取值范围0-1，控制输出的随机性：

  • 0.1-0.3：输出更严谨、固定，适合需要精准结果的场景（如代码调试、数据分析）；

  • 0.5-0.7：平衡严谨和灵活，适合日常对话、文本生成；

  • 0.8-1.0：输出更有创意、随机性强，适合文案创作、 brainstorming。

3. max_tokens（最大输出token数）

控制大模型的最大输出长度，token可以理解为“字符片段”（1个汉字约等于2个token），设置时需注意：

  • 不要设置过大（如超过2000），否则会增加调用成本，且响应速度变慢；

  • 不要设置过小，否则会导致输出不完整（如代码没写完、解释没说透）；

  • 日常测试设置500-1000即可，复杂场景（如长文本总结）可设置1500-2000。

4. messages（对话历史）

用于实现多轮对话，格式是列表，内嵌多个字典，每个字典包含role（角色）和content（内容），这是大模型调用的核心，下面详细解析三大核心角色。

四、大模型对话角色体系详解（新手必懂）

messages参数是OpenAI API的标准结构，阿里云通义千问、DeepSeek等兼容OpenAI接口的大模型均完全遵循此规范，掌握角色体系，能让模型输出更贴合预期，实现定制化交互。

1. 核心结构说明

messages是一个列表（list），内嵌多个字典（dict），每个字典的固定结构为：

{'role': '角色类型', 'content': '对应内容'}

其中role定义了消息的身份，content是该角色的具体内容，三者共同构成完整的对话上下文，驱动模型生成符合预期的回复。

2. 三大核心角色全解析

（1）System（系统角色）

定位：控制对话的全局方向和模型的行为模式，是整个对话的「总纲」，优先级最高。

核心作用：

  • 设定上下文：定义对话的背景、目标或规则（例如 “你是一个专业翻译，只回答与翻译相关的问题”）；

  • 调整风格：指定回复的语气（严肃 / 幽默）、格式（分点 / Markdown）或内容限制（避免敏感话题）；

  • 长期控制：在对话中持续影响模型的输出，即使后续对话中没有重复指令。

典型场景：初始化对话时设定角色（如医生、律师、代码助手）、限制模型的回答范围、设定复杂任务的流程。

（2）User（用户角色）

定位：代表真实用户输入，是驱动对话的核心，模型的回复始终围绕User的内容展开。

核心作用：

  • 提出问题或请求（如 “帮我写一首关于夏天的诗”）；

  • 提供补充信息（如 “上一句翻译成法语”）；

  • 修正模型行为（如 “用更简单的语言解释”）。

典型场景：直接交互（用户提问、追问或反馈）、间接控制（通过用户消息调整模型输出）。

（3）Assistant（助手角色）

定位：模型生成的回复内容，用于保留对话历史，实现多轮对话的连贯性。

核心作用：

  • 回答问题：基于上下文生成符合用户需求的回复；

  • 自我修正：在后续对话中根据用户反馈调整回答；

  • 遵循指令：执行system或user指定的规则（如分点回答、使用特定格式）。

典型场景：直接生成文本、代码、建议等；通过历史assistant消息实现多轮对话连贯性。

3. 角色交互流程与实战示例

完整交互逻辑：System设定框架 → User提供具体输入 → Assistant生成回复，三者形成闭环；多轮对话中，历史的User/Assistant消息会作为上下文保留，System指令全程生效。

实战示例（结合通义千问调用）：

messages=[
    # System角色：全局设定（前置，全程生效）
    {'role': 'system', 'content': '你是一个专业的Java后端技术专家，只回答Java相关问题，用简洁的技术语言分点回复'},
    # User角色：用户提问
    {'role': 'user', 'content': 'SpringBoot如何实现全局异常处理？'},
    # Assistant角色：模型历史回复（多轮对话时保留，维持上下文）
    {'role': 'assistant', 'content': '1. 自定义全局异常处理器，使用@RestControllerAdvice和@ExceptionHandler注解；2. 定义异常类，继承RuntimeException；3. 在处理器中捕获对应异常，返回统一响应格式。'},
    # 新一轮User提问（基于历史上下文）
    {'role': 'user', 'content': '那如何自定义异常类？'}
]

4. 关键使用技巧

  1. System指令前置：System消息必须放在messages列表最前面，确保全局生效；

  2. System指令精简明确：避免冗长描述，用清晰的规则约束模型行为；

  3. 多轮对话保留历史：多轮交互时，需保留历史User/Assistant消息，维持上下文连贯性；

  4. 敏感信息规避：System中可添加 “禁止回答敏感话题” 等规则，提升安全性。

五、常见问题排查：新手必看，避免踩坑

调用接口时，很容易遇到各种问题，这里整理了5个最常见的错误及解决方案，结合新增的通义千问报错场景，遇到问题直接对照排查即可：

1. 错误：API key invalid / 身份验证失败

原因：API密钥错误、密钥过期，或请求头格式错误；

解决方案：

  • 检查API密钥是否正确，重新复制粘贴（不要多空格、少字符）；

  • 检查请求头中Authorization的格式（必须是“Bearer + 空格 + 密钥”）；

  • 登录对应平台，确认密钥是否过期，若过期则重新生成。

2. 错误：网络连接超时 / Connection refused / link dead

原因：网络问题、平台接口不可用，或OpenAI需要科学上网；常见于OpenAI、DeepSeek接口调用。

解决方案：

  • 检查网络是否正常，尝试访问对应平台官网，确认接口可用；

  • 调用OpenAI接口时，确保已开启科学上网，且代理配置正确；

  • 调整timeout参数（如设置为15），避免因网络延迟导致超时。

3. 错误：link hit security strategy

原因：阿里云通义千问接口调用时，触发了平台安全策略（如IP受限、接口地址错误）；常见于通义千问接口调用。

解决方案：

  • 检查接口地址是否正确，通义千问兼容接口地址为https://dashscope.aliyuncs.com/compatible-mode/v1；

  • 确认账号无异常，未触发平台安全限制，可登录阿里云控制台查看账号状态；

  • 更换网络环境，避免IP被限制。

4. 错误：Insufficient quota / 额度不足

原因：账号免费额度用完，或未充值；

解决方案：

  • 登录对应平台，查看账号额度，领取免费额度（若有）；

  • 按需充值，OpenAI、通义千问、DeepSeek都支持按需充值，最低充值金额不高。

补充：阿里云通义千问不同模型免费额度不同，qwen-max、qwen-plus等模型新账号可领取各100万Token免费额度，有效期90天。

5. 错误：Invalid request: model not found

原因：模型名称错误，或该模型未开通使用权限；

解决方案：

  • 查看对应平台的官方文档，确认模型名称的正确写法（如通义千问的qwen-plus而非qwen_plus）；

  • 登录平台，确认该模型已开通（部分模型需要申请开通）；

  • 阿里云百炼平台模型列表参考：help.aliyun.com/zh/model-st…

六、进阶优化：让代码更规范、更实用

上面的代码是基础版本，适合测试和入门，实际项目中可以做以下优化，提升代码的可维护性和安全性，结合前文通义千问安全优化方案，补充更多实用技巧：

1. 把API密钥放在环境变量中（推荐，已在通义千问专项中详解）

避免直接将密钥写在代码里，防止泄露，核心是使用python-dotenv库读取.env文件，具体步骤参考通义千问安全优化方案。

2. 封装成函数，重复调用

如果需要多次调用接口，可以将调用逻辑封装成函数，避免重复写代码，这里以通义千问调用为例：

import openai
from dotenv import load_dotenv
import os

load_dotenv()

# 初始化客户端（全局一次即可）
client = openai.OpenAI(
    api_key=os.getenv("api_key"),
    base_url=os.getenv("base_url"),
)

def call_qwen(prompt, model="qwen-plus", temperature=0.7, max_tokens=1000):
    """
    调用通义千问接口的封装函数
    :param prompt: 用户的问题/指令
    :param model: 调用的模型名称（qwen-max、qwen-plus等）
    :param temperature: 随机性
    :param max_tokens: 最大输出token数
    :return: 大模型的回答，失败则返回None
    """
    try:
        completion = client.chat.completions.create(
            model=model,
            messages=[
                {'role': 'system', 'content': 'You are a helpful assistant.'},
                {'role': 'user', 'content': prompt}
            ],
            temperature=temperature,
            max_tokens=max_tokens
        )
        return completion.choices[0].message.content
    except Exception as e:
        print(f"通义千问调用失败：{str(e)}")
        return None

# 调用函数
answer = call_qwen("解释什么是提示词工程，300字以内")
if answer:
    print(answer)

3. 处理多轮对话

如果需要实现连续对话（如聊天机器人），可以用列表保存对话历史，每次调用时传入完整的对话列表：

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()
client = OpenAI(
    api_key=os.getenv("api_key"),
    base_url=os.getenv("base_url"),
)

# 初始化对话历史（包含System角色，全局设定）
chat_history = [{"role": "system", "content": "你是一位友好的AI助手，回答简洁易懂，仅用中文回复"}]

# 多轮对话循环
while True:
    user_input = input("请输入你的问题（输入q退出）：")
    if user_input.lower() == "q":
        break
    # 添加用户输入到对话历史
    chat_history.append({"role": "user", "content": user_input})
    # 调用接口（传入完整对话历史）
    completion = client.chat.completions.create(
        model="qwen-plus",
        messages=chat_history,
        temperature=0.7,
        max_tokens=1000
    )
    answer = completion.choices[0].message.content
    # 添加AI回答到对话历史，维持上下文
    chat_history.append({"role": "assistant", "content": answer})
    # 打印回答
    print(f"AI：{answer}")

4. 开启流式输出，提升体验

大模型生成较长内容时，流式输出可实现“边生成边显示”，提升用户体验，核心只需添加stream=True参数，示例如下：

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()
client = OpenAI(
    api_key=os.getenv("api_key"),
    base_url=os.getenv("base_url"),
)

# 开启流式输出
response = client.chat.completions.create(
    model="qwen-plus",
    messages=[
        {'role': 'user', 'content': '用Python写一个完整的学生管理系统，附带详细注释'}
    ],
    stream=True  # 开启流式输出
)

# 循环打印流式结果
print("通义千问 流式响应结果：")
for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end='', flush=True)

结尾

到这里，用Python调用AI大模型接口的核心方法、多平台实战、通义千问专项优化以及对话角色体系就全部讲完了。其实核心逻辑很简单，无论是requests库还是OpenAI SDK，本质都是“构造请求→发送请求→解析响应”。

本文重点补充了阿里云通义千问的两种调用方式、密钥安全优化方案，同时详解了角色体系，让新手不仅能“会调用”，还能“安全调用、灵活调用”。三个平台的实战代码可以直接复制使用，新手只需替换自己的API密钥，就能快速上手。

无论是做个人项目、办公自动化，还是开发商业应用，调用大模型接口都能大幅提升效率。后续可以结合自己的需求，尝试封装更复杂的逻辑（如批量调用、结果保存），也可以探索更多平台的接口（如百度文心一言、字节跳动火山方舟）。

如果觉得有用，欢迎点赞、收藏、转发，也可以在评论区分享你的调用经验，或者提问你遇到的问题，一起交流进步～

avatar
文章
阅读
粉丝