【AI原生开发实战】2.1 Prompt工程基础：编写高质量提示词

前言

在AI原生开发时代，Prompt（提示词）已成为我们与大型语言模型（LLM）交互的核心接口。如果说传统的编程是编写代码指令，那么AI原生开发就是编写自然语言指令。掌握Prompt工程，就相当于掌握了AI时代的新编程范式。

本节将系统性地介绍Prompt工程的核心原理与实践方法，帮助你从零开始构建高质量Prompt的设计能力。

一、学习目标

完成本节学习后，你将能够：

理解 Prompt工程的基本概念与重要性
掌握 Prompt设计的五大核心原则（清晰性、具体性、上下文、角色扮演、结构化）
应用三种高级Prompt技巧（Few-shot Learning、Chain of Thought、Tree of Thought）
设计可复用的Prompt模板系统
实践构建一个完整的Prompt模板管理库

前置知识要求：

了解大语言模型（LLM）的基本概念
熟悉Python编程基础
有过ChatGPT等AI工具的使用经验

二、Prompt设计核心原则

2.1 什么是Prompt工程？

Prompt工程（Prompt Engineering）是指通过设计和优化输入给AI模型的文本提示，以获得更准确、更符合预期的输出结果的技术。

从数学角度看，我们可以将Prompt工程建模为优化问题：

Prompt ∗ = arg ⁡ max ⁡ Prompt P ( Output desired ∣ Prompt ) \text{Prompt}^* = \arg\max_{\text{Prompt}} P(\text{Output}_{\text{desired}} \mid \text{Prompt}) Prompt∗=argPromptmaxP(Outputdesired∣Prompt)

其中， P ( Output desired ∣ Prompt ) P(\text{Output}_{\text{desired}} \mid \text{Prompt}) P(Outputdesired∣Prompt) 表示在给定Prompt条件下，生成期望输出的概率。我们的目标是找到最优Prompt，使得这个概率最大化。

2.2 为什么Prompt质量至关重要？

研究表明，Prompt的质量直接影响AI输出的质量。根据OpenAI的实验数据：

优秀的Prompt：可以将模型性能提升 40-60%
糟糕的Prompt：可能导致模型产生幻觉或错误输出
结构化Prompt：比非结构化Prompt的成功率高 3倍以上

示例对比：

python 复制代码

# ❌ 糟糕的Prompt示例
bad_prompt = "帮我写个函数"

# ✅ 优秀的Prompt示例
good_prompt = """
请用Python编写一个计算斐波那契数列的函数，要求：
1. 函数名：fibonacci
2. 输入参数：n（整数，表示数列长度）
3. 输出：包含前n个斐波那契数的列表
4. 时间复杂度要求：O(n)
5. 需要添加类型注解和docstring
"""

2.3 五大核心原则详解

原则一：清晰性（Clarity）

定义：Prompt应该表达清晰，避免歧义和模糊表述。

清晰性评分公式：

Clarity Score = 明确的信息单元数总信息单元数 × 100 % \text{Clarity Score} = \frac{\text{明确的信息单元数}}{\text{总信息单元数}} \times 100\% Clarity Score=总信息单元数明确的信息单元数×100%

示例：

python 复制代码

# ❌ 缺乏清晰性
prompt_v1 = "分析一下这个数据"

# ✅ 清晰明确
prompt_v2 = """
请对以下销售数据进行多维度分析：
1. 计算总销售额、平均销售额、销售额增长率
2. 按产品类别分组，找出销售额TOP 3的产品
3. 识别销售趋势（上升/下降/平稳）
4. 给出数据可视化的建议

数据：
[
    {"date": "2024-01", "product": "A", "sales": 1000},
    {"date": "2024-01", "product": "B", "sales": 1500},
    {"date": "2024-02", "product": "A", "sales": 1200},
    {"date": "2024-02", "product": "B", "sales": 1800}
]
"""

原则二：具体性（Specificity）

定义：Prompt应该包含具体的约束条件、输出格式和期望目标。

具体性维度矩阵：

维度	低具体性	高具体性
输出格式	"写点内容"	"输出JSON格式，包含title和content字段"
长度要求	"简短一些"	"控制在200-300字之间"
风格要求	"专业一点"	"使用学术论文风格，引用权威数据源"
质量标准	"写好点"	"错误率低于5%，通过单元测试"

代码示例：

python 复制代码

def create_specific_prompt(task, constraints):
    """
    生成具体化Prompt的模板函数
    
    参数：
        task: 任务描述
        constraints: 约束条件字典
    
    返回：
        格式化的Prompt字符串
    """
    prompt_parts = [f"任务：{task}"]
    
    if 'output_format' in constraints:
        prompt_parts.append(f"输出格式：{constraints['output_format']}")
    
    if 'length' in constraints:
        prompt_parts.append(f"长度要求：{constraints['length']}")
    
    if 'style' in constraints:
        prompt_parts.append(f"风格要求：{constraints['style']}")
    
    if 'examples' in constraints:
        prompt_parts.append(f"参考示例：{constraints['examples']}")
    
    return "\n".join(prompt_parts)


# 使用示例
task = "编写一个Python数据验证函数"
constraints = {
    'output_format': '带类型注解的Python函数',
    'length': '代码不超过30行',
    'style': '遵循PEP 8规范',
    'examples': '参考pandas的validate_dataframe函数'
}

prompt = create_specific_prompt(task, constraints)
print(prompt)

原则三：上下文（Context）

定义：提供充分的背景信息、领域知识和相关示例，帮助模型理解任务场景。

上下文信息模型：

Context t = α ⋅ B + β ⋅ K + γ ⋅ E + δ ⋅ D \text{Context}_t = \alpha \cdot B + \beta \cdot K + \gamma \cdot E + \delta \cdot D Contextt=α⋅B+β⋅K+γ⋅E+δ⋅D

其中：

