覆盖内容：提示词基础 → Few-shot → Chain of Thought → 结构化输出 → 文本总结 → 分类与情感分析 → 代码生成 → 实战
最终产出：AI 简历优化助手（上传简历 → AI 分析 → 给出修改建议）
前置要求：完成第二篇 API 调用入门

---

一、什么是 Prompt Engineering？为什么重要？

大模型像一个通晓万物的实习生——聪明但需要精准指挥。你不会说"帮我把这事做了"，而是说"把这份数据按销售额降序排列，只取前 10 条，输出成 Markdown 表格"。

Prompt Engineering 就是学会给 AI 下精确指令，让它每次输出都可预期、可解析、可集成到程序里。

---

二、清晰指令——把话说清楚

2.1 模糊 vs 精确

from openai import OpenAI
import os

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

# ❌ 模糊指令——AI 自由发挥，每次结果都不同
def ask_vague():
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{"role": "user", "content": "写一段关于 Python 的文字"}]
    )
    return response.choices[0].message.content

# ✅ 精确指令——角色 + 格式 + 长度 + 内容要求
def ask_precise():
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{
            "role": "user",
            "content": """你是一个 Python 入门讲师。请遵守以下规则：

1. 用一段话（不超过 80 字）解释 Python 是什么
2. 列出 3 个 Python 最适合新手的应用场景
3. 每个场景用一句话说明

按以下格式输出：
【一句话解释】
xxx

【三个应用场景】
1. 场景名：说明
2. 场景名：说明
3. 场景名：说明"""
        }]
    )
    return response.choices[0].message.content

print(ask_precise())

输出：

【一句话解释】
Python 是一门语法简洁、上手极快的编程语言，特别适合新手快速入门。

【三个应用场景】
1. 数据分析：用几行代码就能处理 Excel 表格、画图表
2. AI 应用开发：调用大模型 API，搭建聊天机器人和知识库
3. 自动化脚本：自动整理文件、批量处理文档、定时发送邮件

2.2 指令六要素

一个完整的 prompt 应该包含：

要素	说明	例子
角色	你是谁	“你是一个资深后端工程师”
任务	要做什么	“审查以下 Python 代码”
约束	不能做什么	“不要输出解释文字，只要 JSON”
格式	输出长什么样	“用 Markdown 表格” / “JSON 格式”
示例	参考案例	给 1-2 个输入输出样例
边界	遇到特殊情况怎么办	“如果找不到答案，说不知道”

---

三、Few-shot Prompting——给几个例子让 AI 照做

3.1 原理

把"输入 → 输出"的例子放进 prompt，AI 自动学会规律。

# 邮件分类器 —— 用两个例子教 AI
def classify_email(subject):
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{
            "role": "user",
            "content": f"""你是一个邮件分类助手。将邮件标题分为三类：工作、社交、垃圾。

示例 1：
输入：周三部门例会通知
输出：工作

示例 2：
输入：恭喜你中奖了！点击领取
输出：垃圾

现在对以下邮件分类，只输出「工作」「社交」或「垃圾」三个字：
输入：{subject}
输出："""
        }],
        temperature=0
    )
    return response.choices[0].message.content

# 测试
emails = [
    "关于 Q2 项目进度的会议纪要",
    "周末一起去打球吗？",
    "您的账户存在异常登录，请立即点击链接验证",
    "数据分析组本周 OKR 复盘",
]
for e in emails:
    print(f"{e} → {classify_email(e)}")

输出：

关于 Q2 项目进度的会议纪要 → 工作
周末一起去打球吗？ → 社交
您的账户存在异常登录，请立即点击链接验证 → 垃圾
数据分析组本周 OKR 复盘 → 工作

3.2 Few-shot 的格式控制

