ai全栈软件开发day21（第四阶段喽）

Python 速通、AI 环境搭建与大模型 API 初探

2026-07-30 周四 AI 大模型开发基础 阅读约 18 分钟

本文目录

1. 今日学习内容
2. [Python 语法速通](#Python 语法速通)
3. [AI 开发环境搭建](#AI 开发环境搭建)
4. [大模型 API 调用实战](#大模型 API 调用实战)
5. 提示工程入门
6. 踩坑记录
7. 收获总结
8. 明日计划

今日学习内容

今天是 Day 21，也是一个全新的开始 ------ **第四阶段「AI 大模型开发基础」**正式启程！经过前面 20 天的高强度学习，我们已经打下了坚实的 Java 全栈基础：从 Vue 3 前端到 Spring Boot 后端，从 MySQL 到 Redis，从单体应用到 Spring Cloud 微服务。现在，我们终于要踏入 AI 的世界了。

说实话，从 Java 转向 Python 和大模型开发，内心既兴奋又忐忑。兴奋的是终于要接触最前沿的 AI 技术了，忐忑的是 Python 生态和 Java 差异很大，需要快速适应。不过有前面的编程基础打底，相信过渡会相对平滑。

今天的学习目标非常明确：

• Python 语法速通：用 Java 程序员的视角，快速掌握 Python 核心语法（数据类型、流程控制、函数、面向对象、容器）
• AI 开发环境搭建：Python 3.11、Anaconda、VS Code、Jupyter Notebook、虚拟环境管理
• 大模型 API 调用：OpenAI API 格式、国内大模型平台（DeepSeek/智谱/通义）接入、HTTP 请求封装
• 提示工程入门：Zero-shot / Few-shot、角色设定、结构化提示、链式思考

阶段目标：第四阶段共 5 天，目标是掌握 Python 编程基础、提示工程、LangChain 框架、FastAPI 和向量数据库，最终能独立开发一个基于大模型的智能问答系统后端。

Python 语法速通

如果你已经熟练掌握 Java，学习 Python 就像是从手动挡切换到自动挡 ------ 语法更简洁，但需要适应新的编程范式。我的策略是「对比学习」：用 Java 的概念映射到 Python，快速建立认知。

变量与数据类型

Python 是动态类型语言，不需要显式声明变量类型。这既是便利也是陷阱 ------ 类型错误往往在运行时才暴露。

python_crash_course.pyPython

# Python 没有 int/double/String 关键字，直接赋值即可
name = "AI 全栈工程师"        # str
age = 21                    # int
pi = 3.14159                # float
is_student = True           # bool
skills = ["Java", "Vue", "Python"]  # list（相当于 Java ArrayList）
profile = {"name": name, "age": age}  # dict（相当于 Java HashMap）

# type() 查看类型，isinstance() 做类型检查（推荐）
print(type(name))           # <class 'str'>
print(isinstance(age, int))  # True

# f-string 格式化（Python 3.6+），比 Java 的 String.format 优雅太多
print(f"我是{name}，学习第{age}天，掌握{len(skills)}项技能")
# 输出：我是AI 全栈工程师，学习第21天，掌握3项技能

流程控制与推导式

Python 的缩进语法需要特别注意 ------ 它用缩进来表示代码块，而不是大括号。这迫使代码必须保持良好的格式，但也容易因为混用空格和 Tab 导致报错。

control_flow.pyPython

# if-elif-else（注意冒号和缩进！）
score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "C"

# for 循环遍历（没有传统 for-i 循环，用 range()）
for i in range(5):           # 0,1,2,3,4
    print(i)

# 列表推导式 ------ Python 的灵魂特性之一
numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers if x % 2 == 0]
print(squares)  # [4, 16]
# 等价 Java：numbers.stream().filter(x -> x % 2 == 0).map(x -> x * x).toList()

# 字典推导式
word_lengths = {word: len(word) for word in ["AI", "Python", "LangChain"]}
print(word_lengths)  # {'AI': 2, 'Python': 6, 'LangChain': 9}

函数与面向对象

Python 的函数支持默认参数、可变参数、关键字参数，非常灵活。面向对象方面，Python 的类机制相对简单，没有访问修饰符（public/private），通过命名约定（单下划线/双下划线）来表示私有性。

oop_demo.pyPython

class AIModel:
    # 类属性（相当于 Java static）
    provider = "OpenAI"

    # __init__ 是构造方法（注意双下划线）
    def __init__(self, model_name: str, api_key: str):
        self.model_name = model_name    # 实例属性
        self._api_key = api_key         # 约定：单下划线 = "受保护"
        self.__call_count = 0          # 双下划线 = 名称修饰（伪私有）

    # 实例方法，第一个参数必须是 self
    def chat(self, prompt: str) -> str:
        self.__call_count += 1
        return f"[{self.model_name}] 回复：{prompt[:20]}..."

    # @property 装饰器 ------ 把方法变成属性访问
    @property
    def call_count(self) -> int:
        return self.__call_count

    # 类方法
    @classmethod
    def create_default(cls):
        return cls("gpt-4o-mini", "sk-xxx")

# 使用
model = AIModel("gpt-4o", "sk-test123")
print(model.chat("你好，请介绍一下自己"))
print(model.call_count)  # 1（像属性一样访问，不需要括号）

Python 容器速查

containers.pyPython

# list ------ 有序可变，相当于 Java ArrayList
arr = [1, 2, 3]
arr.append(4)
arr[0] = 10           # 索引访问
last = arr[-1]       # 负数索引 = 倒数第一个，Python 特色！
sub = arr[1:3]      # 切片 [2, 3]

# tuple ------ 有序不可变，相当于 "只读列表"
t = (1, 2, 3)
# t[0] = 10  # TypeError!

# dict ------ 键值对，相当于 Java HashMap
d = {"name": "Alice", "age": 25}
d["city"] = "Beijing"
print(d.get("salary", 0))  # 安全取值，默认 0

# set ------ 无序不重复，相当于 Java HashSet
s = {1, 2, 3, 3, 3}
print(s)  # {1, 2, 3}

# 解包（unpacking）------ Python 的神级语法
a, b, *rest = [1, 2, 3, 4, 5]
print(rest)  # [3, 4, 5]

AI 开发环境搭建

工欲善其事，必先利其器。AI 开发对 Python 版本和依赖管理要求很高，因为很多深度学习库对版本兼容性极其敏感。今天搭建了一套「可复现」的开发环境。

环境清单

• Python 3.11.9：当前 AI 生态的主流版本，比 3.12 兼容性更好
• Miniconda：轻量级环境管理器，比 Anaconda 更省空间
• VS Code：配合 Python 插件 + Jupyter 插件，开发体验极佳
• Poetry：现代化 Python 依赖管理工具（替代 pip + requirements.txt）

终端命令Bash

# 1. 安装 Miniconda（Windows PowerShell）
# 下载地址：https://docs.conda.io/en/latest/miniconda.html

# 2. 创建独立环境（隔离是王道！）
conda create -n ai-dev python=3.11 -y
conda activate ai-dev

# 3. 安装核心依赖
pip install openai requests python-dotenv jupyterlab

# 4. 验证环境
python -c "import openai; print(openai.__version__)"
# 输出：1.35.12（或更高）

项目结构规划

项目目录结构Tree

ai-learning/
├── .env                    # API 密钥等敏感配置（加入 .gitignore！）
├── .gitignore
├── requirements.txt        # 依赖清单
├── notebooks/              # Jupyter 实验笔记
│   ├── 01_python_basics.ipynb
│   └── 02_prompt_engineering.ipynb
├── src/
│   ├── __init__.py
│   ├── llm_client.py       # 大模型 API 封装
│   └── prompt_templates.py # 提示词模板库
└── tests/
    └── test_llm_client.py

安全提醒 ：永远不要将 API Key 硬编码在代码中！使用 .env 文件存储密钥，并通过 python-dotenv 加载。.env 文件必须加入 .gitignore，否则密钥泄露可能导致账号被盗刷。

大模型 API 调用实战

学会调用大模型 API 是 AI 应用开发的第一步。目前主流的大模型 API 基本遵循 OpenAI 的格式标准，这意味着学会一套接口，就能快速迁移到国内各大平台。

封装通用 LLM 客户端

为了让代码可复用、可切换不同模型，我封装了一个通用的 LLMClient 类，支持 OpenAI、DeepSeek、智谱 GLM、阿里通义等多个平台。

src/llm_client.pyPython

import os
from typing import Iterator, Optional
from dataclasses import dataclass
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

@dataclass
class LLMConfig:
    """大模型配置"""
    base_url: str
    api_key: str
    model: str
    temperature: float = 0.7
    max_tokens: int = 2048

class LLMClient:
    """通用大模型客户端，兼容 OpenAI 格式"""

    # 预置常用平台配置
    PRESETS = {
        "deepseek": LLMConfig(
            base_url="https://api.deepseek.com/v1",
            api_key=os.getenv("DEEPSEEK_API_KEY", ""),
            model="deepseek-chat"
        ),
        "zhipu": LLMConfig(
            base_url="https://open.bigmodel.cn/api/paas/v4",
            api_key=os.getenv("ZHIPU_API_KEY", ""),
            model="glm-4-flash"
        ),
        "openai": LLMConfig(
            base_url="https://api.openai.com/v1",
            api_key=os.getenv("OPENAI_API_KEY", ""),
            model="gpt-4o-mini"
        ),
    }

    def __init__(self, config: LLMConfig):
        self.config = config
        self.client = OpenAI(
            base_url=config.base_url,
            api_key=config.api_key
        )

    @classmethod
    def from_preset(cls, name: str) -> "LLMClient":
        if name not in cls.PRESETS:
            raise ValueError(f"Unknown preset: {name}. Available: {list(cls.PRESETS.keys())}")
        return cls(cls.PRESETS[name])

    def chat(
        self,
        messages: list[dict],
        stream: bool = False,
        temperature: Optional[float] = None
    ) -> str | Iterator[str]:
        """
        发送对话请求
        :param messages: 消息列表，格式 [{"role": "user", "content": "..."}, ...]
        :param stream: 是否流式输出
        :param temperature: 创造性参数（0~2），越大越随机
        """
        response = self.client.chat.completions.create(
            model=self.config.model,
            messages=messages,
            stream=stream,
            temperature=temperature or self.config.temperature,
            max_tokens=self.config.max_tokens
        )

        if stream:
            return (chunk.choices[0].delta.content or ""
                    for chunk in response if chunk.choices[0].delta.content)

        return response.choices[0].message.content

    def simple_chat(self, prompt: str, system: str = "") -> str:
        """简化版单轮对话"""
        messages = []
        if system:
            messages.append({"role": "system", "content": system})
        messages.append({"role": "user", "content": prompt})
        return self.chat(messages)

调用示例：非流式 vs 流式

test_llm.pyPython

from src.llm_client import LLMClient

# 1. 从预置配置创建客户端（自动读取 .env 中的 API Key）
client = LLMClient.from_preset("deepseek")

# 2. 非流式调用（等待完整响应）
response = client.simple_chat(
    prompt="用一句话解释什么是 RAG",
    system="你是一位耐心的 AI 讲师，用中文回答"
)
print(response)
# 输出：RAG（检索增强生成）是一种让大模型在回答问题时先检索外部知识库，再将检索到的信息与生...

# 3. 流式调用（逐字输出，适合打字机效果）
print("\n=== 流式输出 ===")
stream = client.chat(
    messages=[{"role": "user", "content": "Python 的列表推导式有什么优势？"}],
    stream=True
)
for chunk in stream:
    print(chunk, end="", flush=True)

# 4. 多轮对话（保留上下文）
messages = [
    {"role": "system", "content": "你是 Java 专家，帮助用户学习 Python"},
    {"role": "user", "content": "Python 的 self 和 Java 的 this 有什么区别？"},
    {"role": "assistant", "content": "主要区别有三点：1. Python 的 self 必须显式声明..."},
    {"role": "user", "content": "那 @classmethod 对应 Java 的什么？"},
]
response = client.chat(messages)
print(response)

选择模型的建议：学习阶段推荐 DeepSeek 或智谱 GLM-4-Flash，它们对中文支持好且成本极低（甚至免费额度够用）。OpenAI 的 gpt-4o-mini 也很便宜，但需要解决网络问题。生产环境根据业务需求选择模型能力 vs 成本的平衡点。

提示工程入门

提示工程（Prompt Engineering）被很多人戏称为「咒语学」，但它实际上是一门关于「如何与模型高效沟通」的技术。一个好的提示词，能让模型输出质量提升数倍。

核心技巧一：角色设定（Role Prompting）

给模型设定一个明确的角色，能显著改变回答的风格和深度。这是因为大模型在预训练时学习了大量不同角色的文本，角色提示相当于激活了对应的「专家模式」。

prompt_templates.pyPython

# 策略对比：无角色 vs 有角色

# ❌ 差提示
BAD_PROMPT = "解释一下 RESTful API"

# ✅ 好提示：角色 + 目标受众 + 输出格式
GOOD_PROMPT = """你是一位拥有 10 年经验的 Java 后端架构师，
正在给一位从 Java 转 Python 的 AI 全栈工程师讲解概念。
请用类比的方式解释 RESTful API，并给出 Python（FastAPI）和 Java（Spring Boot）的代码对比。
要求：
1. 先用一个生活化的类比引入
2. 分点说明核心原则
3. 代码片段带注释
4. 总字数控制在 300 字以内"""

# 调用
client = LLMClient.from_preset("zhipu")
result = client.simple_chat(GOOD_PROMPT)
print(result)

核心技巧二：Few-shot 示例学习

Zero-shot 是直接给任务，Few-shot 是先给几个示例让模型「照葫芦画瓢」。对于格式敏感的任务（如 JSON 提取、情感分类），Few-shot 的效果通常明显更好。

few_shot_demo.pyPython

# Few-shot 示例：从用户评论中提取情感标签和关键词

few_shot_prompt = """请分析用户评论的情感倾向，并提取关键词。
输出格式必须是 JSON：{"sentiment": "正面/负面/中性", "keywords": ["关键词1", ...], "score": 0~1}

示例1：
评论："这个手机电池太耐用了，一天不用充电！"
输出：{"sentiment": "正面", "keywords": ["电池", "耐用"], "score": 0.95}

示例2：
评论："物流慢得像蜗牛，等了一周才到。"
输出：{"sentiment": "负面", "keywords": ["物流慢", "等待时间长"], "score": 0.15}

示例3：
评论："功能挺全的，不过价格有点贵。"
输出：{"sentiment": "中性", "keywords": ["功能全", "价格贵"], "score": 0.5}

现在请分析：
评论："Python 的语法真的很优雅，写起来比 Java 爽多了，就是运行速度有点慢。"
输出："""

client = LLMClient.from_preset("deepseek")
result = client.simple_chat(few_shot_prompt)
print(result)
# 输出：{"sentiment": "正面", "keywords": ["语法优雅", "开发效率高"], "score": 0.75}

核心技巧三：链式思考（Chain-of-Thought）

对于复杂推理任务（数学计算、逻辑判断、代码调试），直接问答案模型容易出错。通过在提示词中加入「请一步步思考」或「Let's think step by step」，能引导模型展示推理过程，显著提高准确率。

cot_demo.pyPython

# 链式思考：让模型展示推理过程

math_prompt = """你是一位严格的数学老师。请解答下面的题目，
必须展示完整的推理步骤，最后给出答案。

题目：一个水池有甲、乙两个进水管。单开甲管 6 小时注满，单开乙管 4 小时注满。
如果两管同时开，几小时可以注满？

请按以下格式回答：
步骤1：...
步骤2：...
...
答案：X 小时"""

client = LLMClient.from_preset("zhipu")
result = client.simple_chat(math_prompt)
print(result)
# 模型会输出详细的步骤推导，而不是直接猜一个数字

提示词工程黄金法则：1) 明确角色和任务边界；2) 提供输入/输出的具体格式示例；3) 复杂任务拆分为子步骤；4) 用分隔符（如 ###）区分不同部分；5) 给模型「思考时间」（Chain-of-Thought）；6) 迭代优化，根据输出结果反向调整提示词。