B B B：背景信息（Background）
K K K：领域知识（Knowledge）
E E E：示例（Examples）
D D D：数据（Data）
α , β , γ , δ \alpha, \beta, \gamma, \delta α,β,γ,δ：权重系数

示例：

python 复制代码

# 缺乏上下文的Prompt
prompt_no_context = "解释一下RAG技术"

# 提供充分上下文的Prompt
prompt_with_context = """
背景：
我是一名有3年经验的NLP工程师，正在开发一个企业知识库问答系统。
我们使用LangChain框架，后端是Python，数据库是PostgreSQL。

目标：
需要理解RAG（检索增强生成）技术，以便评估是否适合我们的场景。

请从以下角度解释RAG技术：
1. 基本原理：RAG是如何工作的？
2. 与传统方法（如纯微调、纯Prompt）的对比
3. 适用场景和局限性
4. 实现RAG的关键组件
5. 推荐的开源工具和框架

输出要求：
- 技术深度：中高级
- 包含架构图描述
- 提供代码片段示例
"""

原则四：角色扮演（Role-playing）

定义：通过赋予AI特定角色，引导其从专业视角思考和回答问题。

角色设计框架：

python 复制代码

class RoleDesign:
    """角色设计模板"""
    
    def __init__(self, name, expertise, background, communication_style):
        self.name = name
        self.expertise = expertise  # 专业领域
        self.background = background  # 背景经验
        self.communication_style = communication_style  # 沟通风格
    
    def generate_prompt_prefix(self):
        """生成角色扮演的Prompt前缀"""
        return f"""
你现在是一位{self.name}。

专业领域：{self.expertise}
背景经验：{self.background}
沟通风格：{self.communication_style}

请基于你的专业背景回答以下问题：
"""


# 创建不同角色的示例
senior_architect = RoleDesign(
    name="资深软件架构师",
    expertise="分布式系统设计、微服务架构、高并发解决方案",
    background="15年互联网大厂经验，主导过百万级QPS系统设计",
    communication_style="注重系统思考，强调trade-off分析，提供具体的技术方案"
)

ai_researcher = RoleDesign(
    name="AI研究员",
    expertise="深度学习、NLP、大模型优化",
    background="PhD，发表论文30+篇，曾在顶级AI实验室工作",
    communication_style="注重理论基础，引用最新研究成果，提供数学推导"
)

# 使用示例
question = "如何设计一个智能客服系统？"
prompt = senior_architect.generate_prompt_prefix() + question
print(prompt)

角色扮演的效果对比：

python 复制代码

# 场景：代码审查
code_review_prompt = """
你是一位经验丰富的代码审查专家，专注于：
- 代码质量（可读性、可维护性）
- 性能优化
- 安全漏洞检测
- 设计模式应用

请审查以下Python代码，并从你的专业角度提供改进建议：

```python
def process_data(data):
    result = []
    for item in data:
        if item['value'] > 0:
            result.append(item['value'] * 2)
    return result

审查维度：

代码质量问题
性能优化建议
潜在风险

改进方案（提供重构后的代码）
"""

原则五：结构化（Structured）

定义：使用清晰的层次结构和格式化标记，提高Prompt的可读性和可解析性。

结构化模板示例：

python 复制代码

class StructuredPromptTemplate:
    """结构化Prompt模板"""
    
    def __init__(self):
        self.sections = {}
    
    def add_section(self, name, content, level=1):
        """添加章节"""
        prefix = "#" * level
        self.sections[name] = f"{prefix} {name}\n\n{content}\n"
    
    def add_list(self, title, items):
        """添加列表"""
        list_content = "\n".join([f"- {item}" for item in items])
        self.sections[title] = f"## {title}\n\n{list_content}\n"
    
    def add_code_example(self, title, code, language="python"):
        """添加代码示例"""
        code_block = f"```{language}\n{code}\n```"
        self.sections[title] = f"## {title}\n\n{code_block}\n"
    
    def build(self):
        """构建完整Prompt"""
        return "\n".join(self.sections.values())


# 使用示例
template = StructuredPromptTemplate()

template.add_section(
    "任务说明",
    "分析用户评论的情感倾向，并提供改进建议"
)

template.add_list(
    "分析维度",
    [
        "情感极性（正面/负面/中性）",
        "关键词提取",
        "用户需求识别",
        "可操作性建议"
    ]
)

template.add_section(
    "输出格式",
    """
```json
{
    "sentiment": "positive/negative/neutral",
    "confidence": 0.95,
    "keywords": ["关键词1", "关键词2"],
    "suggestions": ["建议1", "建议2"]
}

"""

)

print(template.build())

复制代码

---

## 三、高级Prompt技巧

### 3.1 Few-shot Learning（少样本学习）

**定义**：通过在Prompt中提供少量示例，帮助模型快速理解任务模式。

**Few-shot Learning的理论基础**：

给定输入-输出对示例集 $S = \{(x_1, y_1), (x_2, y_2), ..., (x_k, y_k)\}$ 和新输入 $x_{new}$，模型需要通过类比推理生成输出：

$$y_{new} = f(x_{new} \mid S)$$

**示例数量选择指南**：

| 任务复杂度 | 推荐示例数 | 说明 |
|-----------|-----------|------|
| 简单分类 | 1-2个 | 任务模式明显 |
| 格式转换 | 2-3个 | 需要理解格式规范 |
| 复杂推理 | 3-5个 | 需要多步骤推理 |
| 专业领域 | 5-10个 | 需要领域知识 |

**代码实现：**