# 用 Few-shot 格式化输出
def extract_skills(job_desc):
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{
            "role": "user",
            "content": f"""从职位描述中提取技术栈，输出 JSON 数组。

示例 1：
输入：要求熟悉 Spring Boot、MySQL、Redis，了解 Docker
输出：["Spring Boot", "MySQL", "Redis", "Docker"]

示例 2：
输入：精通 Vue3 和 TypeScript，有 Node.js 经验优先
输出：["Vue3", "TypeScript", "Node.js"]

现在提取：
输入：{job_desc}
输出："""
        }],
        temperature=0.3
    )
    return response.choices[0].message.content

print(extract_skills(
    "负责 Python 后端开发，熟练使用 FastAPI 和 PostgreSQL，"
    "有 LangChain 和 Docker 部署经验者优先"
))
# 输出：["Python", "FastAPI", "PostgreSQL", "LangChain", "Docker"]

---

四、Chain of Thought（思维链）——让 AI 逐步推理

4.1 不加 CoT vs 加 CoT

# ❌ 直接问——容易错
prompt_bad = "小明的年龄是小红的 2 倍。3 年后两人年龄和是 27 岁。小红现在几岁？"

# ✅ 加 CoT——让 AI 先列步骤再给答案
prompt_cot = """小明的年龄是小红的 2 倍。3 年后两人年龄和是 27 岁。小红现在几岁？

请按以下步骤思考：
第一步：设小红现在的年龄为 x
第二步：小明的年龄为 2x
第三步：3 年后小红 x+3 岁，小明 2x+3 岁
第四步：列方程 (x+3) + (2x+3) = 27
第五步：解方程，得出 x
第六步：写出最终答案"""

4.2 动手：数学题分步求解器

# cot_solver.py —— 思维链分步求解器
import os
from openai import OpenAI

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

def solve_step_by_step(question):
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{
            "role": "user",
            "content": f"""请用思维链逐步解答以下问题。

格式要求：
1. 每一步用「第N步：」开头
2. 最后给出「最终答案：」
3. 只输出推理过程，不要额外解释

问题：{question}"""
        }],
        temperature=0
    )
    return response.choices[0].message.content

# 测试
questions = [
    "一个长方形的长是宽的 3 倍。如果周长是 64 厘米，宽是多少？",
    "3 个人 3 天喝 3 桶水，9 个人 9 天喝几桶水？",
]

for q in questions:
    print(f"\n📐 {q}")
    print("-" * 50)
    print(solve_step_by_step(q))
    print("-" * 50)

4.3 CoT 的核心技巧

# 技巧 1：加入「让我们一步步思考」
prompt = "问题：...\n让我们一步步思考："

# 技巧 2：给一个完整的思维链示例（Few-shot CoT）
prompt = """示例：
问题：一个苹果 3 元，小明买了 5 个，付了 20 元，找零多少？
第一步：5 个苹果总价 = 5 × 3 = 15 元
第二步：找零 = 20 - 15 = 5 元
最终答案：5 元

现在回答：
问题：{你的问题}
第一步："""

---

五、结构化输出——让 AI 返 JSON / Markdown / 表格

程序不能吃大段文字，必须解析。让 AI 稳定输出结构化数据。

5.1 手动约束 JSON 格式

def extract_person(text):
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{
            "role": "system",
            "content": "你只输出 JSON，不要加 markdown 代码块标记，不要加任何解释。"
        }, {
            "role": "user",
            "content": f"""从以下文本提取姓名、年龄、城市、技能（数组）。

文本：{text}

输出格式：
{{"name": "...", "age": 数字, "city": "...", "skills": ["..."]}}

如果某项没有，填 null。"""
        }],
        temperature=0
    )
    return response.choices[0].message.content

import json

result = extract_person(
    "小啾啾，22 岁，武汉人，会 Java、Python 和 C++，正在找后端工作"
)
person = json.loads(result)
print(person["skills"])  # ['Java', 'Python', 'C++']

5.2 表格输出

def compare_tech():
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{
            "role": "user",
            "content": """比较 Python 和 Java 在后端开发中的特点。

用 Markdown 表格输出，列：特性、Python、Java、建议
至少 5 行。

不要加「好的」「以下是」之类废话，直接输出表格。"""
        }]
    )
    return response.choices[0].message.content

