0.4 小结和复习

回顾：你已经掌握的核心能力

恭喜你完成 Module 0！通过本章的学习，你已经具备了构建 AI Agent 的第一层基础。让我们回顾一下你学到了什么：

🎯 小白鼓励：学编程就像学骑自行车

如果你现在感觉有点懵，觉得"我真的学会了吗？"——这是完全正常的！

学编程就像学骑自行车：

• 刚开始：东倒西歪、不断摔倒（代码报错）
• 坚持练习：慢慢找到平衡感（理解逻辑）
• 最后：不知不觉就会骑了（写代码变成本能）

关键是：不要只看，要动手敲代码！敲10遍比看100遍有用。

你已经迈出了最难的第一步。继续加油！💪

✅ 开发环境与工具链

• Python 3.11+ 安装与配置
• 虚拟环境管理（venv / Poetry）
• VS Code 专业配置
• 包管理（pip / poetry）

✅ Python 核心数据类型

• int: Agent 的计数器、token 统计
• float: 置信度分数、温度参数
• str: 用户输入、LLM 输出、提示词
• bool: 状态标志、权限检查
• 类型注解: 现代 Python 的标准

✅ 控制流与决策逻辑

• if/elif/else: Agent 的条件路由
• for 循环: 批量处理任务
• while 循环: 重试机制
• break/continue: 精确控制流程

---

核心概念速查表

🎯 小白理解：把这页打印出来！

下面的速查表是你以后写代码时的"小抄"。刚开始写代码时，忘记语法是很正常的——专业程序员也会天天 Google 查语法。

建议：

1. 收藏这一页，忘了就回来看
2. 多敲几遍，慢慢就记住了
3. 不用死记硬背，用多了自然会

数据类型对应表

Python 类型	在 AI Agent 中的用途	示例
int	token 计数、轮次、重试次数	max_tokens = 2000
float	温度参数、置信度、成本	temperature = 0.7
str	消息、提示词、响应	prompt = "Hello"
bool	状态标志、权限检查	is_active = True
list[str]	消息历史、工具列表	messages = ["Hi", "Hello"]
dict	配置、状态、API 响应	config = {"model": "gpt-4"}

控制流速查

# 条件判断
if condition:
    # 执行分支 A
elif another_condition:
    # 执行分支 B
else:
    # 执行分支 C

# for 循环
for item in collection:
    # 处理每个 item

# while 循环
while condition:
    # 持续执行直到 condition 为 False
    
# 列表推导式
result = [expression for item in collection if condition]

---

高难度编码挑战

现在是时候检验你的学习成果了！以下是两个非常高难度的编码挑战，它们模拟了真实的 AI Agent 开发场景。

⚠️ 重要提示：这些挑战故意设计得很难，目的是让你综合运用本章所学的所有知识。不要气馁，尝试独立完成，即使需要多次迭代也没关系。

🎯 小白攻略：如何啃下这些"硬骨头"？

看到这么长的代码别慌！这是每个程序员都经历过的阶段。

正确的学习姿势：

1. 先跑通示例代码

   • 把代码复制到你的编辑器
   • 直接运行看看会发生什么
   • 观察输出，理解它在干嘛

2. 改一点、试一点

   • 改一个参数，看结果变化
   • 注释掉一行代码，看报什么错
   • 通过"破坏"来理解代码

3. 分而治之

   • 不要试图一次理解全部
   • 一个函数一个函数地看
   • 画流程图帮助理解

4. 善用 print

   • 不确定某个变量是什么？print(变量)
   • 不确定代码执行到哪了？print("我到这了")

做不出来也没关系！ 先看提示，再看答案，然后自己重新实现一遍。这不是作弊，是学习！

---

🔥 挑战 1：智能 Token 管理器（难度：⭐⭐⭐⭐）

任务描述

实现一个 TokenManager 类，用于管理 AI Agent 的 token 使用情况。这个类需要：

1. 追踪多个模型的 token 使用（GPT-4、GPT-3.5、Claude 等）
2. 计算实时成本（不同模型价格不同）
3. 实现预算限制（超过预算时拒绝请求）
4. 支持 token 预留（为关键任务预留 token 配额）
5. 生成使用报告

技术要求

• 使用类型注解
• 使用字典存储多模型数据
• 使用if/elif/else进行预算检查
• 使用for 循环生成报告
• 编写文档字符串

定价参考

MODEL_PRICING = {
    "gpt-4": {
        "input": 0.03,   # $/1K tokens
        "output": 0.06,
    },
    "gpt-3.5-turbo": {
        "input": 0.0015,
        "output": 0.002,
    },
    "claude-3-opus": {
        "input": 0.015,
        "output": 0.075,
    }
}

预期功能

# 创建管理器，预算 $10
manager = TokenManager(budget=10.0)