```python
class FewShotPromptBuilder:
    """Few-shot Prompt构建器"""
    
    def __init__(self, task_description):
        self.task_description = task_description
        self.examples = []
    
    def add_example(self, input_text, output_text):
        """添加示例"""
        self.examples.append({
            "input": input_text,
            "output": output_text
        })
    
    def build(self, new_input):
        """构建完整的Few-shot Prompt"""
        parts = [self.task_description + "\n"]
        
        # 添加示例
        parts.append("### 示例：\n")
        for i, example in enumerate(self.examples, 1):
            parts.append(f"示例 {i}：")
            parts.append(f"输入：{example['input']}")
            parts.append(f"输出：{example['output']}\n")
        
        # 添加新任务
        parts.append("### 现在请处理：")
        parts.append(f"输入：{new_input}")
        parts.append("输出：")
        
        return "\n".join(parts)


# 实战案例：情感分析
builder = FewShotPromptBuilder(
    task_description="判断用户评论的情感倾向（正面/负面/中性）"
)

# 添加示例
builder.add_example(
    "这个产品质量很好，物流也快，非常满意！",
    "正面（积极情感词汇：很好、快、满意）"
)

builder.add_example(
    "东西一般般，包装有破损，不太推荐",
    "负面（消极情感词汇：一般般、破损、不太推荐）"
)

builder.add_example(
    "收到了，还没拆开使用",
    "中性（客观陈述，无明显情感倾向）"
)

# 构建新Prompt
new_comment = "客服态度不错，但是等了半个月才收到货，有点失望"
prompt = builder.build(new_comment)
print(prompt)

Few-shot示例选择的优化策略：

python 复制代码

import numpy as np
from typing import List, Dict

class ExampleSelector:
    """示例选择器：基于相似度选择最优示例"""
    
    def __init__(self, examples: List[Dict]):
        self.examples = examples
    
    def calculate_similarity(self, text1: str, text2: str) -> float:
        """
        计算文本相似度（简化版，实际应用中可使用embedding）
        这里使用词集合的Jaccard相似度作为示例
        """
        words1 = set(text1.lower().split())
        words2 = set(text2.lower().split())
        
        intersection = words1 & words2
        union = words1 | words2
        
        if not union:
            return 0.0
        
        return len(intersection) / len(union)
    
    def select_top_k_examples(self, query: str, k: int = 3) -> List[Dict]:
        """选择与query最相似的k个示例"""
        similarities = []
        
        for example in self.examples:
            sim = self.calculate_similarity(query, example['input'])
            similarities.append((sim, example))
        
        # 按相似度排序
        similarities.sort(key=lambda x: x[0], reverse=True)
        
        return [item[1] for item in similarities[:k]]


# 使用示例
examples_db = [
    {"input": "这个手机电池续航很强", "output": "正面", "category": "电子产品"},
    {"input": "物流太慢了，差评", "output": "负面", "category": "物流"},
    {"input": "衣服质量不错，尺码合适", "output": "正面", "category": "服装"},
    {"input": "客服回复很慢，态度一般", "output": "负面", "category": "客服"},
]

selector = ExampleSelector(examples_db)
query = "这个笔记本电池不耐用"
selected = selector.select_top_k_examples(query, k=2)

print("为查询选择的示例：")
for ex in selected:
    print(f"- {ex['input']} -> {ex['output']}")

3.2 Chain of Thought（思维链）

定义：引导模型逐步展开推理过程，提高复杂问题的解决质量。

CoT的数学表达：

传统Prompt的推理过程可以表示为：

P ( Answer ∣ Question ) P(\text{Answer} \mid \text{Question}) P(Answer∣Question)

而CoT将推理分解为：

P ( Answer ∣ Question ) = ∑ r ∈ R P ( Answer ∣ r ) ⋅ P ( r ∣ Question ) P(\text{Answer} \mid \text{Question}) = \sum_{r \in R} P(\text{Answer} \mid r) \cdot P(r \mid \text{Question}) P(Answer∣Question)=r∈R∑P(Answer∣r)⋅P(r∣Question)

其中 r r r 表示推理链（Reasoning Chain）， R R R 是所有可能推理链的集合。

CoT的几种实现方式：

python 复制代码

class ChainOfThoughtPrompt:
    """思维链Prompt模板"""
    
    @staticmethod
    def zero_shot_cot():
        """Zero-shot CoT：仅添加推理指令"""
        return "让我们一步一步地思考这个问题。\n"
    
    @staticmethod
    def manual_cot(reasoning_steps):
        """手动CoT：提供明确的推理步骤"""
        steps = "\n".join([f"第{i+1}步：{step}" for i, step in enumerate(reasoning_steps)])
        return f"请按照以下步骤进行分析：\n{steps}\n"
    
    @staticmethod
    def few_shot_cot(examples_with_reasoning):
        """Few-shot CoT：提供带推理过程的示例"""
        parts = ["参考以下示例的推理过程：\n"]
        for i, ex in enumerate(examples_with_reasoning, 1):
            parts.append(f"示例{i}：")
            parts.append(f"问题：{ex['question']}")
            parts.append(f"推理过程：{ex['reasoning']}")
            parts.append(f"答案：{ex['answer']}\n")
        return "\n".join(parts)


# 实战案例：数学问题求解
cot_prompt = """
请解决以下数学问题，要求展示完整的推理过程。

问题：一个商店买了100件商品，每件成本是50元。如果以每件80元的价格卖出，
卖出率为80%，求最终利润是多少？

让我们一步步推理：

第一步：计算总成本
- 成本 = 100件 × 50元/件 = 5000元

第二步：计算实际销售数量
- 销售数量 = 100件 × 80% = 80件

第三步：计算总收入
- 收入 = 80件 × 80元/件 = 6400元

第四步：计算利润
- 利润 = 收入 - 成本 = 6400元 - 5000元 = 1400元

答案：最终利润是1400元。

---

现在请用同样的方法解决：

问题：某工厂生产一批零件，原计划每天生产200个，需要15天完成。
实际生产中，前5天每天生产180个，之后每天生产220个。
问实际用了多少天完成？
"""

CoT在不同场景的应用：

python 复制代码

# 场景1：代码调试
debug_cot = """
你是一位代码调试专家。请按以下步骤分析代码问题：

步骤1：理解代码意图
- 分析代码想要实现什么功能
- 检查输入输出的期望

步骤2：识别潜在问题
- 语法错误
- 逻辑错误
- 边界条件
- 异常处理

步骤3：定位问题根源
- 使用断点或日志分析
- 追踪变量值变化

步骤4：提供修复方案
- 给出修改后的代码
- 解释修改原因

请按此步骤分析以下代码：
```python
def find_max(numbers):
    max_val = 0
    for num in numbers:
        if num > max_val:
            max_val = num
    return max_val