print(compare_tech())

5.3 动手：通用结构化提取器

# structured_extractor.py —— 把任意文字提取成 JSON
import json
import os
from openai import OpenAI

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

def extract(text, schema_desc, examples=""):
    """通用结构化提取"""
    prompt = f"""从文本中提取结构化信息，输出合法 JSON。

提取目标：{schema_desc}

{examples}

规则：
1. 只输出 JSON，不要加 ```json 标记
2. 缺失字段填 null
3. 数组用 []，对象用 {{}}

文本：{text}"""
    
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{"role": "user", "content": prompt}],
        temperature=0
    )
    raw = response.choices[0].message.content.strip()
    # 清理可能的 markdown 包裹
    if raw.startswith("```"):
        raw = raw.split("\n", 1)[1]
        raw = raw.rsplit("\n```", 1)[0]
    return json.loads(raw)

# ─── 用法一：提取项目信息 ───
project_desc = """
校园商城，SpringBoot 3 + Vue3 + MyBatis，
用了 DeepSeek Function Calling 做智能客服，
部署在 mall.qiuyangmm.top
"""

schema = "提取：project(项目名)、stack(技术栈数组)、features(特色功能数组)、url(网址)"
data = extract(project_desc, schema)
print(data)
# {'project': '校园小卖部商城', 'stack': ['SpringBoot 3', 'Vue3', 'MyBatis', 'DeepSeek'],
#  'features': ['智能客服', 'Function Calling'], 'url': 'mall.qiuyangmm.top'}

# ─── 用法二：提取面试信息 ───
job_desc = """
Java 后端开发，要求 1-3 年经验，
熟悉 Spring Cloud、RabbitMQ、Kubernetes，
base 武汉光谷，薪资 12-18K
"""
schema = "提取：position、experience、skills(数组)、location、salary_range"
data = extract(job_desc, schema)
print(data)

---

六、文本总结——长文变短文

6.1 分层总结

def summarize(text, length="short"):
    """多级总结"""
    prompts = {
        "short": "用一句话（不超过 40 字）总结以下内容",
        "medium": "用 3 句话总结以下内容，每句不超过 30 字",
        "detailed": "用 5 个要点总结以下内容，每个要点一行",
    }
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{
            "role": "user",
            "content": f"{prompts[length]}：\n\n{text}"
        }],
        temperature=0.3
    )
    return response.choices[0].message.content

6.2 动手：文章摘要生成器

# summarizer.py —— 文章摘要生成器
import os
from openai import OpenAI

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

def summarize_article(text, style="要点"):
    """生成文章摘要
    
    style: 要点 / 一句话 / 关键词 / 脑图
    """
    style_prompts = {
        "要点": "用 3-5 个要点总结文章核心内容，每点一行，用「-」开头",
        "一句话": "用一句话概括文章主旨，不超过 50 字",
        "关键词": "提取 5-10 个关键词，用逗号分隔，不要额外文字",
        "脑图": "用缩进层级结构展示文章脉络，像思维导图一样",
    }
    
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{
            "role": "user",
            "content": f"{style_prompts[style]}\n\n文章：\n{text}"
        }],
        temperature=0.3
    )
    return response.choices[0].message.content

# 测试
article = """
大模型应用开发正在成为 2026 年最热门的就业方向之一。不同于模型训练需要大量GPU资源，
应用开发只需要掌握 API 调用、RAG 检索增强和 Agent 开发这三个核心技能。

RAG 技术让大模型能够访问外部知识库，解决了大模型「不知道企业内部数据」的痛点。
而 Function Calling 让大模型能够调用数据库、发送邮件、查询天气等外部工具，
真正实现从「聊天」到「干活」的跨越。

目前市场上对「大模型应用开发工程师」的需求同比增长超过 300%，薪资范围在 15K-35K 之间。
"""