# 记录 token 使用
success = manager.record_usage(
    model="gpt-4",
    input_tokens=500,
    output_tokens=300
)

# 检查是否可以继续使用
can_proceed = manager.can_use_tokens(
    model="gpt-4",
    estimated_tokens=1000
)

# 预留 token（为重要任务）
manager.reserve_tokens(
    model="gpt-4",
    tokens=2000,
    reason="Critical summary generation"
)

# 生成报告
report = manager.generate_report()
print(report)

参考输出

=== Token 使用报告 ===
总预算: $10.00
已使用: $2.55 (25.5%)
剩余预算: $7.45

模型使用详情:
- gpt-4:
  输入: 1500 tokens ($0.045)
  输出: 800 tokens ($0.048)
  总计: $0.093
  
- gpt-3.5-turbo:
  输入: 5000 tokens ($0.0075)
  输出: 3000 tokens ($0.006)
  总计: $0.0135

Token 预留:
- [gpt-4] 2000 tokens - Critical summary generation

预算状态: ✅ 健康

你的解决方案

from typing import Dict, Optional, Tuple

# 模型定价
MODEL_PRICING: Dict[str, Dict[str, float]] = {
    "gpt-4": {"input": 0.03, "output": 0.06},
    "gpt-3.5-turbo": {"input": 0.0015, "output": 0.002},
    "claude-3-opus": {"input": 0.015, "output": 0.075},
}


class TokenManager:
    """智能 Token 管理器"""
    
    def __init__(self, budget: float) -> None:
        """
        初始化 Token 管理器
        
        Args:
            budget: 总预算（美元）
        """
        # TODO: 实现初始化逻辑
        pass
    
    def record_usage(
        self,
        model: str,
        input_tokens: int,
        output_tokens: int
    ) -> bool:
        """
        记录 token 使用
        
        Args:
            model: 模型名称
            input_tokens: 输入 token 数
            output_tokens: 输出 token 数
        
        Returns:
            是否成功记录（如果超预算返回 False）
        """
        # TODO: 实现
        pass
    
    def can_use_tokens(self, model: str, estimated_tokens: int) -> bool:
        """
        检查是否可以使用指定数量的 tokens
        
        Args:
            model: 模型名称
            estimated_tokens: 预估 token 数
        
        Returns:
            是否可以使用
        """
        # TODO: 实现
        pass
    
    def reserve_tokens(self, model: str, tokens: int, reason: str) -> None:
        """
        为重要任务预留 tokens
        
        Args:
            model: 模型名称
            tokens: 预留数量
            reason: 预留原因
        """
        # TODO: 实现
        pass
    
    def generate_report(self) -> str:
        """
        生成详细的使用报告
        
        Returns:
            格式化的报告字符串
        """
        # TODO: 实现
        pass


# 测试代码
def main() -> None:
    manager = TokenManager(budget=10.0)
    
    # 测试用例
    manager.record_usage("gpt-4", 500, 300)
    manager.record_usage("gpt-3.5-turbo", 1000, 500)
    
    print(manager.can_use_tokens("gpt-4", 10000))
    manager.reserve_tokens("gpt-4", 2000, "Important task")
    
    print(manager.generate_report())


if __name__ == "__main__":
    main()

---

🔥🔥 挑战 2：对话状态机（难度：⭐⭐⭐⭐⭐）

任务描述

实现一个 ConversationStateMachine，模拟 LangGraph 的状态转移机制。这个状态机需要：

1. 支持多个状态：greeting, collecting_info, processing, responding, ending
2. 实现状态转移规则（基于用户输入）
3. 追踪状态历史
4. 支持状态回滚（撤销到上一个状态）
5. 可视化状态转移

状态转移图

START → greeting → collecting_info → processing → responding
                        ↓                            ↓
                     ending ←────────────────────── ending

技术要求

• 使用枚举类型（Enum）定义状态
• 使用字典定义转移规则
• 使用while 循环实现状态机主循环
• 使用列表追踪状态历史
• 实现复杂的条件逻辑

预期功能

# 创建状态机
sm = ConversationStateMachine()

# 开始对话
sm.start()  # 进入 greeting 状态

# 处理用户输入，自动转移状态
sm.process_input("你好")          # greeting → collecting_info
sm.process_input("我想查天气")    # collecting_info → processing
sm.process_input("谢谢")          # processing → responding
sm.process_input("再见")          # responding → ending

# 回滚到上一个状态
sm.rollback()  # ending → responding

# 查看状态历史
print(sm.get_state_history())

# 可视化当前状态
sm.visualize_state()

参考输出

[状态机启动] 当前状态: greeting
用户: 你好
[状态转移] greeting → collecting_info

用户: 我想查天气
[状态转移] collecting_info → processing
[处理中] 正在查询天气信息...