"""

场景2：架构设计

architecture_cot = """

你是一位系统架构师。请使用结构化思维设计系统方案：

第一步：需求分析

功能需求
非功能需求（性能、可用性、扩展性）
约束条件

第二步：技术选型

对比多种技术方案
分析trade-off
给出选择理由

第三步：架构设计

组件划分
接口定义
数据流设计
部署架构

第四步：风险分析

单点故障
性能瓶颈
安全风险

第五步：优化方案

可扩展性设计
容灾方案
监控告警

现在请基于以上步骤，设计一个高并发秒杀系统。

"""

复制代码

### 3.3 Tree of Thought（思维树）

**定义**：通过构建多分支的思维树，探索多种推理路径，找到最优解。

**ToT vs CoT对比**：

$$
\text{CoT}: \text{Question} \xrightarrow{\text{推理}} \text{Answer}
$$

$$
\text{ToT}: \text{Question} \xrightarrow{\text{分支}} \begin{cases} \text{Path}_1 \rightarrow \text{Answer}_1 \\ \text{Path}_2 \rightarrow \text{Answer}_2 \\ \text{Path}_3 \rightarrow \text{Answer}_3 \end{cases} \xrightarrow{\text{评估}} \text{Best Answer}
$$

**ToT实现框架：**

```python
from typing import List, Dict, Tuple
import json

class TreeOfThought:
    """思维树框架"""
    
    def __init__(self, max_depth: int = 3, branch_factor: int = 3):
        self.max_depth = max_depth
        self.branch_factor = branch_factor
        self.thought_tree = {}
    
    def generate_thoughts(self, current_state: str, n: int) -> List[str]:
        """生成n个可能的思考方向"""
        # 这里应该是调用LLM生成多个思考方向
        # 简化示例，返回占位符
        prompt = f"""
当前状态：{current_state}

请生成{n}个不同的思考方向，每个方向应该：
1. 有不同的切入点
2. 有可能导向解决方案
3. 相互独立，避免重复

输出格式：
- 思考方向1：...
- 思考方向2：...
- 思考方向3：...
"""
        # 实际应用中会调用LLM
        return ["思考方向1", "思考方向2", "思考方向3"]
    
    def evaluate_thought(self, thought: str) -> float:
        """评估思考方向的价值（0-1分数）"""
        # 评估标准：可行性、创新性、完整性
        prompt = f"""
评估以下思考方向的价值：

思考方向：{thought}

评估维度：
1. 可行性（能否实施）
2. 创新性（是否有新见解）
3. 完整性（是否考虑周全）

请给出0-1之间的综合评分，并说明理由。
"""
        # 实际应用中会调用LLM进行评估
        return 0.8  # 占位符
    
    def search(self, problem: str) -> str:
        """执行思维树搜索"""
        # 使用广度优先搜索或最佳优先搜索
        frontier = [(problem, 0)]  # (状态, 深度)
        best_solution = None
        best_score = 0
        
        while frontier:
            current_state, depth = frontier.pop(0)
            
            if depth >= self.max_depth:
                # 达到最大深度，评估解决方案
                score = self.evaluate_thought(current_state)
                if score > best_score:
                    best_score = score
                    best_solution = current_state
                continue
            
            # 生成新的思考方向
            thoughts = self.generate_thoughts(current_state, self.branch_factor)
            
            for thought in thoughts:
                # 评估并选择有希望的方向
                score = self.evaluate_thought(thought)
                if score > 0.5:  # 阈值过滤
                    frontier.append((thought, depth + 1))
        
        return best_solution


# ToT应用示例：创意写作
tot_writing_prompt = """
使用思维树方法创作一篇关于"AI与人类协作"的短文。

### 第一层：确定文章角度
分支A：从技术发展角度（AI工具如何辅助人类）
分支B：从哲学思考角度（人机关系的本质）
分支C：从实践案例角度（具体应用场景）

### 第二层：展开每个角度
对于分支A（技术角度）：
- A1: 编程辅助（Copilot等）
- A2: 内容创作（写作、设计）
- A3: 数据分析（洞察发现）

### 第三层：细化内容
对于A1（编程辅助）：
- 提升效率的具体数据
- 开发者的使用体验
- 对编程未来的影响

请基于以上思维树结构，选择最有价值的路径，创作一篇500字短文。
"""

ToT在复杂决策中的应用：

python 复制代码

class DecisionTreePrompt:
    """决策树Prompt模板"""
    
    @staticmethod
    def create_decision_tree(scenario: str, options: List[str]):
        """创建决策树Prompt"""
        prompt = f"""
场景：{scenario}

请使用决策树思维分析以下选项：

{chr(10).join([f"选项{i+1}：{opt}" for i, opt in enumerate(options)])}

分析要求：
1. 为每个选项生成可能的结果（正面/负面）
2. 评估每个结果的概率
3. 计算期望价值
4. 考虑风险因素

输出格式：

决策树：

├── 选项1

│ ├── 结果A（概率：p1，价值：v1）

│ └── 结果B（概率：p2，价值：v2）

├── 选项2

│ ├── 结果C（概率：p3，价值：v3）

│ └── 结果D（概率：p4，价值：v4）

...

推荐选择：[选项X]

理由：...

复制代码