print("=== 要点式 ===")
print(summarize_article(article, "要点"))
print("\n=== 一句话 ===")
print(summarize_article(article, "一句话"))
print("\n=== 关键词 ===")
print(summarize_article(article, "关键词"))

---

七、文本分类与情感分析

7.1 情感分析器

# sentiment_analyzer.py —— 评论情感分析
import os
from openai import OpenAI

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

def analyze_sentiment(text):
    """分析情感：正面/负面/中性，带置信度"""
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{
            "role": "user",
            "content": f"""分析以下文本的情感倾向。

输出 JSON：
{{"sentiment": "正面/负面/中性", "confidence": 0.0-1.0, "keywords": ["情绪关键词1", "情绪关键词2"]}}

文本：{text}"""
        }],
        temperature=0
    )
    import json
    raw = response.choices[0].message.content.strip()
    if raw.startswith("```"):
        raw = raw.split("\n", 1)[1].rsplit("\n```", 1)[0]
    return json.loads(raw)

# 批量分析
reviews = [
    "产品非常好用，客服也很有耐心，下次还会买",
    "物流太慢了，包装也破了，差评",
    "今天收到了，还没用",
]

for r in reviews:
    result = analyze_sentiment(r)
    icon = {"正面": "😊", "负面": "😡", "中性": "😐"}
    print(f"{icon[result['sentiment']]} [{result['sentiment']}] {r[:30]}...")
    print(f"   置信度: {result['confidence']}, 关键词: {result['keywords']}")

7.2 批量分类 + 统计

def batch_classify(texts, categories):
    """批量将文本分到指定类别"""
    cat_list = "、".join(categories)
    
    results = []
    for text in texts:
        response = client.chat.completions.create(
            model="deepseek-chat",
            messages=[{
                "role": "user",
                "content": f"""将以下文本分类到：{cat_list}。
只输出类别名，一个字都不要多。

文本：{text}"""
            }],
            temperature=0
        )
        results.append({
            "text": text[:50],
            "category": response.choices[0].message.content.strip()
        })
    return results

# 给客服工单分类
tickets = [
    "我的订单怎么还没发货？",
    "收到的商品颜色不对，我要换货",
    "系统登录时一直提示密码错误",
    "如何申请退货退款？",
    "账号被锁定了，需要重置密码",
]

results = batch_classify(tickets, ["物流问题", "商品问题", "账号问题", "售后退款", "其他"])
for r in results:
    print(f"[{r['category']}] {r['text']}")

---

八、代码生成——自然语言 → SQL

# sql_generator.py —— 自然语言生成 SQL
import os
from openai import OpenAI

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

def generate_sql(nl_query, table_info):
    """自然语言转 SQL"""
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{
            "role": "system",
            "content": "你是 SQL 生成器。只输出 SQL 语句，一行，不加任何解释。"
        }, {
            "role": "user",
            "content": f"""根据以下表结构和自然语言，生成 SQL 语句。

表结构：
{table_info}

自然语言查询：{nl_query}

只输出 SQL："""
        }],
        temperature=0
    )
    return response.choices[0].message.content.strip()

# 定义表结构
schema = """
students(id, name, age, class_id)
classes(id, class_name, teacher)
scores(id, student_id, subject, score)
"""

# 测试
queries = [
    "查询所有学生的姓名和年龄",
    "查询张三的各科成绩",
    "查询每个班级的学生人数，按人数降序排列",
    "查询数学成绩大于 85 分的所有学生姓名和成绩",
]

for q in queries:
    sql = generate_sql(q, schema)
    print(f"\n📝 {q}")
    print(f"   SQL: {sql}")

---

九、阶段实战：AI 简历优化助手

综合本篇全部 Prompt Engineering 技巧，做一个简历分析工具。

# resume_optimizer.py —— 第三篇章毕业作品
import os
import json
from openai import OpenAI

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

# ─── 1. 读取简历 ───
def load_resume(filepath):
    """支持 .txt 和 .json"""
    with open(filepath, "r", encoding="utf-8") as f:
        if filepath.endswith(".json"):
            return json.dumps(json.load(f), ensure_ascii=False, indent=2)
        return f.read()


