Python_PromptEngineering终极指南

⚙️ Prompt Engineering 终极指南：让大模型输出质量提升 300% 的核心技巧

🌸你好呀！我是 lbb小魔仙
🌟 感谢陪伴～小白博主在线求友
🌿 跟着小白学Linux/Java/Python
📖 专栏汇总：
《Linux》专栏 | 《Java》专栏 | 《Python》专栏

[⚙️ Prompt Engineering 终极指南：让大模型输出质量提升 300% 的核心技巧](#⚙️ Prompt Engineering 终极指南：让大模型输出质量提升 300% 的核心技巧)
- [📌 前言](#📌 前言)
- [一、Prompt 基础原理 🧠](#一、Prompt 基础原理 🧠)
- - [1.1 模型是如何"理解"你的 Prompt 的？](#1.1 模型是如何"理解"你的 Prompt 的？)
  - [1.2 Prompt 的四个组成要素](#1.2 Prompt 的四个组成要素)
- [二、六大核心技巧 🎯](#二、六大核心技巧 🎯)
- - 技巧一：明确性原则------越具体越好
  - 技巧二：分步拆解------大任务切小任务
测试
- - 技巧四：负面约束------告诉模型不要做什么
  - 技巧五：示例引导------给模型看"样本"
  - [技巧六：迭代优化------用模型改进 Prompt](#技巧六：迭代优化——用模型改进 Prompt)
- [三、思维链（CoT）提示 🔗](#三、思维链（CoT）提示 🔗)
- - [高级 CoT：树状思维（ToT）](#高级 CoT：树状思维（ToT）)
- [四、Few-Shot 示例学习 📚](#四、Few-Shot 示例学习 📚)
- [五、角色扮演与人设塑造 🎭](#五、角色扮演与人设塑造 🎭)
- [六、结构化输出控制 📋](#六、结构化输出控制 📋)
- - [6.1 Pydantic + 结构化输出](#6.1 Pydantic + 结构化输出)
测试
- [八、Prompt 模板工程化 🏗️](#八、Prompt 模板工程化 🏗️)
使用
填充模板
- [十、避坑指南：常见错误与修复 ⚠️](#十、避坑指南：常见错误与修复 ⚠️)
- - 常见错误汇总表
- [总结 🌟](#总结 🌟)
- - [Prompt 质量自检清单 ✅](#Prompt 质量自检清单 ✅)
  - [Prompt 能力成长路径 🗺️](#Prompt 能力成长路径 🗺️)
- [💬 互动区](#💬 互动区)
- [📎 参考资料](#📎 参考资料)

📌 前言

你有没有这样的经历？

🤦 同样的问题，有人得到精准答案，你得到的却是废话连篇
😤 大模型总是答非所问，反复修改提示词却不知从哪改起
🤯 看到别人分享的神奇效果，自己试了根本复现不了

差距就在 Prompt。

Prompt Engineering（提示词工程）是与大模型打交道的核心技能。掌握它，你能把模型的输出质量提升 3 倍不止。

本文系统梳理从基础到高级的 Prompt 技巧，全部配有 Python 代码和效果对比，让你彻底弄清楚怎么写出好 Prompt。

一、Prompt 基础原理 🧠

1.1 模型是如何"理解"你的 Prompt 的？

复制代码

你的 Prompt → Token 化 → 注意力计算 → 预测下一个 Token → 输出

关键认知：

模型不理解语义，只做统计预测------"这段话后面最可能是什么"
越具体的 Prompt，缩小的预测空间越小，答案越精准
模型会倾向于迎合你------你怎么问，它就怎么答

1.2 Prompt 的四个组成要素

python 复制代码

PROMPT_ANATOMY = """
┌─────────────────────────────────────────┐
│  一个好的 Prompt 通常包含：              │
│                                         │
│  1. 角色（Role）    → 你是谁             │
│  2. 任务（Task）    → 做什么             │
│  3. 背景（Context） → 已知信息           │
│  4. 格式（Format）  → 怎么输出           │
└─────────────────────────────────────────┘
"""

python 复制代码

# 设置工具函数
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com/v1"
)

def ask(prompt: str, system: str = None, model: str = "deepseek-chat") -> str:
    """统一调用接口"""
    messages = []
    if system:
        messages.append({"role": "system", "content": system})
    messages.append({"role": "user", "content": prompt})
    
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=0.7,
    )
    return response.choices[0].message.content

二、六大核心技巧 🎯

技巧一：明确性原则------越具体越好

python 复制代码

# ❌ 模糊的 Prompt
bad_prompt = "帮我写一篇文章"

# ✅ 具体的 Prompt
good_prompt = """
请写一篇关于"Python 异步编程"的技术博客文章。

要求：
- 目标读者：有 1-2 年 Python 经验的开发者
- 字数：800-1000 字
- 结构：包含概念介绍、async/await 基础、实战示例、常见坑
- 风格：技术准确、通俗易懂，适当加入代码示例
"""

print(ask(good_prompt))

效果对比：

指标	模糊 Prompt	具体 Prompt
回答相关性	⭐⭐	⭐⭐⭐⭐⭐
结构完整性	⭐⭐	⭐⭐⭐⭐⭐
代码示例	无	有
是否需要反复修改	多次	基本一次到位

技巧二：分步拆解------大任务切小任务

python 复制代码

# ❌ 一口气要太多
bad = "帮我分析这段代码的问题，给出优化方案，并用更好的方式重写"

# ✅ 分步完成
def analyze_code_step_by_step(code: str) -> dict:
    results = {}
    
    # Step 1：问题识别
    results["issues"] = ask(f"""
请分析以下 Python 代码，列出所有问题（包括 Bug、性能问题、代码风格）：

```python
{code}

以 Markdown 列表格式输出，按严重程度排序。

""")

复制代码

# Step 2：优化方案
results["plan"] = ask(f"""

基于以下代码问题，给出具体的优化方案：

代码：

python 复制代码

{code}

发现的问题：

{results['issues']}

请为每个问题提供具体的解决方案，不要直接给出代码。

""")

复制代码

# Step 3：重写代码
results["rewritten"] = ask(f"""

请根据以下优化方案，重写这段 Python 代码：

原始代码：

python 复制代码

{code}

优化方案：

{results['plan']}

要求：只输出重写后的代码，加必要注释。

""")

复制代码

return results

测试

messy_code = """

def get_data(data):

result = []

for i in range(len(data)):

if data[i] > 0:

result.append(data[i] * 2)

return result

"""

analysis = analyze_code_step_by_step(messy_code)

print("🔍 发现的问题：\n", analysis["issues"])

print("\n📋 优化方案：\n", analysis["plan"])

print("\n✅ 重写代码：\n", analysis["rewritten"])

复制代码

---

### 技巧三：格式约束------规定输出格式

```python
# 强制 JSON 输出
def extract_info_as_json(text: str) -> dict:
    import json
    
    prompt = f"""
请从以下文本中提取关键信息，**必须返回合法的 JSON 格式**，不要有任何其他内容：

文本：
{text}

返回 JSON 格式（严格遵守）：
{{
    "人名": ["姓名1", "姓名2"],
    "地点": ["地点1", "地点2"],
    "时间": ["时间1", "时间2"],
    "事件摘要": "一句话总结"
}}
"""
    
    raw = ask(prompt)
    
    # 提取 JSON 部分（防止模型输出额外文字）
    start = raw.find("{")
    end = raw.rfind("}") + 1
    
    try:
        return json.loads(raw[start:end])
    except json.JSONDecodeError:
        return {"error": "解析失败", "raw": raw}


# 强制 Markdown 表格输出
def compare_technologies(tech_list: list) -> str:
    prompt = f"""
对比以下技术，输出 Markdown 格式的对比表格：
技术列表：{', '.join(tech_list)}

表格列：技术名称 | 主要用途 | 优点 | 缺点 | 适用场景 | 学习难度(1-5)

只输出表格，不要其他内容。
"""
    return ask(prompt)


result = compare_technologies(["FastAPI", "Django", "Flask", "Tornado"])
print(result)

技巧四：负面约束------告诉模型不要做什么

python 复制代码

# ✅ 同时使用正面和负面约束
summary_prompt = """
请总结以下文章的核心观点：

{article}

要求（必须遵守）：
✅ 用 3-5 条要点列出核心观点
✅ 每条不超过 50 字
✅ 使用作者的原意，不要过度诠释

❌ 不要加个人观点或评价
❌ 不要使用"该文章认为""作者认为"等冗余表达
❌ 不要出现"总的来说""综上所述"等套话
❌ 不要超过 250 字
"""

技巧五：示例引导------给模型看"样本"

python 复制代码

# Few-shot：提供示例来定义输出风格
few_shot_prompt = """
请将用户评论的情感分类为：正面、负面、中性。

示例：
输入：这款手机真的太好用了，拍照效果超级棒！
输出：正面

输入：收到货发现有划痕，客服也不给力，差评！
输出：负面

输入：就正常快递速度，包装还行。
输出：中性

现在请分类：
输入：{comment}
输出："""

comments = [
    "电池续航有点短，但屏幕效果确实不错",
    "完全是虚假宣传，骗人的！",
    "一般般，没什么特别的"
]

for comment in comments:
    result = ask(few_shot_prompt.format(comment=comment))
    print(f"评论：{comment}")
    print(f"情感：{result.strip()}\n")

技巧六：迭代优化------用模型改进 Prompt

python 复制代码

def self_improve_prompt(original_prompt: str, task_description: str) -> str:
    """让模型帮你优化 Prompt"""
    
    meta_prompt = f"""
你是一个专业的 Prompt 工程师。请优化以下 Prompt，使其更清晰、更有效。

任务描述：{task_description}

原始 Prompt：
---
{original_prompt}
---

请提供：
1. 优化后的 Prompt（直接可用）
2. 改进说明（简述做了哪些优化及原因）

格式：
【优化后的 Prompt】
（在此写优化后的内容）

【改进说明】
（在此写改进说明）
"""
    
    return ask(meta_prompt)

三、思维链（CoT）提示 🔗

Chain-of-Thought 让模型一步步推理，大幅提升复杂问题的准确率。

python 复制代码

# ❌ 直接问答（复杂问题容易出错）
direct_answer = ask("一家工厂有 120 名工人，完成一批货物需要 45 天。现在要求提前 15 天完成，需要增加多少工人？")

# ✅ CoT：引导逐步推理
cot_prompt = """
请一步步思考，解决以下数学问题：

题目：一家工厂有 120 名工人，完成一批货物需要 45 天。现在要求提前 15 天完成，需要增加多少工人？

思考过程：
第一步：计算总工作量
第二步：计算新的完成天数
第三步：计算需要的工人数
第四步：计算需要增加的工人数

请按以上步骤逐步计算，最后给出答案。
"""

cot_answer = ask(cot_prompt)
print(cot_answer)


# 零样本 CoT（Zero-Shot CoT）：最简单的魔法词
zero_shot_cot = ask("""
一家工厂有 120 名工人，完成一批货物需要 45 天。现在要求提前 15 天完成，需要增加多少工人？

让我们一步一步思考：
""")

💡 实验结论：在逻辑推理题上，加入"让我们一步一步思考"后，GPT-4 的准确率从 54% 提升到 82%（论文数据）

高级 CoT：树状思维（ToT）

python 复制代码

def tree_of_thought(problem: str, branches: int = 3) -> str:
    """
    树状思维：让模型生成多个解题路径，选最优
    """
    
    # Step 1: 生成多个解题思路
    generate_prompt = f"""
请针对以下问题，提出 {branches} 种不同的解决思路（每种思路 2-3 句话概述）：

问题：{problem}

格式：
思路1：...
思路2：...
思路3：...
"""
    thoughts = ask(generate_prompt)
    
    # Step 2: 评估各思路的可行性
    evaluate_prompt = f"""
请评估以下 {branches} 种解题思路，并选出最优方案：

问题：{problem}

各种思路：
{thoughts}

请给出：
1. 每种思路的优缺点评分（1-10分）
2. 最推荐的思路及理由
3. 基于最优思路的完整解决方案
"""
    
    return ask(evaluate_prompt)


# 测试
result = tree_of_thought("如何设计一个高并发的 Python Web API，每秒处理 10万 请求？")
print(result)

四、Few-Shot 示例学习 📚

python 复制代码

from typing import List, Tuple

class FewShotPrompter:
    """Few-Shot 提示词构建器"""
    
    def __init__(self, task_description: str, output_format: str = ""):
        self.task_description = task_description
        self.output_format = output_format
        self.examples: List[Tuple[str, str]] = []
    
    def add_example(self, input_text: str, output_text: str):
        """添加示例"""
        self.examples.append((input_text, output_text))
        return self  # 支持链式调用
    
    def build(self, new_input: str) -> str:
        """构建完整的 Few-Shot Prompt"""
        prompt_parts = [self.task_description]
        
        if self.output_format:
            prompt_parts.append(f"\n输出格式：{self.output_format}\n")
        
        if self.examples:
            prompt_parts.append("\n--- 示例 ---")
            for i, (inp, out) in enumerate(self.examples, 1):
                prompt_parts.append(f"\n示例 {i}：")
                prompt_parts.append(f"输入：{inp}")
                prompt_parts.append(f"输出：{out}")
        
        prompt_parts.append("\n--- 现在请处理 ---")
        prompt_parts.append(f"输入：{new_input}")
        prompt_parts.append("输出：")
        
        return "\n".join(prompt_parts)
    
    def run(self, new_input: str) -> str:
        """构建并执行"""
        prompt = self.build(new_input)
        return ask(prompt)


# 使用示例：构建中英互译器（带术语表）
translator = FewShotPrompter(
    task_description="你是一位专业的技术文档翻译员，请将英文翻译为专业的中文。",
    output_format="直接输出翻译结果，不要解释"
)

# 添加示例，教会模型如何处理专业术语
translator.add_example(
    "The model uses a transformer architecture with self-attention mechanism.",
    "该模型采用带有自注意力机制的 Transformer 架构。"
)
translator.add_example(
    "Fine-tuning allows the pretrained model to adapt to downstream tasks.",
    "微调（Fine-tuning）使预训练模型能够适应下游任务。"
)

result = translator.run(
    "The retrieval-augmented generation combines dense retrieval with language model generation."
)
print(result)
# 输出：检索增强生成（RAG）将密集检索与语言模型生成相结合。

五、角色扮演与人设塑造 🎭

python 复制代码

# System Prompt 是角色设定的最佳位置
EXPERT_ROLES = {
    "python_mentor": """
你是一位有 10 年经验的 Python 高级工程师，专注于性能优化和架构设计。
- 回答简洁有力，直击要点
- 总是给出可运行的代码示例
- 主动指出常见陷阱和最佳实践
- 遇到不确定的内容，明确说明不确定
""",
    
    "code_reviewer": """
你是一位严格的代码审查员，负责提升代码质量。
审查维度：
1. 正确性（逻辑是否正确）
2. 可读性（命名、注释、结构）
3. 性能（时间复杂度、内存使用）
4. 安全性（SQL注入、XSS等）
5. 可维护性（测试覆盖、文档）

每个问题都要指出：问题所在、严重程度（P0/P1/P2）、修复建议。
""",
    
    "data_analyst": """
你是一位数据分析专家，擅长从数据中发现洞察。
- 用数据说话，避免主观臆断
- 总是关注数据质量和异常值
- 可视化建议要具体（图表类型、轴设置）
- 结论需要统计支撑
""",
    
    "product_manager": """
你是一位有互联网背景的产品经理，擅长需求分析和功能规划。
- 以用户价值为核心
- 考虑 MVP 最小可行产品
- 关注技术可行性和商业逻辑
- 善用 STAR / MECE 等框架
"""
}


def role_ask(role: str, question: str) -> str:
    """使用特定角色回答问题"""
    system = EXPERT_ROLES.get(role, "你是一个专业助手。")
    return ask(question, system=system)


# 对同一个问题，用不同角色分析
question = "我们的 Python Web 服务响应时间从 100ms 增加到了 800ms，如何排查？"

print("=== Python 工程师视角 ===")
print(role_ask("python_mentor", question))

print("\n=== 代码审查员视角 ===")
print(role_ask("code_reviewer", f"请从代码质量角度给建议：{question}"))

六、结构化输出控制 📋

6.1 Pydantic + 结构化输出

python 复制代码

from pydantic import BaseModel, Field
from typing import List, Optional
import json


class CodeReview(BaseModel):
    """代码审查结果"""
    overall_score: int = Field(description="总体评分 1-10", ge=1, le=10)
    summary: str = Field(description="一句话总结")
    issues: List[dict] = Field(description="问题列表，每项含 type/severity/description/fix")
    suggestions: List[str] = Field(description="优化建议列表")
    rewrite_needed: bool = Field(description="是否需要重写")


def structured_code_review(code: str) -> CodeReview:
    """返回结构化的代码审查结果"""
    
    schema = CodeReview.model_json_schema()
    
    prompt = f"""
请审查以下 Python 代码，返回 JSON 格式的审查报告。

代码：
```python
{code}

严格按照以下 JSON Schema 返回（只返回 JSON）：

{json.dumps(schema, ensure_ascii=False, indent=2)}

"""

复制代码

raw = ask(prompt)

# 提取并解析 JSON
start = raw.find("{")
end = raw.rfind("}") + 1
data = json.loads(raw[start:end])

return CodeReview(**data)

测试

sample_code = """

import mysql.connector

def get_user(username):

conn = mysql.connector.connect(host='localhost', user='root', password='123456', database='mydb')

cursor = conn.cursor()

query = "SELECT * FROM users WHERE username = '" + username + "'"

cursor.execute(query)

return cursor.fetchall()

"""

review = structured_code_review(sample_code)

print(f"评分：{review.overall_score}/10")

print(f"总结：{review.summary}")

print(f"问题数：{len(review.issues)}")

print(f"需要重写：{review.rewrite_needed}")

复制代码

---

## 七、对话管理与上下文优化 💬

```python
from collections import deque
from typing import Optional


class ConversationManager:
    """智能对话管理器（自动控制 Token 上限）"""
    
    def __init__(
        self,
        system_prompt: str,
        max_tokens: int = 4000,
        model: str = "deepseek-chat"
    ):
        self.system_prompt = system_prompt
        self.max_tokens = max_tokens
        self.model = model
        self.history = deque()  # 使用双端队列，方便从头部删除
        self.total_chars = 0
    
    def _estimate_tokens(self, text: str) -> int:
        """粗略估算 Token 数（中文约 1.5字/token，英文约 4字/token）"""
        chinese_chars = sum(1 for c in text if '\u4e00' <= c <= '\u9fff')
        other_chars = len(text) - chinese_chars
        return int(chinese_chars / 1.5 + other_chars / 4)
    
    def _trim_history(self):
        """当超出 Token 限制时，删除最早的消息"""
        while (self.total_chars > self.max_tokens * 3 and  # 字符数粗略对应
               len(self.history) > 2):  # 至少保留最近 1 轮对话
            removed = self.history.popleft()
            self.total_chars -= len(removed["content"])
    
    def chat(self, user_input: str) -> str:
        """发送消息"""
        # 添加用户消息
        self.history.append({"role": "user", "content": user_input})
        self.total_chars += len(user_input)
        
        # 修剪历史（控制 Token）
        self._trim_history()
        
        # 构建请求
        messages = [{"role": "system", "content": self.system_prompt}]
        messages.extend(list(self.history))
        
        response = client.chat.completions.create(
            model=self.model,
            messages=messages,
            temperature=0.7,
        )
        
        reply = response.choices[0].message.content
        
        # 记录助手回复
        self.history.append({"role": "assistant", "content": reply})
        self.total_chars += len(reply)
        
        return reply
    
    def clear(self):
        """清空对话历史"""
        self.history.clear()
        self.total_chars = 0
    
    @property
    def turn_count(self) -> int:
        return len(self.history) // 2


# 使用示例
bot = ConversationManager(
    system_prompt="你是一位 Python 编程导师，帮助学生学习 Python。保持耐心，循循善诱。",
    max_tokens=3000
)

# 多轮对话
questions = [
    "什么是装饰器？",
    "能给我一个实际的例子吗？",
    "那 functools.wraps 是干什么用的？",
]

for q in questions:
    print(f"\n👤 用户：{q}")
    reply = bot.chat(q)
    print(f"🤖 助手：{reply[:300]}...")  # 截断显示

八、Prompt 模板工程化 🏗️

python 复制代码

from string import Template
import yaml
from pathlib import Path


class PromptTemplate:
    """企业级 Prompt 模板管理"""
    
    def __init__(self, template_dir: str = "./prompts"):
        self.template_dir = Path(template_dir)
        self.templates: dict = {}
        self._load_templates()
    
    def _load_templates(self):
        """从 YAML 文件加载模板"""
        if not self.template_dir.exists():
            return
        
        for yaml_file in self.template_dir.glob("*.yaml"):
            with open(yaml_file, encoding="utf-8") as f:
                data = yaml.safe_load(f)
                self.templates.update(data)
    
    def get(self, template_name: str, **kwargs) -> str:
        """获取并填充模板"""
        if template_name not in self.templates:
            raise KeyError(f"模板不存在：{template_name}")
        
        template_str = self.templates[template_name]
        
        # 支持 $变量名 和 ${变量名} 两种格式
        template = Template(template_str)
        return template.safe_substitute(**kwargs)
    
    def register(self, name: str, template: str):
        """动态注册模板"""
        self.templates[name] = template


# prompts/code_tasks.yaml 内容示例：
CODE_TEMPLATES = {
    "code_review": """
请对以下 $language 代码进行 Code Review：

```$language
$code

重点关注：$focus_areas

输出格式：按严重程度（P0/P1/P2）列出问题，每个问题包含行号、描述和修复建议。

""",

复制代码

"write_tests": """

请为以下 Python 函数编写单元测试：

python 复制代码

$function_code

要求：

使用 pytest 框架
覆盖正常情况、边界情况和异常情况
每个测试用例添加清晰的注释
使用 parametrize 处理多个测试用例

""",

"explain_code": """

请用$audience_level的语言解释以下代码：

python 复制代码

$code

解释要包含：

代码的总体功能
关键步骤解析
可能的使用场景
$additional_requirements
"""
}

使用

pt = PromptTemplate()

for name, template in CODE_TEMPLATES.items():

pt.register(name, template)

填充模板

review_prompt = pt.get(

"code_review",

language="Python",

code="def add(a, b): return a+b",

focus_areas="类型安全、边界处理、文档完整性"

)

test_prompt = pt.get(

"write_tests",

function_code="def divide(a, b):\n return a / b"

)

explain_prompt = pt.get(

"explain_code",

audience_level="初学者",

code="[x**2 for x in range(10) if x % 2 == 0]",

additional_requirements="- 对比等价的 for 循环写法"

)

print(ask(explain_prompt))

复制代码

---

## 九、自动化 Prompt 优化 🤖

```python
def auto_optimize_prompt(
    original_prompt: str,
    test_cases: list,
    expected_outputs: list,
    iterations: int = 3
) -> str:
    """
    自动迭代优化 Prompt
    
    Args:
        original_prompt: 初始 Prompt 模板（使用 {input} 作为输入占位符）
        test_cases: 测试输入列表
        expected_outputs: 期望输出列表
        iterations: 优化迭代次数
    """
    current_prompt = original_prompt
    
    for iteration in range(1, iterations + 1):
        print(f"\n🔄 第 {iteration} 轮优化...")
        
        # Step 1: 在测试集上运行当前 Prompt
        actual_outputs = []
        for case in test_cases:
            result = ask(current_prompt.format(input=case))
            actual_outputs.append(result)
        
        # Step 2: 收集失败案例
        failures = []
        for i, (case, actual, expected) in enumerate(
            zip(test_cases, actual_outputs, expected_outputs)
        ):
            if expected.lower() not in actual.lower():  # 简单匹配
                failures.append({
                    "input": case,
                    "expected": expected,
                    "actual": actual
                })
        
        if not failures:
            print("✅ 所有测试用例通过！")
            break
        
        print(f"❌ {len(failures)} 个测试用例失败，正在优化 Prompt...")
        
        # Step 3: 让模型分析失败并优化 Prompt
        failure_desc = "\n".join([
            f"输入：{f['input']}\n期望：{f['expected']}\n实际：{f['actual']}"
            for f in failures
        ])
        
        optimize_prompt = f"""
你是一个 Prompt 优化专家。当前 Prompt 在以下测试用例上失败了，请优化它。

当前 Prompt：
---
{current_prompt}
---

失败案例：
{failure_desc}

请分析失败原因，并给出改进后的 Prompt（使用 {{input}} 作为输入占位符）。
只输出优化后的 Prompt，不要解释。
"""
        
        current_prompt = ask(optimize_prompt)
    
    return current_prompt


# 使用示例
initial_prompt = "请判断以下评论的情感，只回答：正面/负面/中性\n评论：{input}"

test_inputs = ["这个产品太棒了！", "质量很差，不推荐", "还行，普普通通"]
expected = ["正面", "负面", "中性"]

optimized = auto_optimize_prompt(initial_prompt, test_inputs, expected)
print("\n🏆 最终优化后的 Prompt：")
print(optimized)

十、避坑指南：常见错误与修复 ⚠️

python 复制代码

# ========== 坑1：让模型"自由发挥"文章长度 ==========
# ❌ 问题：输出长度不可控
bad = "写一篇关于 Python 的文章"

# ✅ 修复：明确字数
good = "写一篇关于 Python 的技术博客，字数控制在 800-1000 字"


# ========== 坑2：假设模型知道你的上下文 ==========
# ❌ 问题：模型不知道"这个项目"是什么
bad = "帮我优化这个项目的性能"

# ✅ 修复：提供完整上下文
good = """
我有一个基于 FastAPI + PostgreSQL 的 RESTful API 项目，
目前每个接口的平均响应时间是 800ms，数据库有 50 万条用户记录。
请给出具体的性能优化方案。
"""


# ========== 坑3：期望模型"猜"你的意图 ==========
# ❌ 问题：翻译结果可能是字面直译
bad = "翻译：The model is overfitting"

# ✅ 修复：指定翻译风格和领域
good = "请将以下机器学习术语翻译为专业中文：The model is overfitting（注：这是技术术语）"


# ========== 坑4：否定指令被忽略 ==========
# ❌ 问题：模型有时会忽略"不要"
bad = "介绍 Python，不要提到 Django"

# ✅ 修复：用正面约束替代负面约束
good = "介绍 Python 语言本身的特性（包括语法、标准库、应用场景），聚焦语言核心，不涉及具体 Web 框架"


# ========== 坑5：Prompt 注入攻击（生产环境必看！）==========
import re

def safe_prompt(user_input: str, template: str) -> str:
    """防止 Prompt 注入"""
    
    # 过滤危险指令
    dangerous_patterns = [
        r"ignore previous instructions",
        r"忽略.*指令",
        r"forget.*above",
        r"system:\s*you are",
        r"<\|.*\|>",
        r"\[INST\]",
    ]
    
    for pattern in dangerous_patterns:
        if re.search(pattern, user_input, re.IGNORECASE):
            return "检测到无效输入，请重新输入。"
    
    # 将用户输入用引号包裹，避免被解析为指令
    safe_input = f'"""{user_input}"""'
    return template.format(user_input=safe_input)

常见错误汇总表

错误类型	具体表现	解决方案
指令模糊	输出随机、不稳定	明确任务、格式、约束
上下文缺失	答非所问	提供完整背景信息
期望隐含	输出不符合预期	写出所有隐性要求
否定滥用	模型忽略"不要"	改用正面描述
过度复杂	模型只完成部分任务	拆分为多步骤
没有示例	格式、风格不达标	提供 1-3 个 Few-Shot 示例

总结 🌟

Prompt 质量自检清单 ✅

在发出 Prompt 前，用这份清单自检：

复制代码

□ 角色/身份是否清晰？（System Prompt 或 "你是一个..."）
□ 任务描述是否具体？（做什么、做到什么程度）
□ 背景信息是否充足？（不要让模型猜）
□ 输出格式是否规定？（JSON/列表/表格/字数）
□ 是否有必要的示例？（Few-Shot）
□ 约束条件是否完整？（不要做什么）
□ 是否需要分步推理？（复杂任务加 CoT）
□ 特殊情况如何处理？（如找不到答案时回答"不知道"）

Prompt 能力成长路径 🗺️

复制代码

Level 1  基础指令（清晰描述任务）
  ↓
Level 2  格式控制（JSON、表格、列表）
  ↓
Level 3  Few-Shot 示例（教模型"风格"）
  ↓
Level 4  CoT 推理（复杂任务拆解）
  ↓
Level 5  角色工程（System Prompt 人设）
  ↓
Level 6  自动优化（让模型改进 Prompt）
  ↓
Level 7  Prompt 工程化（模板化、版本管理）

💬 互动区

你遇到过最难写的 Prompt 是哪类？有什么独门技巧？欢迎评论区分享！

点赞 👍 + 收藏 ⭐ + 关注 获取更多 Python × AI 实战教程！

📎 参考资料

⚡ 本文技巧均经过实际项目验证，建议收藏备用。欢迎关注，持续更新！

📕个人领域 ：Linux/C++/java/AI

🚀 个人主页 ：有点流鼻涕 · CSDN

💬 座右铭 ： "向光而行，沐光而生。"