"""
        return prompt


# 实战案例：技术选型决策
decision_prompt = DecisionTreePrompt.create_decision_tree(
    scenario="创业公司需要选择后端技术栈",
    options=[
        "使用Python + Django（快速开发）",
        "使用Java + Spring（企业级稳定）",
        "使用Go + Gin（高性能）"
    ]
)
print(decision_prompt)

四、Prompt模板管理

4.1 为什么需要Prompt模板？

在实际项目中，我们经常需要：

复用：相同类型的任务使用相似的Prompt结构
维护：集中管理和更新Prompt
版本控制：追踪Prompt的演变历史
A/B测试：对比不同Prompt的效果

Prompt模板的价值模型：

Value template = 复用次数 × 效率提升维护成本 \text{Value}_{\text{template}} = \frac{\text{复用次数} \times \text{效率提升}}{\text{维护成本}} Valuetemplate=维护成本复用次数×效率提升

4.2 Prompt模板设计模式

模式一：变量插值模板

python 复制代码

from string import Template

class PromptTemplate:
    """Prompt模板类"""
    
    def __init__(self, template: str, variables: dict):
        self.template = Template(template)
        self.variables = variables
        self.required_vars = self._extract_variables()
    
    def _extract_variables(self) -> list:
        """提取模板中的变量名"""
        import re
        return re.findall(r'\$\{?(\w+)\}?', self.template.template)
    
    def render(self, **kwargs) -> str:
        """渲染模板"""
        # 检查必需变量
        missing = set(self.required_vars) - set(kwargs.keys())
        if missing:
            raise ValueError(f"缺少必需变量：{missing}")
        
        return self.template.safe_substitute(**kwargs)
    
    def validate(self) -> bool:
        """验证模板格式"""
        try:
            # 尝试用空值渲染
            test_vars = {var: "" for var in self.required_vars}
            self.template.safe_substitute(**test_vars)
            return True
        except Exception as e:
            print(f"模板验证失败：{e}")
            return False


# 实战示例：代码审查模板
code_review_template = PromptTemplate(
    template="""
你是一位经验丰富的${language}代码审查专家。

请审查以下代码，重点关注：
${focus_areas}