# ─── 2. 分析简历 ───
def analyze_resume(resume_text):
    """多维度分析，返回结构化 JSON"""
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{
            "role": "system",
            "content": "你是资深 HR + 技术面试官。只输出 JSON，不要加解释。"
        }, {
            "role": "user",
            "content": f"""分析以下简历，输出 JSON：

{{
  "summary": "一句话职业画像，不超过 30 字",
  "strengths": ["优势1", "优势2", "优势3"],
  "weaknesses": ["短板1", "短板2"],
  "score": 1-10 的整数（综合评分）,
  "tech_stack": ["技术1", "技术2"],
  "keywords_missing": ["简历里缺但加分的关键词"],
  "suggestions": [
    {{"category": "排版/内容/技术/项目描述", "problem": "...", "fix": "..."}}
  ],
  "interview_questions": ["面试官可能问的问题1", "问题2"]
}}

简历：
{resume_text}"""
        }],
        temperature=0.3
    )
    raw = response.choices[0].message.content.strip()
    if raw.startswith("```"):
        raw = raw.split("\n", 1)[1].rsplit("\n```", 1)[0]
    return json.loads(raw)


# ─── 3. 格式化输出 ───
def print_report(analysis):
    """把 JSON 分析结果打印成可读报告"""
    print("\n" + "=" * 60)
    print(f"  📋 简历分析报告")
    print("=" * 60)
    
    print(f"\n👤 职业画像：{analysis['summary']}")
    print(f"⭐ 综合评分：{analysis['score']}/10")
    
    print(f"\n✅ 优势：")
    for s in analysis["strengths"]:
        print(f"   + {s}")
    
    print(f"\n⚠️  短板：")
    for w in analysis["weaknesses"]:
        print(f"   - {w}")
    
    print(f"\n🛠️  技术栈：{', '.join(analysis['tech_stack'])}")
    
    print(f"\n🔍 缺失关键词：{', '.join(analysis['keywords_missing'])}")
    
    print(f"\n📝 修改建议：")
    for i, sug in enumerate(analysis["suggestions"], 1):
        print(f"\n   {i}. [{sug['category']}]")
        print(f"      问题：{sug['problem']}")
        print(f"      建议：{sug['fix']}")
    
    print(f"\n🎯 预测面试问题：")
    for i, q in enumerate(analysis["interview_questions"], 1):
        print(f"   {i}. {q}")
    
    print("\n" + "=" * 60)


# ─── 4. 生成优化版简历 ───
def generate_optimized(resume_text, analysis):
    """基于分析结果生成优化版简历"""
    suggestions_text = "\n".join([
        f"- [{s['category']}] {s['problem']} → {s['fix']}"
        for s in analysis["suggestions"]
    ])
    
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[{
            "role": "user",
            "content": f"""你是一个专业的简历优化师。根据原始简历和分析建议，生成优化版简历。

原简历：
{resume_text}

修改建议：
{suggestions_text}

规则：
1. 保持真实性，不编造经历
2. 优化措辞，突出量化成果
3. 项目描述用 STAR 法则（情境-任务-行动-结果）
4. 排版清晰，适合直接复制使用
5. 用 Markdown 格式输出"""
        }],
        temperature=0.5
    )
    return response.choices[0].message.content