踩坑记录

坑 1：Conda 环境激活后 pip 安装的包不在环境里

现象 ：激活了 ai-dev 环境，用 pip install openai 安装成功，但运行代码时提示 ModuleNotFoundError: No module named 'openai'。

原因：Windows 上如果同时安装了系统 Python 和 Anaconda，PowerShell 的 pip 可能指向系统 Python 的 pip，而不是当前 conda 环境的 pip。

解决 ：在 conda 环境中使用 python -m pip install openai，确保使用的是当前环境的 Python 解释器。或者先执行 conda install pip 再使用 pip。

坑 2：OpenAI 客户端连接超时 / SSL 错误

现象 ：调用国内大模型 API（如 DeepSeek）时，偶尔出现 APIConnectionError 或 SSL 证书验证失败。

原因：部分国内 API 节点的 SSL 证书链不完整，或者网络存在中间人代理干扰。

解决：在创建 OpenAI 客户端时添加超时和重试配置；开发环境可临时关闭 SSL 验证（生产环境不推荐）。另外建议使用 requests 库的 Session 复用连接。

坑 3：Python 的 mutable 默认参数陷阱

现象 ：写了一个函数 def foo(items=[])，多次调用后发现列表里的数据在累积。

原因：Python 的默认参数在函数定义时只计算一次，而不是每次调用时。如果默认参数是可变对象（list/dict），所有调用会共享同一个对象！