代码：
\`\`\`${language}
${code}
\`\`\`

输出格式：
1. 代码质量评分（1-10）
2. 发现的问题列表
3. 改进建议
4. 重构后的代码（如适用）
""",
    variables={
        'language': '编程语言',
        'focus_areas': '关注点',
        'code': '待审查代码'
    }
)

# 使用模板
prompt = code_review_template.render(
    language="Python",
    focus_areas="- 代码规范\n- 性能优化\n- 安全性",
    code="def process(items):\n    result = []\n    for i in items:\n        result.append(i * 2)\n    return result"
)

print(prompt)

模式二：组合模板

python 复制代码

class CompositePromptTemplate:
    """组合式Prompt模板"""
    
    def __init__(self):
        self.sections = []
    
    def add_role_section(self, role: str, expertise: str):
        """添加角色定义部分"""
        self.sections.append({
            'type': 'role',
            'content': f"你是一位{role}，专业领域：{expertise}"
        })
    
    def add_context_section(self, context: str):
        """添加上下文部分"""
        self.sections.append({
            'type': 'context',
            'content': context
        })
    
    def add_task_section(self, task: str, requirements: list):
        """添加任务部分"""
        req_str = "\n".join([f"{i+1}. {r}" for i, r in enumerate(requirements)])
        self.sections.append({
            'type': 'task',
            'content': f"任务：{task}\n\n要求：\n{req_str}"
        })
    
    def add_examples_section(self, examples: list):
        """添加示例部分"""
        ex_str = ""
        for i, ex in enumerate(examples, 1):
            ex_str += f"示例{i}：\n输入：{ex['input']}\n输出：{ex['output']}\n\n"
        
        self.sections.append({
            'type': 'examples',
            'content': f"参考示例：\n{ex_str}"
        })
    
    def add_output_format_section(self, format_spec: str):
        """添加输出格式部分"""
        self.sections.append({
            'type': 'output_format',
            'content': f"输出格式：\n{format_spec}"
        })
    
    def build(self) -> str:
        """构建完整Prompt"""
        return "\n\n---\n\n".join([s['content'] for s in self.sections])


# 使用示例
composite_template = CompositePromptTemplate()
composite_template.add_role_section(
    role="数据分析师",
    expertise="用户行为分析、数据可视化、统计建模"
)
composite_template.add_context_section(
    context="我们是一家电商平台，用户数据存储在MySQL数据库中"
)
composite_template.add_task_section(
    task="分析用户购买行为",
    requirements=[
        "识别用户购买周期",
        "找出高价值用户特征",
        "预测下月销售额",
        "提供营销建议"
    ]
)
composite_template.add_examples_section([
    {"input": "用户A购买记录", "output": "分析结果A"},
    {"input": "用户B购买记录", "output": "分析结果B"}
])
composite_template.add_output_format_section(
    format_spec="""```json
{
    "analysis": "分析结论",
    "insights": ["洞察1", "洞察2"],
    "recommendations": ["建议1", "建议2"]
}
```"""
)

print(composite_template.build())

4.3 Prompt版本管理

python 复制代码

import json
from datetime import datetime
from typing import Dict, List

class PromptVersionControl:
    """Prompt版本控制系统"""
    
    def __init__(self, storage_path: str = "prompt_versions.json"):
        self.storage_path = storage_path
        self.versions = self._load_versions()
    
    def _load_versions(self) -> Dict:
        """加载版本历史"""
        try:
            with open(self.storage_path, 'r', encoding='utf-8') as f:
                return json.load(f)
        except FileNotFoundError:
            return {}
    
    def _save_versions(self):
        """保存版本历史"""
        with open(self.storage_path, 'w', encoding='utf-8') as f:
            json.dump(self.versions, f, ensure_ascii=False, indent=2)
    
    def create_version(self, prompt_name: str, prompt_content: str, 
                      description: str, tags: List[str] = None):
        """创建新版本"""
        if prompt_name not in self.versions:
            self.versions[prompt_name] = []
        
        version_num = len(self.versions[prompt_name]) + 1
        version_data = {
            'version': f"v{version_num}",
            'content': prompt_content,
            'description': description,
            'tags': tags or [],
            'created_at': datetime.now().isoformat(),
            'performance': None  # 后续记录性能指标
        }
        
        self.versions[prompt_name].append(version_data)
        self._save_versions()
        
        return version_data['version']
    
    def get_version(self, prompt_name: str, version: str = 'latest'):
        """获取指定版本"""
        if prompt_name not in self.versions:
            return None
        
        versions = self.versions[prompt_name]
        
        if version == 'latest':
            return versions[-1]
        
        for v in versions:
            if v['version'] == version:
                return v
        
        return None
    
    def compare_versions(self, prompt_name: str, v1: str, v2: str):
        """对比两个版本"""
        version1 = self.get_version(prompt_name, v1)
        version2 = self.get_version(prompt_name, v2)
        
        if not version1 or not version2:
            return None
        
        return {
            'version1': version1,
            'version2': version2,
            'diff': self._compute_diff(version1['content'], version2['content'])
        }
    
    def _compute_diff(self, text1: str, text2: str):
        """计算文本差异（简化版）"""
        # 实际应用中可以使用difflib或其他diff库
        lines1 = text1.split('\n')
        lines2 = text2.split('\n')
        
        added = set(lines2) - set(lines1)
        removed = set(lines1) - set(lines2)
        
        return {
            'added': list(added),
            'removed': list(removed)
        }
    
    def record_performance(self, prompt_name: str, version: str, 
                          metrics: Dict):
        """记录性能指标"""
        version_data = self.get_version(prompt_name, version)
        if version_data:
            version_data['performance'] = metrics
            self._save_versions()


# 使用示例
version_control = PromptVersionControl()

# 创建新版本
v1 = version_control.create_version(
    prompt_name="code_review",
    prompt_content="请审查以下代码...",
    description="初始版本的代码审查Prompt",
    tags=["代码质量", "Python"]
)

# 记录性能
version_control.record_performance(
    prompt_name="code_review",
    version=v1,
    metrics={
        'success_rate': 0.85,
        'avg_response_time': 2.3,
        'user_satisfaction': 4.2
    }
)

# 获取最新版本
latest = version_control.get_version("code_review", "latest")
print(f"最新版本：{latest['version']}")

五、动手实践：构建Prompt模板库

5.1 项目结构设计

复制代码

prompt_library/
├── templates/
│   ├── code_review.json
│   ├── data_analysis.json
│   └── content_writing.json
├── core/
│   ├── template_manager.py
│   ├── version_control.py
│   └── evaluator.py
├── examples/
│   └── usage_examples.py
└── config/
    └── settings.py

5.2 核心实现

python 复制代码

# core/template_manager.py
import json
from pathlib import Path
from typing import Dict, List, Optional
from dataclasses import dataclass
from enum import Enum

class PromptCategory(Enum):
    """Prompt分类"""
    CODE = "代码开发"
    ANALYSIS = "数据分析"
    WRITING = "内容创作"
    QA = "问答系统"
    TRANSLATION = "翻译"


@dataclass
class PromptTemplate:
    """Prompt模板数据结构"""
    id: str
    name: str
    category: PromptCategory
    description: str
    template: str
    variables: List[str]
    examples: List[Dict]
    best_practices: List[str]
    version: str
    performance_score: Optional[float] = None


class PromptLibrary:
    """Prompt模板库管理器"""
    
    def __init__(self, library_path: str = "./templates"):
        self.library_path = Path(library_path)
        self.templates: Dict[str, PromptTemplate] = {}
        self._load_all_templates()
    
    def _load_all_templates(self):
        """加载所有模板文件"""
        self.library_path.mkdir(parents=True, exist_ok=True)
        
        for template_file in self.library_path.glob("*.json"):
            with open(template_file, 'r', encoding='utf-8') as f:
                data = json.load(f)
                template = PromptTemplate(
                    id=data['id'],
                    name=data['name'],
                    category=PromptCategory(data['category']),
                    description=data['description'],
                    template=data['template'],
                    variables=data['variables'],
                    examples=data.get('examples', []),
                    best_practices=data.get('best_practices', []),
                    version=data.get('version', 'v1')
                )
                self.templates[template.id] = template
    
    def get_template(self, template_id: str) -> Optional[PromptTemplate]:
        """获取指定模板"""
        return self.templates.get(template_id)
    
    def search_templates(self, keyword: str = None, 
                        category: PromptCategory = None) -> List[PromptTemplate]:
        """搜索模板"""
        results = list(self.templates.values())
        
        if category:
            results = [t for t in results if t.category == category]
        
        if keyword:
            keyword_lower = keyword.lower()
            results = [t for t in results 
                      if keyword_lower in t.name.lower() or 
                         keyword_lower in t.description.lower()]
        
        return results
    
    def render_template(self, template_id: str, **kwargs) -> str:
        """渲染模板"""
        template = self.get_template(template_id)
        
        if not template:
            raise ValueError(f"模板不存在：{template_id}")
        
        # 检查必需变量
        missing = set(template.variables) - set(kwargs.keys())
        if missing:
            raise ValueError(f"缺少必需变量：{missing}")
        
        # 渲染模板
        result = template.template
        for key, value in kwargs.items():
            result = result.replace(f"{{{key}}}", str(value))
        
        return result
    
    def add_template(self, template: PromptTemplate):
        """添加新模板"""
        self.templates[template.id] = template
        self._save_template(template)
    
    def _save_template(self, template: PromptTemplate):
        """保存模板到文件"""
        file_path = self.library_path / f"{template.id}.json"
        
        data = {
            'id': template.id,
            'name': template.name,
            'category': template.category.value,
            'description': template.description,
            'template': template.template,
            'variables': template.variables,
            'examples': template.examples,
            'best_practices': template.best_practices,
            'version': template.version
        }
        
        with open(file_path, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
    
    def get_best_practices(self, template_id: str) -> List[str]:
        """获取模板的最佳实践"""
        template = self.get_template(template_id)
        return template.best_practices if template else []


# 创建模板库实例
library = PromptLibrary()

5.3 预置模板示例

python 复制代码

# 创建代码审查模板
code_review_template = PromptTemplate(
    id="code_review_python",
    name="Python代码审查模板",
    category=PromptCategory.CODE,
    description="用于Python代码的质量审查，包含代码规范、性能、安全性等维度",
    template="""
你是一位资深的Python代码审查专家，具有10年以上的开发经验。

## 审查目标
对以下Python代码进行全面审查：

```python
{code}

