Prompt Engineering 技术体系全解析：从 Zero-shot 到 ToT 的完整指南（含大量示例）
- Prompt Engineering 技术体系全解析：从 Zero-shot 到 ToT 的完整指南
Prompt Engineering 技术体系全解析：从 Zero-shot 到 ToT 的完整指南
随着大语言模型（LLM）的快速发展，Prompt Engineering（提示工程）已经从简单的"问问题"演变成一套完整的技术体系。本文将通过大量实际可用的 Prompt 示例，帮助你真正理解和掌握这些技术。
一、Prompt 格式标准
1.1 XML 标签格式（Claude 推荐）
<context>
你是一位资深的Python开发工程师，擅长代码审查和优化。
</context>
<task>
请审查以下代码并提出改进建议。
</task>
<code>
def calc(x,y):
return x+y
</code>
<requirements>
1. 检查代码规范性
2. 提出性能优化建议
3. 使用中文回复
</requirements>
1.2 Markdown 格式（GPT 推荐）
## 角色
你是一位资深的Python开发工程师
## 任务
请审查以下代码并提出改进建议
## 代码
\`\`\`python
def calc(x,y):
return x+y
\`\`\`
## 要求
- 检查代码规范性
- 提出性能优化建议
二、Shot 系列：示例驱动的基础技术
2.1 Zero-shot（零样本）
不给任何示例，直接让模型执行任务。
Prompt:
将以下中文翻译成英文：今天天气很好
Output:
The weather is nice today.
Prompt:
判断以下评论的情感是正面、负面还是中性：
"这个产品质量不错，但价格有点贵"
Output:
中性（产品有优点但也有不满）
2.2 One-shot（单样本）
提供1个示例来帮助模型理解任务格式。
Prompt:
将产品评论转换为结构化数据。
示例：
输入："手机很好用，电池耐用，就是有点重"
输出：{"优点": ["好用", "电池耐用"], "缺点": ["有点重"], "评分": 4}
现在处理：
输入："屏幕清晰，拍照效果一般，价格实惠"
输出：
Output:
{"优点": ["屏幕清晰", "价格实惠"], "缺点": ["拍照效果一般"], "评分": 3.5}
2.3 Few-shot（少样本）
提供2-5个示例，让模型学习模式。
Prompt:
请根据示例，为新的编程概念生成通俗解释：
概念：变量
解释：变量就像一个贴了标签的盒子，你可以把东西（数据）放进去，之后用标签名字找到它。
概念：函数
解释：函数就像一台咖啡机，你放入咖啡豆和水（输入参数），它给你一杯咖啡（返回值）。
概念：循环
解释：循环就像跑步机，让你一直重复同样的动作，直到达到设定的条件才停下来。
概念：递归
解释：
Output:
递归就像俄罗斯套娃，打开一个娃娃里面还有个小一号的娃娃，
一直打开到最小的那个（基准条件）才停下来，然后再一层层合上。
三、推理增强技术（重点！大量示例）
3.1 Chain of Thought (CoT) - 链式思维
核心思想：让模型"思考出声"，展示推理过程，而不是直接给答案。
💡 示例1：数学应用题
❌ 普通问法（经常出错）：
Q: 我去市场买了10个苹果。给了邻居2个，给了修理工2个。
然后又买了5个苹果，吃了1个。我还剩多少个苹果？
A: 9个 ← 这是错的！
✅ CoT 问法（准确率大幅提升）：
Q: 我去市场买了10个苹果。给了邻居2个，给了修理工2个。
然后又买了5个苹果，吃了1个。我还剩多少个苹果？
请一步一步思考。
A: 让我一步步计算：
第1步：开始买了 10 个苹果
第2步：给邻居 2 个：10 - 2 = 8 个
第3步：给修理工 2 个：8 - 2 = 6 个
第4步：又买了 5 个：6 + 5 = 11 个
第5步：吃了 1 个：11 - 1 = 10 个
答案：我还剩 10 个苹果。 ✓
💡 示例2：逻辑推理
❌ 普通问法：
Q: 这组数字中的奇数加起来是偶数吗？4, 8, 9, 15, 12, 2, 1
A: 是的 ← 错误！
✅ CoT 问法：
Q: 这组数字中的奇数加起来是偶数吗？4, 8, 9, 15, 12, 2, 1
请按以下步骤分析：
1. 首先找出所有奇数
2. 计算这些奇数的和
3. 判断结果是奇数还是偶数
A: 让我按步骤分析：
第1步 - 找出奇数：
4(偶), 8(偶), 9(奇), 15(奇), 12(偶), 2(偶), 1(奇)
奇数有：9, 15, 1
第2步 - 计算和：
9 + 15 + 1 = 25
第3步 - 判断结果：
25 ÷ 2 = 12余1，所以25是奇数
答案：不是偶数，这些奇数的和是25，是奇数。 ✓
💡 示例3：Few-shot CoT（最强用法！）
给模型展示"推理长什么样"：
Prompt:
Q: 小明有5本书，借给小红2本后，又从图书馆借了3本。小明现在有几本书？
A: 我来一步步算。
开始：5本
借出后：5 - 2 = 3本
借入后：3 + 3 = 6本
答案是6本。
Q: 停车场有7辆车，开走了4辆，又开来了2辆。停车场现在有几辆车？
A: 我来一步步算。
开始：7辆
开走后：7 - 4 = 3辆
开来后：3 + 2 = 5辆
答案是5辆。
Q: 小华有12支铅笔，送给同学5支，妈妈又给他买了8支。小华现在有几支铅笔？
A:
Output:
我来一步步算。
开始：12支
送出后：12 - 5 = 7支
买入后：7 + 8 = 15支
答案是15支。
💡 示例4：代码调试场景
Prompt:
请帮我找出这段代码的bug，一步步分析：
def find_max(numbers):
max_num = 0
for num in numbers:
if num > max_num:
max_num = num
return max_num
print(find_max([-1, -5, -3])) # 期望输出 -1
请按以下步骤分析：
1. 理解代码意图
2. 追踪代码执行过程
3. 找出问题所在
4. 提供修复方案
Output:
让我一步步分析：
**第1步 - 理解代码意图：**
这个函数想要找出列表中的最大值。
**第2步 - 追踪执行过程：**
- 输入：[-1, -5, -3]
- max_num 初始化为 0
- 循环检查：
- -1 > 0? 否，max_num 保持 0
- -5 > 0? 否，max_num 保持 0
- -3 > 0? 否，max_num 保持 0
- 返回 0
**第3步 - 问题所在：**
max_num 初始化为 0，当所有数字都是负数时，没有任何数字能大于0，
所以会错误地返回0。
**第4步 - 修复方案：**
def find_max(numbers):
if not numbers:
return None
max_num = numbers[0] # 用第一个元素初始化
for num in numbers[1:]:
if num > max_num:
max_num = num
return max_num
💡 示例5：复杂业务决策
Prompt:
我在考虑是否应该接受一个新的工作offer，请帮我分析：
当前工作：
- 月薪 2万
- 通勤 30分钟
- 工作内容熟悉
- 团队关系好
新offer：
- 月薪 2.6万
- 通勤 1.5小时
- 需要学习新技术
- 是知名大厂
请从多个维度一步步分析这个决策。
Output:
让我从多个维度逐一分析：
**1. 财务维度分析：**
- 薪资涨幅：(2.6-2)/2 = 30%，这是显著的提升
- 年收入增加：0.6万 × 12 = 7.2万/年
- 结论：财务上有明显收益 ✓
**2. 时间成本分析：**
- 通勤增加：(1.5-0.5) × 2 = 2小时/天（往返）
- 每月额外通勤：2 × 22 = 44小时
- 如果按时薪计算：6000/44 ≈ 136元/小时
- 结论：时间成本需要认真考虑 ⚠️
**3. 职业发展分析：**
- 大厂背书：对简历有加成
- 新技术栈：扩展能力边界
- 但有学习曲线压力
- 结论：长期有利，短期有压力 ✓⚠️
**4. 生活质量分析：**
- 通勤增加影响生活时间
- 离开熟悉的团队有适应期
- 但薪资提升可改善生活质量
- 结论：需要权衡取舍
**综合建议：**
如果你是职业上升期（30岁以下），建议接受。大厂经验+薪资提升的
长期收益大于短期的通勤成本。如果已经35+或家庭责任重，建议慎重。
3.2 Zero-shot CoT
最简单的 CoT 触发方式！只需在问题后面加一句魔法咒语：
魔法触发词（选一个加在问题后面）
✨ "Let's think step by step"
✨ "请一步步思考"
✨ "让我们逐步分析"
✨ "请详细说明你的推理过程"
✨ "Think carefully and show your reasoning"
💡 完整示例1
Q: 一家书店上午卖出45本书，下午卖出的比上午多18本。这一天共卖出多少本书？
Let's think step by step.
A: 让我一步步思考：
1. 上午卖出：45本
2. 下午比上午多18本，所以下午卖出：45 + 18 = 63本
3. 一天总共卖出：45 + 63 = 108本
答案：这一天共卖出108本书。
💡 完整示例2：经典河渡谜题
Q: 一个农民要带着一只狼、一只羊和一棵白菜过河。
船很小，每次只能带一样东西。
如果农民不在，狼会吃羊，羊会吃白菜。
农民如何安全地把它们都带过河？
Let's think step by step.
A: 让我一步步思考这个经典谜题：
**分析约束条件：**
- 狼+羊单独 = 羊被吃
- 羊+白菜单独 = 白菜被吃
- 狼+白菜单独 = 安全（狼不吃白菜）
**解决步骤：**
第1步：农民带羊过河 →
左岸：狼、白菜 | 右岸：农民、羊
（狼和白菜可以单独在一起）
第2步：农民独自返回 →
左岸：狼、白菜、农民 | 右岸：羊
第3步：农民带狼过河 →
左岸：白菜 | 右岸：农民、狼、羊
⚠️ 但狼和羊在一起！
第4步：农民带羊返回 →
左岸：白菜、农民、羊 | 右岸：狼
（关键步骤：把羊带回来！）
第5步：农民带白菜过河 →
左岸：羊 | 右岸：农民、狼、白菜
第6步：农民独自返回 →
左岸：农民、羊 | 右岸：狼、白菜
第7步：农民带羊过河 →
左岸：空 | 右岸：农民、狼、羊、白菜 ✓
答案：共需要7次渡河，关键是第4步要把羊带回来。
3.3 Self-Consistency（自洽性）
核心思想：同一个问题问多次，让答案"投票"选出最靠谱的！
💡 图解原理
┌─→ 推理路径1 → 答案: 76岁 ✓
│
同一个问题 ────────┼─→ 推理路径2 → 答案: 76岁 ✓
(temperature=0.7) │
├─→ 推理路径3 → 答案: 140岁 ✗ (推理出错)
│
├─→ 推理路径4 → 答案: 76岁 ✓
│
└─→ 推理路径5 → 答案: 76岁 ✓
投票统计：76岁=4票，140岁=1票
最终答案：76岁 ✓（多数获胜）
💡 完整示例
问题： 小明6岁时，他姐姐的年龄是他的2倍。现在小明70岁了，他姐姐多少岁？
第1次调用（temperature=0.7）：
让我想想...
小明6岁时，姐姐是6×2=12岁
姐姐比小明大：12-6=6岁
现在小明70岁，姐姐：70+6=76岁
答案：76岁
第2次调用：
计算一下。
当年姐姐是小明的2倍，即12岁。
年龄差永远是6岁。
现在姐姐是70+6=76岁。
答案：76岁
第3次调用：
小明6岁→姐姐12岁
差值=6
现在=70+6=76
答案：76岁
第4次调用（出错了！）：
姐姐是小明的2倍。
现在小明70岁，姐姐70×2=140岁
答案：140岁 ← 推理错误！
第5次调用：
6岁时差6岁（12-6）
这个差距不会变
所以现在姐姐70+6=76岁
答案：76岁
投票结果： | 答案 | 票数 | |——|——| | 76岁 | 4票 ✓ | | 140岁 | 1票 |
最终输出：76岁
💡 Python 实现代码
import openai
from collections import Counter
def self_consistency(question, num_samples=5):
"""使用自洽性方法获得更准确的答案"""
answers = []
for i in range(num_samples):
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[{
"role": "user",
"content": f"{question}\n\nLet's think step by step."
}],
temperature=0.7 # 需要一定随机性来获得多样的推理路径
)
# 提取最终答案（需要根据实际情况解析）
full_response = response.choices[0].message.content
answer = extract_final_answer(full_response) # 自定义函数
answers.append(answer)
print(f"第{i+1}次推理结果: {answer}")
# 多数投票
vote = Counter(answers)
final_answer, count = vote.most_common(1)[0]
print(f"\n投票结果: {dict(vote)}")
print(f"最终答案: {final_answer} (获得{count}票)")
return final_answer
# 使用示例
result = self_consistency(
"小明6岁时姐姐是他年龄的2倍，现在小明70岁，姐姐多少岁？",
num_samples=5
)
四、Tree of Thoughts (ToT) - 思维树
核心思想：不只走一条路，而是同时探索多条路，选最好的那条！
4.1 CoT vs ToT 对比
CoT（链式思维）：
问题 → 步骤1 → 步骤2 → 步骤3 → 答案
（只有一条路，走错了就全错）
ToT（思维树）：
问题 → ┌─ 思路A → 评估：不太对 → 放弃
├─ 思路B → 评估：看起来对 → 继续 → 答案 ✓
└─ 思路C → 评估：完全错误 → 放弃
（多条路同时探索，可以回溯）
4.2 💡 完整示例：24点游戏
问题：用 4, 5, 6, 10 四个数字，通过加减乘除得到24
ToT 解题过程：
Prompt:
你需要用 4, 5, 6, 10 这四个数字，每个只能用一次，
通过加减乘除运算得到24。
请像三位专家一样思考：
- 每位专家提出一个初步思路
- 评估每个思路的可行性
- 选择最有希望的思路继续
- 如果走不通就回溯尝试其他思路
Output:
**专家A的思路：**
初步想法：先找能凑成简单数的组合
- 观察：6 × 4 = 24，那只需要让 5 和 10 "消失"
- 尝试：5 - 10 = -5...这没法用
- 尝试：10 / 5 = 2，但 6 × 4 × 2 = 48，不对
- 评估：❌ 这个方向不太对，放弃
**专家B的思路：**
初步想法：24 = 20 + 4，能凑20吗？
- 观察：10 × 2 = 20，那需要凑出2
- 尝试：6 - 4 = 2，那 10 × 2 = 20，但5还没用
- 这个方向也不太对
- 评估：❌ 放弃
**专家C的思路：**
初步想法：24可以分解为哪些乘法？
- 24 = 8 × 3
- 24 = 6 × 4 ✓（6和4都在！）
- 24 = 12 × 2
- 如果用 6 × 4 = 24，那5和10需要组合成"乘1"或"加0"
- 10 / 5 = 2...不行
- 5 - 5 = 0...没有两个5
- 10 - 10 = 0...没有两个10
- 等等！换个角度：(10 - 6) = 4 或者 (10 - 4) = 6
- 如果 (10 - 6) × ...
- 评估：⚠️ 有希望，继续深入
**深入专家C的思路：**
- (10 - 6) = 4
- 4 × ? = 24，需要 ? = 6
- 现在有数字 4, 5 可用，能凑6吗？
- 4 + 5 = 9...不行
- 5 - 4 = 1...不行
- 换个方向：4 × (10 - 6) = 16，还差8
- 16 + 8 = 24，5能变成8吗？不能
- 再换：让我试试 (6 - 4) × (10 + 5) = 2 × 15 = 30...不对
- 试试：4 × (6 - (10 / 5)) = 4 × (6 - 2) = 4 × 4 = 16...不对
- 试试：4 × 6 × (10 / 5) = 24 × 2 = 48...不对
- 试试：4 × (6 + 10 / 5) = 4 × (6 + 2) = 4 × 8 = 32...不对
- 试试：4 × (6 - 10 / 5) = 4 × (6 - 2) = 4 × 4 = 16...不对
- 试试：(4 + 6) × 10 / 5 = 10 × 2 = 20...不对
- 试试：(6 + 10 / 5) × 4 = 8 × 4 = 32...不对
- 试试：6 / (1 - 5/10) 看看能不能凑...
- 试试：(10 - 4) × (6 - 5) = 6 × 1 = 6...不对
- 试试：10 × 6 / (4 - 5) = 60 / (-1) = -60...不对
- 试试：(10 - 6) × 5 + 4 = 4 × 5 + 4 = 24 ✓✓✓
**答案：(10 - 6) × 5 + 4 = 24**
验证：
- 10 - 6 = 4
- 4 × 5 = 20
- 20 + 4 = 24 ✓
4.3 💡 简化版 ToT Prompt（可直接使用）
Prompt:
想象有三位不同领域的专家正在解决这个问题。
每位专家会：
1. 写下他们思考的第一步
2. 与其他专家分享
3. 评估所有思路，指出哪些有希望、哪些应该放弃
4. 继续最有希望的思路
5. 如果某位专家意识到自己的思路有问题，就退出
重复这个过程直到得出答案。
问题：[你的问题]
4.4 💡 ToT 解决复杂规划问题
Prompt:
问题：规划一次从北京到拉萨的自驾游，时间10天，预算2万。
请用思维树方法分析：
**第一轮探索 - 路线选择：**
思路A（川藏线）：
- 优点：风景最美，318国道
- 缺点：路况复杂，耗时长
- 评估：风险中等，体验最佳
- 决定：✓ 保留
思路B（青藏线）：
- 优点：路况好，海拔适应快
- 缺点：风景相对单一
- 评估：适合赶时间
- 决定：✓ 保留作为返程
思路C（新藏线）：
- 优点：最原始
- 缺点：路况极差，10天不够
- 评估：时间不允许
- 决定：❌ 放弃
**第二轮深入 - 去程规划（川藏线）：**
Day1-2：北京→西安（高速，约1200km）
Day3：西安→成都（高速，约700km）
Day4：成都→康定（开始318）
Day5：康定→理塘
Day6：理塘→芒康
Day7：芒康→波密
Day8：波密→拉萨
**评估这个方案：**
- 时间：8天到拉萨 ✓
- 剩余2天可在拉萨游玩
- 但返程怎么办？时间不够！
**回溯调整：**
重新规划：单程飞回，车托运
- 托运费用约3000
- 预算：油费5000 + 住宿4000 + 餐饮2000 + 门票2000 + 托运3000 = 16000
- 预算可行 ✓
**最终方案：**
去程走川藏线自驾，返程飞机+车辆托运。
五、ReAct - 推理与行动的协同
核心思想：让AI不只是"想"，还能"做"——查资料、调API、执行代码！
5.1 ReAct 循环
用户问题
↓
┌─────────────────────────────────────┐
│ Thought: 我需要先查一下... │
│ ↓ │
│ Action: 搜索/调用API/执行代码 │
│ ↓ │
│ Observation: 得到结果... │
│ ↓ │
│ Thought: 根据结果，我还需要... │
│ ↓ │
│ (循环继续，直到得出答案) │
└─────────────────────────────────────┘
↓
最终答案
5.2 💡 完整示例1：查询实时信息
用户问题：苹果公司现在的股价是多少？市值超过微软了吗？
---
Thought 1: 我需要查询苹果公司的当前股价。
Action 1: search("AAPL stock price today")
Observation 1: Apple Inc. (AAPL) 当前股价 $178.52，
涨幅 +1.2%，市值 2.79万亿美元。
---
Thought 2: 好的，我知道苹果的市值了。现在需要查微软的市值来比较。
Action 2: search("Microsoft MSFT market cap today")
Observation 2: Microsoft Corp. (MSFT) 当前股价 $378.91，
市值 2.81万亿美元。
---
Thought 3: 现在我有了两个公司的数据：
- 苹果市值：2.79万亿美元
- 微软市值：2.81万亿美元
微软略高于苹果。
Action 3: finish("苹果当前股价是$178.52。
苹果市值2.79万亿美元，
微软市值2.81万亿美元，
所以苹果市值目前没有超过微软。")
---
最终答案：苹果当前股价是$178.52。苹果市值约2.79万亿美元，
微软市值约2.81万亿美元，所以苹果市值目前没有超过微软。
5.3 💡 完整示例2：多跳推理问答
用户问题：《哈利波特》作者的出生地现在属于哪个国家？
---
Thought 1: 我需要先找出《哈利波特》的作者是谁。
Action 1: search("Harry Potter author")
Observation 1: 《哈利波特》系列的作者是 J.K. Rowling（J.K.罗琳）
---
Thought 2: 好，作者是J.K.罗琳。现在我需要找她的出生地。
Action 2: search("J.K. Rowling birthplace")
Observation 2: J.K. Rowling 出生于英国英格兰格洛斯特郡的 Yate（耶特）。
---
Thought 3: 她出生在英格兰的Yate。英格兰是英国的一部分，
这个地方现在仍然属于英国。我可以给出答案了。
Action 3: finish("《哈利波特》的作者J.K.罗琳出生于英格兰的Yate，
该地现在属于英国（大不列颠及北爱尔兰联合王国）。")
---
最终答案：《哈利波特》的作者J.K.罗琳出生于英格兰的Yate，
该地现在属于英国。
5.4 💡 完整示例3：代码执行任务
用户问题：帮我计算一下，如果我每月存5000元，年利率4%，复利计算，10年后能有多少钱？
---
Thought 1: 这是一个复利计算问题，我需要写代码来精确计算。
公式是定期定额复利：FV = PMT × ((1+r)^n - 1) / r
但每月存款需要考虑月利率。
Action 1: execute_python("""
# 每月定额存款复利计算
monthly_deposit = 5000 # 每月存款
annual_rate = 0.04 # 年利率
years = 10 # 投资年限
monthly_rate = annual_rate / 12 # 月利率
months = years * 12 # 总月数
# 定期定额复利公式
# FV = PMT × ((1 + r)^n - 1) / r
fv = monthly_deposit * ((1 + monthly_rate) ** months - 1) / monthly_rate
print(f"10年后总金额: ¥{fv:,.2f}")
print(f"本金总投入: ¥{monthly_deposit * months:,}")
print(f"利息收益: ¥{fv - monthly_deposit * months:,.2f}")
""")
Observation 1:
10年后总金额: ¥736,579.66
本金总投入: ¥600,000
利息收益: ¥136,579.66
---
Thought 2: 计算完成，我现在可以给出完整的答案。
Action 2: finish("如果每月存5000元，年利率4%复利计算：
- 10年后总金额：约73.66万元
- 本金投入：60万元（5000×12×10）
- 利息收益：约13.66万元")
---
最终答案：如果每月存5000元，年利率4%复利计算，10年后能有约73.66万元。
其中本金60万，利息收益约13.66万。
5.5 ReAct vs 纯 CoT 对比
| 场景 | CoT 表现 | ReAct 表现 |
|---|---|---|
| 数学推理 | ✅ 很好 | ✅ 很好 |
| 实时信息查询 | ❌ 会编造 | ✅ 可查询 |
| 复杂计算 | ⚠️ 可能出错 | ✅ 可执行代码 |
| 多跳推理 | ⚠️ 容易断链 | ✅ 可验证每步 |
| 需要API | ❌ 无法访问 | ✅ 可调用 |
六、RAG - 检索增强生成
核心思想：让AI先"查资料"，再回答问题，大幅减少胡说八道！
6.1 RAG 工作流程
用户问题："公司的年假政策是什么？"
↓
┌───────────────────┐
│ 1. 问题向量化 │
│ (转为数字表示) │
└───────────────────┘
↓
┌───────────────────┐
│ 2. 向量数据库检索 │
│ (找相似文档) │
│ │
│ 📄 员工手册.pdf │
│ 📄 休假制度.doc │
│ 📄 HR问答.txt │
└───────────────────┘
↓
┌───────────────────┐
│ 3. 构建增强Prompt │
│ │
│ Context: [检索到 │
│ 的相关文档内容] │
│ │
│ Question: 公司的 │
│ 年假政策是什么？ │
└───────────────────┘
↓
┌───────────────────┐
│ 4. LLM生成回答 │
│ (基于检索到的内容) │
└───────────────────┘
↓
"根据公司员工手册，年假政策如下：
工作满1年可享5天年假..."
6.2 💡 RAG Prompt 模板
你是一个专业的问答助手。请根据提供的上下文信息回答用户的问题。
<context>
{检索到的相关文档内容}
</context>
<rules>
1. 只根据上下文中的信息回答问题
2. 如果上下文中没有相关信息，请明确说"根据现有资料无法回答"
3. 不要编造或猜测信息
4. 如果可能，请引用具体的来源
</rules>
<question>
{用户的问题}
</question>
请回答上述问题：
6.3 💡 完整示例
假设检索到的文档内容：
[文档1: 员工手册-休假制度.pdf]
第五章 休假制度
5.1 年休假
- 工作满1年不满10年的，年休假5天
- 工作满10年不满20年的，年休假10天
- 工作满20年的，年休假15天
5.2 年假使用规则
- 年假应在当年使用完毕
- 经批准可延期至次年3月底
- 未使用的年假不予补偿
构建的完整 Prompt：
你是一个专业的HR助手。请根据提供的公司制度文档回答员工的问题。
<context>
[文档1: 员工手册-休假制度.pdf]
第五章 休假制度
5.1 年休假
- 工作满1年不满10年的，年休假5天
- 工作满10年不满20年的，年休假10天
- 工作满20年的，年休假15天
5.2 年假使用规则
- 年假应在当年使用完毕
- 经批准可延期至次年3月底
- 未使用的年假不予补偿
</context>
<question>
我在公司工作了8年，今年还有2天年假没用完，能结转到明年吗？
</question>
请回答：
LLM 输出：
根据公司员工手册的规定，我来回答您的问题：
1. **年假天数**：您工作满8年（属于"满1年不满10年"），
每年享有5天年假。
2. **关于结转**：根据规定，年假原则上应在当年使用完毕。
但是，经批准后可以延期至次年3月底前使用。
3. **建议**：
- 您剩余的2天年假，建议尽快向主管申请延期使用
- 如获批准，需在明年3月底前使用完毕
- 请注意：如果过期未使用，不予补偿
建议您尽早与HR或直属领导沟通，申请年假延期。
七、技术选择决策树
你的任务是什么？
│
├─ 简单问答（翻译、分类）
│ └─ → Zero-shot（不需要示例）
│ └─ 效果不好 → Few-shot（加几个示例）
│
├─ 数学/逻辑推理
│ └─ → 先试 Zero-shot CoT（加"请一步步思考"）
│ └─ 需要更准 → Self-Consistency（多次推理投票）
│ └─ 特别复杂 → Few-shot CoT（给带推理的示例）
│
├─ 需要探索多种方案的决策问题
│ └─ → Tree of Thoughts（思维树）
│
├─ 需要实时信息/调用工具
│ └─ → ReAct（推理+行动循环）
│
├─ 需要基于特定文档/知识库回答
│ └─ → RAG（检索增强生成）
│
└─ 复杂的多步骤任务
└─ → Prompt Chaining（任务分解+链接）
八、速查表：各技术的触发 Prompt
| 技术 | 触发方式 |
|---|---|
| Zero-shot CoT | 在问题后加 Let's think step by step |
| Few-shot CoT | 提供2-3个带推理过程的示例 |
| Self-Consistency | 调用5次（temperature=0.7），取多数答案 |
| ToT | 想象三位专家在讨论这个问题... |
| ReAct | 使用 Thought/Action/Observation 格式 |
| RAG | 基于以下上下文回答：<context>...</context> |
九、完整实战：组合使用多种技术
任务：帮用户规划一次日本旅行
# 第一步：用 RAG 获取最新信息
检索：日本签证政策2024、日本旅游攻略、日元汇率
# 第二步：用 CoT 分析用户需求
用户说想去日本玩7天，预算2万，喜欢动漫和美食。
让我一步步分析：
1. 时间：7天适合关东或关西单线
2. 预算：2万中等水平，可以舒适游
3. 兴趣：动漫→秋叶原/池袋，美食→大阪/京都
4. 建议路线：东京进大阪出，或反过来
# 第三步：用 ToT 探索多个方案
方案A（纯东京）：7天深度游东京
方案B（东京+大阪）：各3天+1天交通
方案C（大阪+京都+奈良）：关西深度游
评估后选择方案B最符合需求
# 第四步：用 Self-Consistency 验证预算
多次计算确保预算估算准确
机票+住宿+交通+餐饮+门票 = 约18000，在预算内
# 最终输出
整合所有分析，输出完整的旅行规划
参考资料
- Wei et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models
- Yao et al. (2023). Tree of Thoughts: Deliberate Problem Solving with Large Language Models
- Yao et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models
- Lewis et al. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
- Wang et al. (2023). Self-Consistency Improves Chain of Thought Reasoning
- Kojima et al. (2022). Large Language Models are Zero-Shot Reasoners
希望这篇文章能帮你真正理解这些 Prompt 技术！记住：没有最好的技术，只有最适合你任务的技术。多尝试，多组合，找到最适合你的方案。