解决 ：使用 None 作为默认值，在函数体内初始化。

代码修正：

# ❌ 错误
def append_item(item, items=[]):
    items.append(item)
    return items

# ✅ 正确
def append_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

坑 4：API Key 泄露到 GitHub

现象：不小心把包含 API Key 的代码 push 到了公开仓库，几分钟后收到邮件提醒「您的 API Key 已被禁用」。

原因：各大平台（OpenAI/DeepSeek 等）都有爬虫监控公开仓库的密钥，一旦泄露会立即自动禁用。

解决 ：1) 立即在平台后台撤销该 Key 并重新生成；2) 使用 .env + .gitignore 管理密钥；3) 使用 git filter-repo 或 BFG 从历史提交中彻底删除敏感信息。

收获总结

今日学习收获

今天完成了从 Java 到 Python 的「语境切换」，并成功调通了第一个大模型 API。总结一下关键收获：

• Python 核心语法：动态类型、缩进语法、列表/字典推导式、装饰器、解包 ------ 这些特性让代码表达力极强，但也需要适应「Pythonic」的思维方式
• 环境管理：conda 虚拟环境是 Python 开发的必备技能，隔离环境能避免 90% 的依赖冲突问题
• LLM API 封装：通过 LLMClient 统一封装，实现了「一份代码，多平台切换」，为后续 LangChain 集成打下了基础
• 提示工程三板斧：角色设定让回答更专业、Few-shot 让格式更稳定、Chain-of-Thought 让推理更准确

心态调整：从强类型语言切换到动态类型语言，最大的挑战不是语法，而是思维方式的转变 ------ Python 更强调「简洁表达」，Java 更强调「类型安全」。两者没有优劣，只有场景之分。在 AI 和数据领域，Python 的生态优势是压倒性的。

明日计划

Day 22 · 提示工程进阶 + LangChain 框架入门

• 提示工程进阶：ReAct 框架、Self-Consistency、Prompt Chaining
• LangChain 核心概念：Chains、Agents、Memory、Tools
• LangChain 实战：构建一个多轮对话的「Python 学习助手」
• 文档加载与分割：TextLoader、RecursiveCharacterTextSplitter