审查维度

请从以下方面进行审查：

{review_aspects}

输出要求

{output_format}

特别关注

{special_attention}

""",

variables=['code', 'review_aspects', 'output_format', 'special_attention'],

examples=[

{

'input': 'def process(data): return [x*2 for x in data]',

'output': '评分：7/10\n问题：缺少类型注解、文档字符串\n建议：添加类型提示和异常处理'

}

best_practices=[

"总是检查输入参数的有效性",

"对性能敏感的代码提供时间复杂度分析",

"指出潜在的安全风险",

"提供改进后的代码示例"

version="v1.0"

)

添加到库

library.add_template(code_review_template)

使用模板

rendered_prompt = library.render_template(

"code_review_python",

code="def calculate_sum(numbers):\n total = 0\n for n in numbers:\n total += n\n return total",

review_aspects="- 代码规范（PEP 8）\n- 性能优化\n- 类型安全\n- 异常处理",

output_format="JSON格式，包含score、issues、suggestions字段",

special_attention="注意大数据量场景下的性能问题"

)

print(rendered_prompt)

复制代码

### 5.4 Prompt效果评估系统

```python
from typing import Callable
import time

class PromptEvaluator:
    """Prompt效果评估器"""
    
    def __init__(self):
        self.evaluation_history = []
    
    def evaluate(self, prompt: str, llm_call: Callable, 
                test_cases: List[Dict], metrics: List[str]):
        """
        评估Prompt效果
        
        参数：
            prompt: Prompt模板
            llm_call: LLM调用函数
            test_cases: 测试用例列表
            metrics: 评估指标列表
        """
        results = {
            'prompt': prompt,
            'test_cases': test_cases,
            'metrics': {},
            'details': []
        }
        
        total_time = 0
        success_count = 0
        
        for test_case in test_cases:
            start_time = time.time()
            
            # 调用LLM
            try:
                response = llm_call(prompt.format(**test_case['input']))
                success = self._check_output(response, test_case['expected'])
                
                if success:
                    success_count += 1
                
                elapsed = time.time() - start_time
                total_time += elapsed
                
                results['details'].append({
                    'input': test_case['input'],
                    'expected': test_case['expected'],
                    'actual': response,
                    'success': success,
                    'time': elapsed
                })
            
            except Exception as e:
                results['details'].append({
                    'input': test_case['input'],
                    'error': str(e),
                    'success': False
                })
        
        # 计算指标
        n = len(test_cases)
        results['metrics'] = {
            'success_rate': success_count / n if n > 0 else 0,
            'avg_time': total_time / n if n > 0 else 0
        }
        
        self.evaluation_history.append(results)
        return results
    
    def _check_output(self, actual: str, expected: str) -> bool:
        """检查输出是否符合预期"""
        # 简化版检查，实际应用中可以使用更复杂的匹配逻辑
        return expected.lower() in actual.lower()
    
    def compare_prompts(self, prompts: List[str], test_cases: List[Dict],
                       llm_call: Callable):
        """对比多个Prompt的效果"""
        comparison_results = []
        
        for i, prompt in enumerate(prompts):
            result = self.evaluate(prompt, llm_call, test_cases, ['success_rate', 'avg_time'])
            result['prompt_id'] = i
            comparison_results.append(result)
        
        # 排序
        comparison_results.sort(key=lambda x: x['metrics']['success_rate'], reverse=True)
        
        return comparison_results


# 使用示例
def mock_llm_call(prompt: str) -> str:
    """模拟LLM调用"""
    # 实际应用中这里会调用真实的API
    time.sleep(0.1)  # 模拟延迟
    return "这是模拟的LLM响应"

evaluator = PromptEvaluator()

test_cases = [
    {
        'input': {'question': '什么是机器学习？'},
        'expected': '人工智能'
    },
    {
        'input': {'question': 'Python有什么优点？'},
        'expected': '简单'
    }
]

prompt_v1 = "请回答：{question}"
prompt_v2 = "作为一位AI专家，请详细回答以下问题：{question}\n要求：内容准确、逻辑清晰、举例说明"

comparison = evaluator.compare_prompts(
    prompts=[prompt_v1, prompt_v2],
    test_cases=test_cases,
    llm_call=mock_llm_call
)

print("Prompt对比结果：")
for result in comparison:
    print(f"Prompt {result['prompt_id']}: 成功率={result['metrics']['success_rate']:.2%}")

5.5 完整的使用示例

python 复制代码

# examples/usage_examples.py

class PromptLibraryDemo:
    """Prompt库使用演示"""
    
    def __init__(self):
        self.library = PromptLibrary()
        self._setup_default_templates()
    
    def _setup_default_templates(self):
        """设置默认模板"""
        # 数据分析模板
        data_analysis_template = PromptTemplate(
            id="data_analysis",
            name="数据分析助手",
            category=PromptCategory.ANALYSIS,
            description="帮助用户进行数据分析和洞察发现",
            template="""
你是一位数据分析专家，擅长从数据中发现洞察和趋势。

## 数据背景
{data_context}

## 分析任务
{task}

## 分析要求
{requirements}

## 输出格式
请提供：
1. 数据概览
2. 关键发现（至少3条）
3. 数据可视化建议
4. 行动建议
""",
            variables=['data_context', 'task', 'requirements'],
            examples=[],
            best_practices=[
                "先进行数据质量检查",
                "使用统计方法验证结论",
                "提供可操作的建议"
            ],
            version="v1.0"
        )
        
        self.library.add_template(data_analysis_template)
    
    def demo_code_review(self):
        """演示代码审查功能"""
        print("=== 代码审查示例 ===\n")
        
        code = """