# ─── 主程序 ───
def main():
    print("=" * 60)
    print("  🎯 AI 简历优化助手 · 第三篇章毕业作品")
    print("=" * 60)
    
    # 示例简历（也可以让用户输入）
    sample_resume = """
个人简历

姓名：李明
学历：本科，计算机科学与技术，2026 年毕业
电话：138-0000-0000
邮箱：liming@example.com

技能：
Java、Python、MySQL、Spring Boot、Git

项目经历：
1. 学生管理系统
做了一个学生管理系统，可以对学生的信息进行增删改查，
用 Spring Boot 写的后端，前端用 Vue 做的。

2. 电商数据分析
用 Python 爬虫抓了一些商品数据，做了简单的分析，
画了几个图表展示价格分布。

实习经历：
2025.7-2025.10 在某科技公司实习
参与公司内部系统的开发和维护，写了一些接口。
"""
    
    print("\n📂 分析简历中...")
    analysis = analyze_resume(sample_resume)
    print_report(analysis)
    
    # 问用户要不要看优化版
    print("\n" + "=" * 60)
    choice = input("要生成优化版简历吗？(y/n)：").strip().lower()
    if choice == 'y':
        print("\n⚙️  正在优化...")
        optimized = generate_optimized(sample_resume, analysis)
        print("\n" + "=" * 60)
        print("  ✨ 优化版简历")
        print("=" * 60)
        print(optimized)
        
        save = input("\n保存到文件？(y/n)：").strip().lower()
        if save == 'y':
            with open("optimized_resume.md", "w", encoding="utf-8") as f:
                f.write(optimized)
            print("✅ 已保存到 optimized_resume.md")


if __name__ == "__main__":
    main()

运行效果

============================================================
  🎯 AI 简历优化助手 · 第三篇章毕业作品
============================================================

📂 分析简历中...

============================================================
  📋 简历分析报告
============================================================

👤 职业画像：计算机应届生，有基础 Java 开发和实习经验
⭐ 综合评分：4/10

✅ 优势：
   + 有实习经历，简历有实际工作内容
   + 技术栈覆盖前后端基础
   + 教育背景与求职方向匹配

⚠️  短板：
   - 项目描述过于简单，缺少量化数据
   - 技术栈描述不够深入，没有体现原理理解

🛠️  技术栈：Java, Python, MySQL, Spring Boot, Git, Vue

🔍 缺失关键词：Redis, Docker, Linux, 微服务, 项目难点, 性能优化

📝 修改建议：

   1. [项目描述]
      问题：学生管理系统描述太简略，"增删改查"体现不出技术深度
      建议：补充技术细节（用了 MyBatis Plus、异常处理、接口文档 Swagger）

   2. [项目描述]
      问题：电商数据分析没有量化成果
      建议：加上数据量（如"爬取 10000+ 条商品数据"）、图表类型、分析结论

   3. [技术]
      问题：技能列表像流水账
      建议：按熟练度分层（熟练/了解），突出最擅长的 2-3 项

   4. [排版]
      问题：缺少求职意向、GitHub 链接
      建议：顶部加求职意向（Java 后端开发），附 GitHub 或个人网站

🎯 预测面试问题：
   1. 你实习期间最有挑战的一个需求是什么？怎么解决的？
   2. Spring Boot 的自动配置原理是什么？
   3. 学生管理系统的数据库表怎么设计的？为什么这样设计？
   4. 你的爬虫项目遇到过反爬吗？怎么处理的？

============================================================

---

本篇总结

知识点                  你学会了什么
─────────────────────────────────────────────
清晰指令                   角色 + 任务 + 约束 + 格式 + 示例 + 边界
Few-shot Prompting         给 1-2 个示例，AI 自动学会规律
Chain of Thought           让 AI 逐步推理，解数学题、做逻辑判断
结构化输出                 稳定输出 JSON / 表格，程序能解析
文本总结                   要点式、一句话、关键词、脑图四种风格
分类与情感分析             邮件分类、客服工单分类、评论正负面判断
代码生成                   自然语言 → SQL，准确率极高
实战                       简历分析 + 评分 + 建议 + 面试预测 + 优化版生成

---

下一篇预告

第四篇章：RAG 知识检索增强生成——文档加载 → 文本分块 → Embedding 向量化 → ChromaDB 向量数据库 → 检索 + 生成 → 构建完整的知识问答系统。大模型应用开发最核心的技术。

---

作业：把简历优化助手改成接收命令行参数——python resume_optimizer.py my_resume.txt，自动读取文件并输出分析报告。