用户: 谢谢
[状态转移] processing → responding
[响应] 不客气！还有其他需要帮助的吗？

用户: 再见
[状态转移] responding → ending
[会话结束]

状态历史: START → greeting → collecting_info → processing → responding → ending

当前状态: ending
  ├─ 可转移到: []
  └─ 历史路径长度: 6

你的解决方案

from enum import Enum
from typing import List, Optional, Dict


class State(Enum):
    """会话状态枚举"""
    START = "start"
    GREETING = "greeting"
    COLLECTING_INFO = "collecting_info"
    PROCESSING = "processing"
    RESPONDING = "responding"
    ENDING = "ending"


class ConversationStateMachine:
    """对话状态机"""
    
    # 状态转移规则
    TRANSITIONS: Dict[State, List[State]] = {
        State.START: [State.GREETING],
        State.GREETING: [State.COLLECTING_INFO, State.ENDING],
        State.COLLECTING_INFO: [State.PROCESSING, State.ENDING],
        State.PROCESSING: [State.RESPONDING, State.ENDING],
        State.RESPONDING: [State.COLLECTING_INFO, State.ENDING],
        State.ENDING: [],
    }
    
    def __init__(self) -> None:
        """初始化状态机"""
        # TODO: 实现
        pass
    
    def start(self) -> None:
        """启动状态机"""
        # TODO: 实现
        pass
    
    def process_input(self, user_input: str) -> None:
        """
        处理用户输入并转移状态
        
        Args:
            user_input: 用户输入文本
        """
        # TODO: 实现状态转移逻辑
        pass
    
    def can_transition_to(self, target_state: State) -> bool:
        """
        检查是否可以转移到目标状态
        
        Args:
            target_state: 目标状态
        
        Returns:
            是否可以转移
        """
        # TODO: 实现
        pass
    
    def transition_to(self, target_state: State) -> bool:
        """
        转移到目标状态
        
        Args:
            target_state: 目标状态
        
        Returns:
            是否成功转移
        """
        # TODO: 实现
        pass
    
    def rollback(self) -> bool:
        """
        回滚到上一个状态
        
        Returns:
            是否成功回滚
        """
        # TODO: 实现
        pass
    
    def get_state_history(self) -> str:
        """获取状态历史的可视化表示"""
        # TODO: 实现
        pass
    
    def visualize_state(self) -> None:
        """可视化当前状态"""
        # TODO: 实现
        pass


# 测试代码
def main() -> None:
    sm = ConversationStateMachine()
    sm.start()
    
    test_inputs = ["你好", "我想查天气", "谢谢", "再见"]
    for user_input in test_inputs:
        print(f"\n用户: {user_input}")
        sm.process_input(user_input)
    
    print("\n" + "="*50)
    print(sm.get_state_history())
    sm.visualize_state()


if __name__ == "__main__":
    main()

---

挑战答案提示

挑战 1 提示

点击查看提示

核心数据结构：

self.budget: float = budget
self.total_spent: float = 0.0
self.usage_by_model: Dict[str, Dict[str, int]] = {}
self.reservations: List[Dict[str, any]] = []

成本计算：

input_cost = (input_tokens / 1000) * MODEL_PRICING[model]["input"]
output_cost = (output_tokens / 1000) * MODEL_PRICING[model]["output"]

挑战 2 提示

点击查看提示

核心数据结构：

self.current_state: State = State.START
self.state_history: List[State] = [State.START]

意图识别逻辑：

def _classify_intent(text: str) -> State:
    if "你好" in text:
        return State.GREETING
    elif "再见" in text:
        return State.ENDING
    # ...

---

自我评估清单

在进入下一个 Module 之前，确保你能够：

• [ ] 独立搭建 Python 开发环境
• [ ] 创建和使用虚拟环境
• [ ] 编写带类型注解的函数
• [ ] 使用 f-string 格式化字符串
• [ ] 实现多分支条件判断
• [ ] 使用 for 循环处理列表和字典
• [ ] 使用 while 循环实现重试逻辑
• [ ] 完成至少一个高难度挑战（60%+正确）

---

学习资源

推荐阅读

• Python 官方教程
• Real Python - Control Flow
• PEP 484 - Type Hints

视频课程

• Python for Everybody (Coursera)
• CS50's Introduction to Programming with Python

练习平台

• LeetCode Python Track
• HackerRank Python

---

下一步

恭喜你完成 Module 0！你已经掌握了 Python 的核心基础。

在 Module 1: 函数与模块化 中，你将学习：

• 如何编写可复用的函数
• 装饰器——LangChain 的核心模式
• 模块化设计——构建大型 Agent 系统的关键
• 实战：创建你的第一个 LangChain Tool

继续前进，你离构建真正的 AI Agent 越来越近了！

---

下一章：Module 1: 函数与模块化