摘要
随着大语言模型（Large Language Model, LLM）技术的快速发展，Prompt工程（提示工程）已成为AI应用开发中最核心的技术之一。本文系统性地介绍了Prompt工程的理论基础与实践方法，涵盖Zero-shot、Few-shot、Chain-of-Thought等主流技术，并提供了完整的Python代码示例。通过本文，读者将掌握设计高效Prompt的核心技巧，能够在文本分类、内容生成、代码开发、数据分析等实际场景中显著提升LLM的应用效果。
关键词： Prompt工程；大语言模型；Few-shot；Chain-of-Thought；LangChain；提示优化
一、什么是Prompt
1.1 Prompt的定义
Prompt（提示）是用户向大语言模型发送的输入文本，它是模型生成输出的直接依据。在传统的机器学习中，模型需要通过大量标注数据进行训练；而在LLM时代，我们通过精心设计的Prompt来"引导"模型完成各种任务，而无需修改模型本身的权重。
一个完整的Prompt通常包含以下要素：
-
指令（Instruction）：告诉模型需要执行什么任务
-
上下文（Context）：提供必要的背景信息
-
输入数据（Input Data）：模型需要处理的具体内容
-
输出格式（Output Format）：期望的返回格式或结构
1.2 为什么Prompt工程重要
Prompt工程之所以重要，主要体现在以下几个方面：
第一，成本与效率的平衡。 相比于微调（Fine-tuning）模型，Prompt工程无需消耗大量计算资源进行训练，通过优化提示词即可显著提升模型表现。
第二，快速迭代与实验。 开发者可以实时调整Prompt内容，立即观察效果，大幅缩短开发周期。
第三，模型适配性强。 同一套Prompt技巧在多数主流LLM上都具有良好的迁移性。
第四，业务适配度高。 通过精心设计的Prompt，可以让通用模型更好地适配特定业务场景。
二、Zero-shot Prompting
2.1 概念与原理
Zero-shot Prompting（零样本提示）是最基础的Prompt使用方式，指在不提供任何示例的情况下，直接通过自然语言指令告诉模型需要完成的任务。这种方式适用于任务简单明确、模型对任务本身有较好理解的情况。
2.2 代码示例
import openai
import os
# 设置API密钥
# 请确保环境变量OPENAI_API_KEY已正确配置
openai.api_key = os.getenv("OPENAI_API_KEY")
def zero_shot_completion(prompt: str, model: str = "gpt-3.5-turbo") -> str:
"""
使用Zero-shot方式调用LLM接口
参数:
prompt: 用户输入的提示词
model: 使用的模型名称
返回:
模型生成的文本
"""
response = openai.ChatCompletion.create(
model=model,
messages=[
{"role": "system", "content": "你是一个专业的AI助手。"},
{"role": "user", "content": prompt}
],
temperature=0.7, # 控制随机性，0为最确定性的输出
max_tokens=500 # 最大生成token数
)
return response.choices[0].message.content
# 示例：直接提问进行文本分类
if __name__ == "__main__":
prompt = "请判断以下评论的情感是正面还是负面：'这家餐厅的服务非常出色，菜品也很美味！'"
result = zero_shot_completion(prompt)
print(f"分类结果: {result}")2.3 适用场景
Zero-shot Prompting适用于以下场景：
-
简单分类任务：如判断情感倾向、识别垃圾邮件等
-
格式转换：如将JSON转换为Markdown表格
-
基础问答：直接回答客观事实类问题
-
简单翻译：常见的语言互译任务
2.4 注意事项
使用Zero-shot时，指令需要足够清晰明确。模糊的指令往往导致模型输出不稳定。以下是优化建议：
# 不推荐的写法（过于模糊）
prompt_v1 = "分析这段话"
# 推荐的写法（清晰明确）
prompt_v2 = """
请分析以下产品评论，按照以下三个维度进行评价：
1. 情感倾向（正面/负面/中性）
2. 主要优点（列出1-2个）
3. 主要缺点（列出1-2个）
评论内容：
"这个手机相机效果很棒，但是电池续航有点差强人意。"
"""三、Few-shot Prompting
3.1 概念与原理
Few-shot Prompting（少样本提示）通过在Prompt中提供少量示例（通常2-5个），帮助模型理解任务的具体模式和期望输出格式。这种方式充分利用了LLM的**上下文学习（In-context Learning）**能力，让模型从示例中推断出任务规则。
3.2 为什么Few-shot有效
Few-shot之所以有效，是因为：
-
示例提供了任务格式的显式说明，减少模型对指令理解的歧义
-
示例展示了输入与输出的对应关系，帮助模型学习隐含的映射规则
-
示例可以包含边缘case，帮助模型处理特殊情况
3.3 代码示例
import openai
import os
openai.api_key = os.getenv("OPENAI_API_KEY")
def few_shot_classification(text: str, categories: list) -> str:
"""
使用Few-shot方法进行文本分类
参数:
text: 需要分类的文本
categories: 候选类别列表
返回:
分类结果
"""
# 构建Few-shot Prompt：包含指令、示例和待分类文本
prompt = f"""请将输入文本分类到以下类别之一：{', '.join(categories)}
## 示例
输入：这部电影的特效简直震撼人心
输出：正面
输入：产品体验极差，等了两周才收到货
输出：负面
输入：今天天气不错，适合出门散步
输出：中性
## 待分类文本
输入：{text}
输出："""
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "你是一个专业的文本分类助手。"},
{"role": "user", "content": prompt}
],
temperature=0.0, # Few-shot分类通常用低温度保证一致性
max_tokens=50
)
return response.choices[0].message.content.strip()
# 示例：多类别分类
if __name__ == "__main__":
categories = ["科技", "娱乐", "体育", "财经", "教育"]
text = "苹果发布新一代iPhone，搭载全新A18芯片"
result = few_shot_classification(text, categories)
print(f"分类结果: {result}")3.4 示例选择技巧
Few-shot的效果高度依赖示例的质量，选择示例时需注意：
多样性原则：示例应覆盖不同类型和边界情况
def build_diverse_few_shot_prompt(task_type: str) -> str:
"""
构建多样化的Few-shot示例
覆盖正面、负面、中性等多种情况
"""
prompt = f"""请判断以下文本的情感类型：正面、负面、中性
## 示例（覆盖多种情况）
示例1：
输入：太棒了！终于抢到了演唱会的门票！
输出：正面
示例2：
输入：这家店的服务态度极差，再也不会来了
输出：负面
示例3：
输入：明天预计会有小雨，出行请带伞
输出：中性
示例4（包含否定词，需要仔细理解）：
输入：虽然价格不便宜，但质量确实不错
输出：正面
示例5（讽刺句式，边界情况）：
输入：呵呵，这就是所谓的'高端'产品？
输出：负面
## 请判断以下文本：
输入：{task_type}
输出："""
return prompt相关性原则：示例应与待处理文本在主题或风格上相近
def build_relevant_few_shot_prompt(domain: str, input_text: str) -> str:
"""
根据领域构建相关的Few-shot示例
确保示例与目标文本在领域上保持一致
"""
# 定义不同领域的示例库
examples_db = {
"电商评论": [
("收到商品了，质量很好，物流也很快", "正面"),
("和描述不符，褪色严重", "负面"),
("价格合理，性价比一般", "中性")
],
"医疗咨询": [
("最近总是头痛，需要看医生吗", "需要进一步诊断"),
("轻微感冒，应该注意什么", "建议观察休息"),
("血压偏高，如何控制", "需要生活方式干预")
]
}
# 根据领域获取相关示例
domain_examples = examples_db.get(domain, [])
# 构建Prompt
prompt = f"【领域：{domain}】\n\n示例：\n"
for ex_input, ex_output in domain_examples:
prompt += f"输入：{ex_input}\n输出：{ex_output}\n\n"
prompt += f"输入：{input_text}\n输出："
return prompt四、Chain-of-Thought（CoT）提示
4.1 概念与原理
Chain-of-Thought（思维链，简称CoT）是由Google研究团队于2022年提出的Prompt技术。其核心思想是引导模型在给出最终答案之前，先生成一系列中间推理步骤，从而显著提升复杂推理任务的准确性。
研究表明，CoT之所以有效，是因为：
-
分解复杂性：将复杂问题拆解为多个简单步骤
-
提供可解释性：推理过程透明可见
-
激活相关知识：引导模型调用与问题相关的知识
4.2 Zero-shot CoT
Zero-shot CoT通过在Prompt中加入触发词（如"让我们一步一步思考"）来激活模型的推理能力，无需提供示例。
import openai
import os
openai.api_key = os.getenv("OPENAI_API_KEY")
def zero_shot_cot(question: str) -> dict:
"""
使用Zero-shot CoT进行推理
先生成推理过程，再给出最终答案
"""
# 第一步：生成推理过程
reasoning_prompt = f"""问题：{question}
请一步一步地思考这个问题，并详细分析推理过程。"""
reasoning_response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "你是一个逻辑严谨的问题解决专家。"},
{"role": "user", "content": reasoning_prompt}
],
temperature=0.3,
max_tokens=800
)
reasoning = reasoning_response.choices[0].message.content
# 第二步：基于推理过程给出答案
answer_prompt = f"""基于以下推理过程，请给出问题的最终答案。
推理过程：
{reasoning}
问题：{question}
请给出最终答案，并简要说明理由。"""
answer_response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "你是一个逻辑严谨的问题解决专家。"},
{"role": "user", "content": answer_prompt}
],
temperature=0.3,
max_tokens=300
)
answer = answer_response.choices[0].message.content
return {
"question": question,
"reasoning": reasoning,
"answer": answer
}
# 示例：复杂数学推理
if __name__ == "__main__":
question = "小明有5个苹果，小红给了他3个，小明吃掉了2个，然后把剩下的苹果分给了3个朋友，每个朋友得到相同数量。请问每个朋友得到几个苹果？"
result = zero_shot_cot(question)
print(f"问题：{result['question']}\n")
print(f"推理过程：{result['reasoning']}\n")
print(f"最终答案：{result['answer']}")4.3 Few-shot CoT
Few-shot CoT在Prompt中提供完整的推理示例，让模型学习"先推理、后作答"的问题解决模式。
def few_shot_cot(reasoning_prompt: str) -> str:
"""
使用Few-shot CoT进行复杂推理
提供完整的推理示例作为参考
"""
# Few-shot CoT Prompt模板
cot_prompt = """请通过逐步推理来解决问题。在给出最终答案前，先写出详细的推理步骤。
## 示例1
问题：一个书店有120本书，第一天卖了总数的1/4，第二天卖了剩余的1/3，还剩多少本书？
推理步骤：
1. 第一天卖出的数量：120 × 1/4 = 30本
2. 第一天后剩余：120 - 30 = 90本
3. 第二天卖出的数量：90 × 1/3 = 30本
4. 最终剩余：90 - 30 = 60本
最终答案：60本
## 示例2
问题：小张的年龄是小李的2倍，小李比小王大3岁，小王10岁。小张多少岁？
推理步骤：
1. 小王的年龄：10岁
2. 小李的年龄：10 + 3 = 13岁
3. 小张的年龄：13 × 2 = 26岁
最终答案：26岁
## 请解决以下问题：
问题：{prompt}
推理步骤："""
full_prompt = cot_prompt.format(prompt=reasoning_prompt)
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "你是一个数学问题解决专家，擅长通过分步推理来解决问题。"},
{"role": "user", "content": full_prompt}
],
temperature=0.3,
max_tokens=1000
)
return response.choices[0].message.content
# 示例：复杂逻辑推理
if __name__ == "__main__":
problem = "某个公司有100名员工，65%会游泳，75%会骑自行车，80%会打篮球。至少有多少人同时会这三项运动？"
result = few_shot_cot(problem)
print(f"问题：{problem}\n")
print(f"推理过程与答案：\n{result}")4.4 CoT适用场景
CoT特别适用于以下任务：
-
数学计算：多步骤运算、概率计算
-
逻辑推理：演绎推理、归纳推理
-
代码调试：分析程序错误原因
-
复杂决策：多因素权衡的分析决策
五、结构化Prompt设计
5.1 System Prompt设计
System Prompt是设置模型角色和行为模式的核心，它决定了模型的整体响应风格和专业方向。
def create_system_prompt(role: str, rules: list, constraints: list) -> str:
"""
构建结构化的System Prompt
参数:
role: 角色定义
rules: 行为规则列表
constraints: 约束条件列表
返回:
完整的System Prompt字符串
"""
prompt_parts = [
f"你是一个{role}。",
"",
"## 核心行为规则："
]
for i, rule in enumerate(rules, 1):
prompt_parts.append(f"{i}. {rule}")
prompt_parts.append("")
prompt_parts.append("## 必须遵守的约束：")
for i, constraint in enumerate(constraints, 1):
prompt_parts.append(f"- {constraint}")
return "\n".join(prompt_parts)
# 示例：创建一个代码审查助手
if __name__ == "__main__":
system_prompt = create_system_prompt(
role="专业的Python代码审查助手",
rules=[
"仔细审查代码的性能、可读性和安全性",
"提供具体的改进建议和优化方案",
"对于代码中的问题，指出具体位置和原因"
],
constraints=[
"只提供Python语言相关的建议",
"不修改原始代码，只提出建议",
"使用中文回复"
]
)
print("生成的System Prompt：")
print(system_prompt)5.2 角色扮演Prompt
角色扮演是一种强大的Prompt技术，通过明确设定角色身份来引导模型产生特定风格的输出。
import openai
import os
openai.api_key = os.getenv("OPENAI_API_KEY")
def role_play_completion(
role: str,
role_background: str,
user_query: str,
output_format: str = "自然语言"
) -> str:
"""
角色扮演模式对话
参数:
role: 角色名称
role_background: 角色背景设定
user_query: 用户问题
output_format: 输出格式要求
返回:
角色化回复
"""
prompt = f"""## 角色设定
角色名称：{role}
角色背景：{role_background}
## 回复要求
- 以{role}的身份和语气进行回复
- 回答要符合角色设定
- 输出格式：{output_format}
## 对话历史
用户：{user_query}
{role}的回复："""
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "你是一个角色扮演助手。"},
{"role": "user", "content": prompt}
],
temperature=0.8, # 适当提高温度以增加创意性
max_tokens=1000
)
return response.choices[0].message.content
# 示例：作为技术面试官
if __name__ == "__main__":
result = role_play_completion(
role="资深技术面试官",
role_background="""你是一家大型互联网公司的资深技术面试官，
具有10年以上互联网后端开发经验，
面试过数百位候选人，
擅长考察候选人的算法思维和系统设计能力。
你的风格是专业、严谨，但也会适时给予候选人鼓励和指导。""",
user_query="请介绍一下你在项目中遇到的最大技术挑战是什么？",
output_format="以面试官的口吻进行追问和建议"
)
print(result)5.3 输出格式指定
明确指定输出格式可以大大提高模型的输出可用性，便于后续程序处理。
def structured_output_prompt(
task: str,
output_schema: dict,
input_data: str
) -> str:
"""
结构化输出Prompt设计
参数:
task: 任务描述
output_schema: 输出格式schema，dict类型
input_data: 输入数据
返回:
格式化Prompt
"""
# 将schema转换为描述文本
schema_desc = "\n".join([
f"- {field}: {desc}"
for field, desc in output_schema.items()
])
prompt = f"""{task}
## 输出格式要求
请严格按照以下JSON格式输出，不要包含任何其他内容：
{{
{schema_desc}
}}
## 输入数据
{input_data}
## 输出
"""
return prompt
# 示例：提取结构化信息
if __name__ == "__main__":
schema = {
"姓名": "人物姓名",
"职位": "人物的职位或头衔",
"公司": "人物所在公司或组织",
"主要成就": "1-3条主要成就，用中文顿号分隔"
}
prompt = structured_output_prompt(
task="从以下文本中提取人物的关键信息：",
output_schema=schema,
input_data="""张伟博士是阿里巴巴集团资深算法专家，2008年加入公司，
主导了多项核心技术的研发工作，在人工智能领域发表了20余篇论文，
曾获国家科技进步奖。"""
)
print("Prompt内容：")
print(prompt)六、进阶Prompt技巧
6.1 Tree of Thought（思维树）
思维树（ToT）是对CoT的扩展，它在推理过程中探索多条可能的路径，然后综合比较得出最优解。这种方法特别适用于需要策略规划或创意探索的任务。
from typing import List, Dict
def tree_of_thought(
initial_thought: str,
expand_prompt: str,
num_branches: int = 3,
max_depth: int = 3
) -> Dict:
"""
思维树实现：多路径推理探索
参数:
initial_thought: 初始思考
expand_prompt: 扩展提示模板
num_branches: 每步展开的分支数
max_depth: 最大探索深度
返回:
包含所有推理路径和评估结果的字典
"""
def expand_thought(thought: str, depth: int) -> List[Dict]:
"""递归扩展思维节点"""
if depth >= max_depth:
return [{"thought": thought, "children": [], "score": None}]
# 使用模型生成多个分支
expand_text = expand_prompt.format(
current_thought=thought,
num_options=num_branches
)
# 这里简化处理，实际使用时需要调用LLM API
branches = [
f"{thought} -> 分支{i+1}"
for i in range(num_branches)
]
children = []
for branch in branches:
children.append({
"thought": branch,
"children": expand_thought(branch, depth + 1),
"score": None
})
return children
# 构建思维树
tree = {
"thought": initial_thought,
"children": expand_thought(initial_thought, 0),
"best_path": None
}
return tree
# 示例：解决创意问题
if __name__ == "__main__":
tot = tree_of_thought(
initial_thought="如何提高在线教育平台的用户完课率？",
expand_prompt="针对当前思考'{current_thought}'，提出{num_options}个不同的解决方向或子问题",
num_branches=3,
max_depth=2
)
print("思维树结构：")
print(f"根节点: {tot['thought']}")
print(f"分支数: {len(tot['children'])}")6.2 Prompt链式调用
链式调用将复杂任务分解为多个步骤，每个步骤由不同的Prompt处理，最后将结果串联起来。
import openai
import os
import json
openai.api_key = os.getenv("OPENAI_API_KEY")
class PromptChain:
"""
Prompt链式调用框架
将复杂任务分解为多个处理步骤
"""
def __init__(self):
self.steps = []
self.results = {}
def add_step(self, name: str, prompt_template: str, extract_key: str = None):
"""
添加一个处理步骤
参数:
name: 步骤名称
prompt_template: Prompt模板，支持占位符{previous_result}
extract_key: 从结果中提取的字段名
"""
self.steps.append({
"name": name,
"prompt_template": prompt_template,
"extract_key": extract_key
})
def execute(self, initial_input: str) -> Dict:
"""
执行完整的Prompt链
参数:
initial_input: 初始输入
返回:
包含所有步骤执行结果的字典
"""
current_input = initial_input
context = {"original_input": initial_input}
for step in self.steps:
# 构建当前步骤的Prompt
prompt = step["prompt_template"].format(
previous_result=current_input,
**context
)
# 调用LLM
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "你是一个专业的内容处理助手。"},
{"role": "user", "content": prompt}
],
temperature=0.3,
max_tokens=1000
)
result = response.choices[0].message.content
self.results[step["name"]] = result
current_input = result
# 如果指定了提取字段，保存到context中
if step["extract_key"]:
try:
# 尝试解析JSON
context[step["extract_key"]] = json.loads(result)
except:
context[step["extract_key"]] = result
self.results["final_output"] = current_input
return self.results
# 示例：文章处理流水线
if __name__ == "__main__":
chain = PromptChain()
# 步骤1：提取关键信息
chain.add_step(
name="extract_info",
prompt_template="""从以下文本中提取主要人物、事件和地点，以JSON格式输出：
{previous_result}
输出格式：
{{"人物": [], "事件": "", "地点": ""}}""",
extract_key="info"
)
# 步骤2：生成摘要
chain.add_step(
name="summarize",
prompt_template="""基于以下信息，用50字概括文章主要内容：
{previous_result}""",
extract_key="summary"
)
# 步骤3：生成标签
chain.add_step(
name="tagging",
prompt_template="""基于文章内容，提供3-5个相关标签：
{previous_result}
只输出标签，用逗号分隔，不要其他内容。""",
extract_key="tags"
)
# 执行链式处理
input_text = """2024年10月15日，阿里巴巴集团创始人马云在杭州举行的云栖大会上发表演讲，
探讨了人工智能对未来商业的影响。马云表示，AI技术将深刻改变传统商业模式，
阿里巴巴将继续加大对AI研发的投入。"""
results = chain.execute(input_text)
print("=== 链式处理结果 ===")
for step_name, result in results.items():
if step_name != "final_output":
print(f"\n【{step_name}】\n{result}")6.3 自动Prompt优化
自动Prompt优化通过LLM自身来评估和改进Prompt，形成迭代优化循环。
class AutoPromptOptimizer:
"""
自动Prompt优化器
使用LLM评估和改进Prompt效果
"""
def __init__(self, evaluator_model: str = "gpt-3.5-turbo"):
self.evaluator_model = evaluator_model
def evaluate_prompt(
self,
prompt: str,
test_cases: List[Dict]
) -> Dict:
"""
评估Prompt效果
参数:
prompt: 待评估的Prompt
test_cases: 测试用例列表，每项包含input和expected
返回:
评估结果，包含得分和改进建议
"""
evaluation_prompt = f"""请评估以下Prompt在给定测试用例上的表现：
## 待评估Prompt
{prompt}
## 测试用例
{json.dumps(test_cases, ensure_ascii=False, indent=2)}
## 评估要求
1. 对每个测试用例，分析模型输出的正确性
2. 指出Prompt存在的具体问题
3. 提出具体的改进建议
请以JSON格式输出：
{{"average_score": 分数(0-100), "issues": ["问题列表"], "suggestions": ["改进建议"]}}"""
response = openai.ChatCompletion.create(
model=self.evaluator_model,
messages=[
{"role": "system", "content": "你是一个专业的Prompt评估专家。"},
{"role": "user", "content": evaluation_prompt}
],
temperature=0.3,
max_tokens=800
)
try:
result = json.loads(response.choices[0].message.content)
except:
result = {"error": "解析失败", "raw": response.choices[0].message.content}
return result
def optimize_prompt(
self,
original_prompt: str,
evaluation_result: Dict
) -> str:
"""
根据评估结果优化Prompt
"""
optimization_prompt = f"""请根据以下评估结果优化Prompt：
## 原始Prompt
{original_prompt}
## 评估结果
{json.dumps(evaluation_result, ensure_ascii=False, indent=2)}
## 优化要求
1. 吸收评估建议
2. 保持Prompt的核心意图
3. 使其更清晰、更有效
只输出优化后的Prompt内容，不要其他说明。"""
response = openai.ChatCompletion.create(
model=self.evaluator_model,
messages=[
{"role": "system", "content": "你是一个专业的Prompt工程师。"},
{"role": "user", "content": optimization_prompt}
],
temperature=0.5,
max_tokens=1000
)
return response.choices[0].message.content
# 示例：自动优化流程
if __name__ == "__main__":
optimizer = AutoPromptOptimizer()
# 初始Prompt
original_prompt = "分析这段文本的情绪"
# 测试用例
test_cases = [
{"input": "太开心了！今天收到了心仪公司的offer！", "expected": "正面"},
{"input": "这服务也太差了吧，等了一个小时都没人理", "expected": "负面"},
{"input": "明天预计多云转晴，温度适宜", "expected": "中性"}
]
# 评估
evaluation = optimizer.evaluate_prompt(original_prompt, test_cases)
print(f"评估结果: {evaluation}")
# 优化
if "average_score" in evaluation and evaluation["average_score"] < 80:
optimized = optimizer.optimize_prompt(original_prompt, evaluation)
print(f"\n优化后的Prompt:\n{optimized}")七、使用场景详解
7.1 文本分类
文本分类是LLM应用最广泛的场景之一，结合Few-shot和CoT可以获得高精度分类结果。
import openai
import os
openai.api_key = os.getenv("OPENAI_API_KEY")
class TextClassifier:
"""
多功能文本分类器
支持二分类、多分类、情感分析等
"""
def __init__(self, model: str = "gpt-3.5-turbo"):
self.model = model
def binary_classify(
self,
text: str,
category_a: str,
category_b: str,
definition_a: str = "",
definition_b: str = ""
) -> dict:
"""
二分类任务
参数:
text: 待分类文本
category_a: 类别A名称
category_b: 类别B名称
definition_a: 类别A的定义说明
definition_b: 类别B的定义说明
"""
prompt = f"""请将以下文本分类为'{category_a}'或'{category_b}'。
## 类别定义
{category_a}：{definition_a}
{category_b}：{definition_b}
## 待分类文本
{text}
## 输出要求
只输出分类结果，格式：类别：[A/B]"""
response = openai.ChatCompletion.create(
model=self.model,
messages=[
{"role": "system", "content": "你是一个专业的文本分类器。"},
{"role": "user", "content": prompt}
],
temperature=0.0,
max_tokens=100
)
result = response.choices[0].message.content
return {
"text": text,
"category": category_a if "A" in result else category_b,
"raw_response": result
}
def multi_classify(
self,
text: str,
categories: list,
few_shot_examples: list = None
) -> dict:
"""
多分类任务，支持Few-shot示例
"""
prompt_parts = [f"请将以下文本分类到以下类别之一：{', '.join(categories)}\n"]
# 添加Few-shot示例
if few_shot_examples:
prompt_parts.append("\n## 示例")
for example in few_shot_examples:
prompt_parts.append(f"文本：{example['text']}")
prompt_parts.append(f"类别：{example['category']}\n")
prompt_parts.append(f"\n## 待分类文本\n{text}")
response = openai.ChatCompletion.create(
model=self.model,
messages=[
{"role": "system", "content": "你是一个专业的文本分类器。"},
{"role": "user", "content": "".join(prompt_parts)}
],
temperature=0.0,
max_tokens=100
)
return {
"text": text,
"category": response.choices[0].message.content.strip(),
"raw_response": response.choices[0].message.content
}
# 示例：新闻分类
if __name__ == "__main__":
classifier = TextClassifier()
# 情感分析示例
sentiment = classifier.binary_classify(
text="这款手机拍照效果真的很棒，但是电池续航太差了",
category_a="正面",
category_b="负面",
definition_a="整体评价偏好的评论",
definition_b="整体评价偏差的评论"
)
print(f"情感分析结果: {sentiment}")
# 新闻分类示例
few_shot = [
{"text": "央行宣布降准0.5个百分点", "category": "财经"},
{"text": "欧冠半决赛皇马战胜曼城", "category": "体育"},
{"text": "科学家发现新的系外行星", "category": "科技"}
]
news = classifier.multi_classify(
text="特斯拉发布新一代自动驾驶系统",
categories=["财经", "体育", "科技", "娱乐", "教育"],
few_shot_examples=few_shot
)
print(f"新闻分类结果: {news}")7.2 内容生成
LLM在内容生成领域有着广泛应用，包括文章写作、营销文案、产品描述等。
def content_generation_prompt(
content_type: str,
topic: str,
target_audience: str,
tone: str,
length: str,
key_points: list = None
) -> str:
"""
构建内容生成的Prompt模板
"""
prompt = f"""请创作一篇{content_type}，要求如下：
## 基本信息
- 主题：{topic}
- 目标受众：{target_audience}
- 语气风格：{tone}
- 字数要求：{length}
"""
if key_points:
prompt += f"\n## 需要涵盖的要点\n"
for point in key_points:
prompt += f"- {point}\n"
prompt += "\n请直接输出内容，不要包含标题说明。"
return prompt
# 示例：生成营销文案
if __name__ == "__main__":
prompt = content_generation_prompt(
content_type="产品营销文案",
topic="某品牌新款无线蓝牙耳机",
target_audience="25-35岁的都市白领",
tone="专业但不失活力，突出科技感",
length="300字左右",
key_points=[
"主动降噪功能",
"30小时超长续航",
"佩戴舒适稳固",
"支持无线充电"
]
)
print("营销文案Prompt：")
print(prompt)7.3 代码开发
LLM在代码开发中的应用主要包括代码生成、代码审查、bug修复等。
import openai
import os
openai.api_key = os.getenv("OPENAI_API_KEY")
class CodeAssistant:
"""
代码开发助手
支持代码生成、解释、审查等功能
"""
def __init__(self, model: str = "gpt-3.5-turbo"):
self.model = model
def generate_code(
self,
task_description: str,
language: str,
requirements: list = None
) -> str:
"""
根据描述生成代码
"""
prompt = f"""请用{language}实现以下功能：
## 功能描述
{task_description}
"""
if requirements:
prompt += "\n## 具体要求\n"
for req in requirements:
prompt += f"- {req}\n"
prompt += "\n## 代码要求\n"
prompt += "- 代码完整可运行\n"
prompt += "- 添加必要的注释说明\n"
prompt += "- 注意代码规范和最佳实践\n"
response = openai.ChatCompletion.create(
model=self.model,
messages=[
{"role": "system", "content": "你是一个专业的软件开发工程师。"},
{"role": "user", "content": prompt}
],
temperature=0.3,
max_tokens=2000
)
return response.choices[0].message.content
def explain_code(self, code: str) -> str:
"""
解释代码功能
"""
prompt = f"""请详细解释以下代码的功能和工作原理：
```{code}解释要求
-
说明代码的整体功能
-
解释关键代码段的作用
-
分析代码的时间/空间复杂度（如适用）
-
指出代码的优点和可能的改进点"""
response = openai.ChatCompletion.create( model=self.model, messages=[ {"role": "system", "content": "你是一个专业的软件开发工程师。"}, {"role": "user", "content": prompt} ], temperature=0.3, max_tokens=1500 ) return response.choices[0].message.contentdef debug_code(self, code: str, error_description: str) -> dict: """ 调试代码问题 """ prompt = f"""请分析以下代码的问题并提供修复方案：
错误描述
{error_description}
代码
分析要求
-
定位问题所在
-
分析问题原因
-
提供修复后的代码
-
说明修复原理"""
response = openai.ChatCompletion.create( model=self.model, messages=[ {"role": "system", "content": "你是一个专业的软件开发工程师。"}, {"role": "user", "content": prompt} ], temperature=0.3, max_tokens=1500 ) return {"analysis": response.choices[0].message.content}
示例：生成数据处理代码
if name == "main": assistant = CodeAssistant()
# 生成Python数据处理代码
code = assistant.generate_code(
task_description="读取CSV文件，进行数据清洗后输出统计结果",
language="Python",
requirements=[
"使用pandas库",
"处理缺失值和异常值",
"计算各列的均值、中位数、标准差",
"输出结果保存为新的CSV文件"
]
)
print("生成的代码：")
print(code)
### 7.4 数据分析
LLM可以辅助进行数据分析报告生成、数据解读等工作。
```python
import openai
import os
import json
openai.api_key = os.getenv("OPENAI_API_KEY")
class DataAnalysisAssistant:
"""
数据分析助手
辅助进行数据解读和报告生成
"""
def __init__(self, model: str = "gpt-3.5-turbo"):
self.model = model
def generate_analysis_report(
self,
data_summary: dict,
business_context: str = ""
) -> str:
"""
基于数据摘要生成分析报告
参数:
data_summary: 数据摘要字典，包含字段统计信息
business_context: 业务背景说明
"""
prompt = f"""请基于以下数据摘要生成一份分析报告：
## 业务背景
{business_context if business_context else '未提供'}
## 数据摘要
{json.dumps(data_summary, ensure_ascii=False, indent=2)}
## 报告要求
1. 总结数据的主要发现
2. 指出值得关注的数据特征或异常
3. 提供初步的数据洞察
4. 如有建议，也请一并提出
请以专业的分析报告格式输出。"""
response = openai.ChatCompletion.create(
model=self.model,
messages=[
{"role": "system", "content": "你是一个专业的数据分析师。"},
{"role": "user", "content": prompt}
],
temperature=0.3,
max_tokens=2000
)
return response.choices[0].message.content
def suggest_visualization(
self,
data_description: str,
analysis_goal: str
) -> list:
"""
推荐适合的图表类型
"""
prompt = f"""基于以下数据描述和分析目标，推荐合适的可视化方案：
## 数据描述
{data_description}
## 分析目标
{analysis_goal}
## 输出格式
请推荐3-5种适合的可视化方式，以JSON数组格式输出：
[{{"chart_type": "图表类型", "reason": "推荐理由", "applicable_to": "适用场景"}}]"""
response = openai.ChatCompletion.create(
model=self.model,
messages=[
{"role": "system", "content": "你是一个专业的数据可视化专家。"},
{"role": "user", "content": prompt}
],
temperature=0.3,
max_tokens=1000
)
try:
suggestions = json.loads(response.choices[0].message.content)
except:
suggestions = response.choices[0].message.content
return suggestions
# 示例：销售数据分析
if __name__ == "__main__":
assistant = DataAnalysisAssistant()
# 模拟数据摘要
data_summary = {
"记录数": 10000,
"时间范围": "2024年1月-6月",
"字段": {
"销售额": {"均值": 1500, "中位数": 1200, "标准差": 800, "范围": [100, 5000]},
"订单量": {"均值": 50, "中位数": 45, "标准差": 20},
"客户数": {"唯一值": 2000},
"转化率": {"均值": "3.5%", "中位数": "3.2%"}
},
"关键发现": [
"Q2销售额环比增长15%",
"客单价呈上升趋势",
"周末订单量显著高于工作日"
]
}
report = assistant.generate_analysis_report(
data_summary=data_summary,
business_context="某电商平台的2024年上半年销售数据，需要评估业绩表现并制定下半年策略"
)
print("分析报告：")
print(report)八、LangChain PromptTemplate实战
LangChain是当前最流行的LLM应用开发框架之一，其PromptTemplate模块提供了强大的Prompt管理能力。
8.1 基础PromptTemplate使用
# 需要先安装：pip install langchain langchain-openai
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
import os
# 设置API密钥
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
def basic_prompt_template_demo():
"""
基础PromptTemplate使用示例
"""
# 创建简单模板
simple_template = PromptTemplate(
input_variables=["topic", "style"],
template="请用{style}风格写一篇关于{topic}的文章，要求字数500字左右。"
)
# 格式化模板
formatted_prompt = simple_template.format(
topic="人工智能",
style="专业且通俗易懂"
)
print("格式化后的Prompt：")
print(formatted_prompt)
# 调用LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
response = llm.invoke(formatted_prompt)
print("\n模型回复：")
print(response.content)
if __name__ == "__main__":
basic_prompt_template_demo()8.2 Few-shot PromptTemplate
from langchain.prompts import FewShotPromptTemplate, PromptTemplate
from langchain_openai import ChatOpenAI
import os
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
def few_shot_prompt_template_demo():
"""
Few-shot PromptTemplate示例
展示如何使用示例来引导模型输出
"""
# 定义示例
examples = [
{
"input": "这部电影太精彩了！",
"output": "正面"
},
{
"input": "服务态度太差，等了半小时都没人理",
"output": "负面"
},
{
"input": "明天预计有小雨，记得带伞",
"output": "中性"
}
]
# 创建示例模板
example_prompt = PromptTemplate(
input_variables=["input", "output"],
template="输入：{input}\n输出：{output}"
)
# 创建Few-shot模板
few_shot_prompt = FewShotPromptTemplate(
examples=examples,
example_prompt=example_prompt,
prefix="请将以下文本的情感分类为：正面、负面、中性",
suffix="输入：{input_text}\n输出：",
input_variables=["input_text"]
)
# 格式化
formatted = few_shot_prompt.format(input_text="这个产品性价比很高，推荐购买！")
print("Few-shot Prompt：")
print(formatted)
# 调用LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.0)
response = llm.invoke(formatted)
print("\n分类结果：")
print(response.content)
if __name__ == "__main__":
few_shot_prompt_template_demo()8.3 链式PromptTemplate
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
import os
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
def chain_prompt_template_demo():
"""
链式PromptTemplate示例
展示如何串联多个处理步骤
"""
# 第一步：提取关键信息
extraction_template = PromptTemplate(
input_variables=["text"],
template="""从以下文本中提取关键实体和信息：
{text}
提取：人名、地点、事件、日期（用JSON格式输出）"""
)
# 第二步：生成摘要
summary_template = PromptTemplate(
input_variables=["text", "extracted_info"],
template="""基于以下原文和提取的关键信息，写一段简洁的摘要：
原文：{text}
提取的信息：{extracted_info}
摘要要求：
- 50字以内
- 包含关键信息
- 语言简洁准确"""
)
# 第三步：生成标签
tagging_template = PromptTemplate(
input_variables=["summary"],
template="""基于以下摘要，生成3-5个相关标签：
摘要：{summary}
标签要求：
- 用逗号分隔
- 每个标签不超过4个字
- 只输出标签，不要其他内容"""
)
# 创建LLM链
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.3)
# 创建各个处理链
extraction_chain = LLMChain(llm=llm, prompt=extraction_template)
summary_chain = LLMChain(llm=llm, prompt=summary_template)
tagging_chain = LLMChain(llm=llm, prompt=tagging_template)
# 示例文本
input_text = """2024年10月20日，华为在深圳举办了年度开发者大会，
会上发布了新一代鸿蒙操作系统。余承东表示，鸿蒙生态设备数已突破8亿台，
成为全球第三大移动操作系统。"""
# 执行链式处理
print("输入文本：")
print(input_text)
print("\n" + "="*50 + "\n")
# 第一步：提取
extracted = extraction_chain.invoke({"text": input_text})
print("【步骤1：信息提取】")
print(extracted["text"])
print()
# 第二步：摘要
summary = summary_chain.invoke({
"text": input_text,
"extracted_info": extracted["text"]
})
print("【步骤2：生成摘要】")
print(summary["text"])
print()
# 第三步：打标签
tags = tagging_chain.invoke({"summary": summary["text"]})
print("【步骤3：生成标签】")
print(tags["text"])
if __name__ == "__main__":
chain_prompt_template_demo()九、Prompt工程最佳实践
9.1 设计原则
清晰明确：Prompt中的指令和上下文应当清晰明了，避免歧义。
# 不推荐
prompt_v1 = "分析一下"
# 推荐
prompt_v2 = """请分析以下销售数据的三个关键指标：
1. 整体销售趋势（上升/下降/平稳）
2. 主要增长/下降原因
3. 潜在风险点
数据：[具体数据内容]"""结构化组织：合理组织Prompt结构，使用分隔符、编号等增强可读性。
def structured_prompt_demo():
"""结构化Prompt示例"""
return """
## 任务
[明确说明要完成什么任务]
## 背景信息
[提供必要的上下文]
## 约束条件
- 条件1
- 条件2
## 输入数据
[具体数据]
## 输出要求
[期望的输出格式]
"""适当限制：通过明确的约束条件引导模型输出，避免无关内容。
9.2 常见问题与解决方案
| 问题 | 原因 | 解决方案 |
|---|---|---|
| 输出格式不稳定 | 缺少明确格式要求 | 使用CoT或Few-shot明确示例 |
| 理解偏差 | 指令不够清晰 | 分解任务，提供更具体的指导 |
| 创造性不足 | 温度设置过低 | 适当提高temperature参数 |
| 回答过于冗长 | 缺少长度限制 | 明确指定字数或详细程度 |
| 推理错误 | 复杂任务缺乏引导 | 使用CoT技术分解推理过程 |
9.3 Prompt迭代优化流程
def prompt_optimization_loop():
"""
Prompt优化迭代流程
"""
optimization_steps = [
"1. 明确任务目标：确定需要完成的具体任务",
"2. 设计初始Prompt：基于最佳实践编写初始版本",
"3. 测试评估：使用多样化的测试用例进行评估",
"4. 分析问题：识别输出中的错误模式和不足",
"5. 针对性优化：根据问题调整Prompt设计",
"6. 迭代改进：重复测试-分析-优化循环",
"7. 验证泛化：在更多样化的用例上验证效果"
]
return "\n".join(optimization_steps)
if __name__ == "__main__":
print("Prompt优化流程：")
print(prompt_optimization_loop())十、总结
Prompt工程是LLM应用开发中最基础也是最重要的技能之一。本文系统介绍了从基础的Zero-shot、Few-shot到进阶的CoT、自动优化等核心技术，并提供了丰富的Python代码示例。
核心要点回顾：
-
Zero-shot适合简单明确的任务，是最基本的Prompt方式
-
Few-shot通过示例增强上下文学习，适合需要特定格式输出的任务
-
Chain-of-Thought引导模型分步推理，显著提升复杂推理任务的效果
-
结构化Prompt通过角色设定、格式指定等方式提高输出质量
-
LangChain等框架提供了便捷的Prompt管理和调用能力
在实际应用中，Prompt工程需要根据具体任务特点进行灵活调整和优化。建议开发者在实践中不断积累经验，形成自己的Prompt设计方法论。