def fibonacci(n):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    
    fib = [0, 1]
    for i in range(2, n):
        fib.append(fib[i-1] + fib[i-2])
    return fib
"""
        
        prompt = self.library.render_template(
            "code_review_python",
            code=code,
            review_aspects="1. 代码正确性\n2. 时间复杂度\n3. 边界条件处理\n4. 代码可读性",
            output_format="Markdown格式，包含评分、问题列表、改进建议",
            special_attention="注意大数情况下的性能问题"
        )
        
        print(prompt)
        print("\n最佳实践：")
        for practice in self.library.get_best_practices("code_review_python"):
            print(f"  • {practice}")
    
    def demo_data_analysis(self):
        """演示数据分析功能"""
        print("\n=== 数据分析示例 ===\n")
        
        prompt = self.library.render_template(
            "data_analysis",
            data_context="电商平台2024年Q1销售数据，包含用户购买记录、商品类别、销售额等",
            task="识别用户购买行为模式，预测Q2销售趋势",
            requirements="1. 分析购买周期\n2. 识别高价值用户特征\n3. 提供营销建议"
        )
        
        print(prompt)
    
    def demo_search(self):
        """演示搜索功能"""
        print("\n=== 模板搜索示例 ===\n")
        
        # 按关键词搜索
        results = self.library.search_templates(keyword="代码")
        print(f"关键词'代码'的搜索结果：{len(results)}个")
        for r in results:
            print(f"  - {r.name}")
        
        # 按分类搜索
        results = self.library.search_templates(category=PromptCategory.ANALYSIS)
        print(f"\n'数据分析'类别的模板：{len(results)}个")
        for r in results:
            print(f"  - {r.name}")


# 运行演示
if __name__ == "__main__":
    demo = PromptLibraryDemo()
    demo.demo_code_review()
    demo.demo_data_analysis()
    demo.demo_search()

六、本节小结

核心知识点回顾

Prompt工程定义：通过优化输入提示，引导AI模型生成高质量输出的技术
五大设计原则：
- 清晰性：避免歧义，明确表达
- 具体性：提供具体约束和要求
- 上下文：提供充分背景信息
- 角色扮演：赋予AI专业角色
- 结构化：使用清晰的层次结构
三种高级技巧：
- Few-shot Learning：通过示例引导模型学习
- Chain of Thought：逐步推理，提高复杂问题解决能力
- Tree of Thought：多分支探索，找到最优解
模板管理：建立可复用、可维护、可版本控制的Prompt模板系统

学习成果检查清单

理解Prompt工程的基本概念和重要性
掌握五大设计原则并能应用于实际场景
会使用Few-shot Learning提升Prompt效果
会使用Chain of Thought处理复杂推理任务
理解Tree of Thought的适用场景
能够设计和管理Prompt模板
完成了Prompt模板库的实践项目

常见误区与注意事项

❌ 误区1 ：Prompt越长越好

✅ 正确：适度即可，过长会引入噪音

❌ 误区2 ：一个Prompt解决所有问题

✅ 正确：根据场景定制，保持模板的针对性

❌ 误区3 ：忽略输出格式

✅ 正确：明确指定输出格式，提高可解析性

七、习题

基础题

1. 选择题

以下哪个Prompt最符合"清晰性"原则？

A. "帮我写个程序"

B. "写一个Python函数"

C. "用Python编写一个计算列表平均值的函数，要求处理空列表情况"

D. "写代码"

2. 填空题

Few-shot Learning通过在Prompt中提供______来帮助模型理解任务模式。推荐示例数量为：简单任务______个，复杂任务______个。

3. 简答题

请解释Chain of Thought和Tree of Thought的区别，并分别举例说明适用场景。

进阶题

4. 实践题

设计一个用于"技术文档生成"的Prompt模板，要求：

使用角色扮演原则
包含至少3个变量
提供输出格式说明
符合结构化设计

5. 分析题

观察以下两个Prompt，分析哪个效果更好，并说明原因：

python 复制代码

Prompt A = "翻译这段文字"

Prompt B = """
你是一位专业的技术翻译，精通中英双语。

翻译以下技术文档片段，要求：
1. 保持专业术语准确
2. 语句通顺自然
3. 保留原文的技术含义

原文：
{content}

输出格式：
翻译：[翻译内容]
术语说明：[新增术语的解释]
"""

挑战题

6. 综合应用

使用本节学习的技巧，构建一个完整的代码生成Prompt系统：

要求：

使用Few-shot Learning提供代码示例
使用Chain of Thought引导思考
使用模板化管理Prompt
支持多种编程语言
输出包含代码、注释和测试用例

八、推荐阅读

官方文档

学术论文

Wei, J., et al. (2022). "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models"
Yao, S., et al. (2023). "Tree of Thoughts: Deliberate Problem Solving with Large Language Models"
Brown, T., et al. (2020). "Language Models are Few-Shot Learners"

实用资源

Learn Prompting - 免费的Prompt工程教程
Prompt Engineering Guide - 系统性的Prompt工程指南
Awesome ChatGPT Prompts - Prompt示例集合

进阶阅读

《Build a Large Language Model (From Scratch)》- Sebastian Raschka
《Natural Language Processing with Transformers》- Lewis et al.
《Designing Machine Learning Systems》- Chip Huyen

附录：术语表

术语	英文	定义
Prompt工程	Prompt Engineering	设计和优化AI模型输入提示的技术
Few-shot Learning	Few-shot Learning	通过少量示例快速学习任务的方法
Chain of Thought	Chain of Thought (CoT)	引导模型逐步推理的技术
Tree of Thought	Tree of Thought (ToT)	构建多分支思维树的推理方法
Token	Token	文本的最小处理单元
上下文窗口	Context Window	模型一次能处理的最大Token数
幻觉	Hallucination	模型生成不准确或虚构内容的现象