在提示词工程中，Few-shot、Zero-shot和Chain-of-Thought（思维链）是三种最重要的提示技术。它们代表了不同的学习范式和推理方式，能够显著提升大语言模型在各种任务上的表现。本文将深入探讨这三种技术的原理、应用和最佳实践。

提示学习范式概览

三种范式对比

class PromptLearningParadigms:
    """
    提示学习范式对比
    """
    
    def __init__(self):
        self.paradigms = {
            'Zero-shot': {
                'definition': '不提供任何示例，仅通过指令完成任务',
                'advantages': ['简单快速', '无需准备示例', '适合通用任务'],
                'disadvantages': ['依赖模型能力', '可能理解偏差', '复杂任务效果差'],
                '适用场景': ['简单任务', '通用任务', '模型能力强']
            },
            'Few-shot': {
                'definition': '提供少量示例（通常2-10个），让模型学习模式',
                'advantages': ['提升准确性', '明确期望', '适应特定格式'],
                'disadvantages': ['需要准备示例', '占用token', '示例质量影响大'],
                '适用场景': ['特定格式', '领域任务', '需要高准确性']
            },
            'Chain-of-Thought': {
                'definition': '展示推理过程，引导模型逐步思考',
                'advantages': ['提升推理能力', '过程可解释', '减少错误'],
                'disadvantages': ['输出较长', '成本较高', '需要设计推理步骤'],
                '适用场景': ['复杂推理', '数学问题', '逻辑分析']
            }
        }
    
    def show_comparison(self):
        """展示对比"""
        print("提示学习范式对比")
        print("=" * 80)
        
        for paradigm, info in self.paradigms.items():
            print(f"\n{paradigm}")
            print(f"  定义: {info['definition']}")
            print(f"  优势: {', '.join(info['advantages'])}")
            print(f"  劣势: {', '.join(info['disadvantages'])}")
            print(f"  适用: {', '.join(info['适用场景'])}")

paradigms = PromptLearningParadigms()
paradigms.show_comparison()

Zero-shot Learning（零样本学习）

原理与特点

Zero-shot是指不提供任何示例，仅通过清晰的指令让模型完成任务。

class ZeroShotLearning:
    """
    Zero-shot学习详解
    """
    
    def __init__(self):
        self.key_points = {
            '核心思想': '依赖模型的预训练知识和指令理解能力',
            '成功关键': '清晰的任务描述和明确的输出要求',
            '模型要求': '需要足够大的模型（通常10B+参数）',
            '最佳实践': '结合7大原则设计提示词'
        }
    
    def show_examples(self):
        """展示Zero-shot示例"""
        print("\n\nZero-shot Learning示例")
        print("=" * 80)
        
        examples = [
            {
                'task': '文本分类',
                'prompt': '''请将以下文本分类为：科技、体育、娱乐、财经、政治

规则：
- 只输出类别名称
- 如果不确定，输出"未分类"

文本：苹果公司今天发布了最新款iPhone，搭载了全新的A17芯片。

类别：''',
                'expected_output': '科技',
                'explanation': '通过清晰的指令和规则，模型能够正确分类'
            },
            {
                'task': '信息抽取',
                'prompt': '''从以下文本中提取关键信息，以JSON格式输出：

{
  "人物": "姓名",
  "职位": "职位",
  "公司": "公司名称",
  "事件": "事件描述"
}

文本：特斯拉CEO埃隆·马斯克宣布，公司将在明年推出新款电动卡车。

JSON：''',
                'expected_output': '''{
  "人物": "埃隆·马斯克",
  "职位": "CEO",
  "公司": "特斯拉",
  "事件": "将在明年推出新款电动卡车"
}''',
                'explanation': '明确的格式要求让模型知道如何组织输出'
            },
            {
                'task': '文本改写',
                'prompt': '''将以下正式的商务邮件改写为轻松友好的风格，保持核心信息不变。

原文：
尊敬的张先生，

感谢您对我司产品的关注。经过评估，我们认为贵司的需求与我们的解决方案高度契合。期待与您进一步洽谈合作事宜。

此致
敬礼

改写后：''',
                'expected_output': '''嗨张先生，

谢谢你关注我们的产品！看了你们的需求，感觉跟我们的方案很搭。期待跟你聊聊合作的事儿！

祝好！''',
                'explanation': '清楚说明了改写的方向和要保持的内容'
            }
        ]
        
        for ex in examples:
            print(f"\n任务: {ex['task']}")
            print(f"\n提示词:")
            print(ex['prompt'])
            print(f"\n期望输出:")
            print(ex['expected_output'])
            print(f"\n💡 说明: {ex['explanation']}")
            print("-" * 80)

zero_shot = ZeroShotLearning()
zero_shot.show_examples()

Zero-shot最佳实践

def zero_shot_best_practices():
    """Zero-shot最佳实践"""
    print("\n\nZero-shot最佳实践")
    print("=" * 80)
    
    practices = {
        '1. 清晰的任务描述': {
            'bad': '翻译这段话',
            'good': '将以下中文翻译成英文，使用正式的商务语言，保持专业术语的准确性'
        },
        '2. 明确的输出格式': {
            'bad': '分析这些数据',
            'good': '分析以下销售数据，输出格式：\n- 总销售额：XXX\n- 增长率：XX%\n- 主要趋势：[描述]'
        },
        '3. 提供约束条件': {
            'bad': '写一个故事',
            'good': '写一个200字的科幻短故事，要求：\n- 主角是机器人\n- 背景在未来\n- 结局积极向上'
        },
        '4. 使用明确的分隔符': {
            'bad': '总结：[长文本]',
            'good': '总结以下文本：\n\n---\n[长文本]\n---\n\n总结（50字以内）：'
        }
    }
    
    for practice, examples in practices.items():
        print(f"\n{practice}")
        print(f"  ❌ 不好: {examples['bad']}")
        print(f"  ✅ 更好: {examples['good']}")

zero_shot_best_practices()

Few-shot Learning（少样本学习）

原理与特点

Few-shot通过提供少量示例，让模型理解任务模式和期望输出。

class FewShotLearning:
    """
    Few-shot学习详解
    """
    
    def __init__(self):
        self.shot_numbers = {
            'One-shot': '1个示例',
            'Few-shot': '2-10个示例',
            'Many-shot': '10+个示例（较少使用）'
        }
    
    def show_examples(self):
        """展示Few-shot示例"""
        print("\n\nFew-shot Learning示例")
        print("=" * 80)
        
        examples = [
            {
                'task': '情感分类（3-shot）',
                'prompt': '''将评论分类为：正面、负面、中性

示例1：
评论：这个产品质量很好，超出预期！
分类：正面

示例2：
评论：完全不值这个价格，很失望。
分类：负面

示例3：
评论：还行吧，没什么特别的。
分类：中性

现在请分类：
评论：物流很快，包装也很好，满意！
分类：''',
                'expected_output': '正面',
                'explanation': '通过3个示例，模型学会了分类标准'
            },
            {
                'task': '格式转换（2-shot）',
                'prompt': '''将自然语言转换为Python代码

示例1：
输入：创建一个包含1到10的列表
输出：numbers = list(range(1, 11))

示例2：
输入：计算列表中所有数字的和
输出：total = sum(numbers)

现在请转换：
输入：找出列表中的最大值
输出：''',
                'expected_output': 'max_value = max(numbers)',
                'explanation': '示例展示了转换的模式和代码风格'
            },
            {
                'task': '实体识别（4-shot）',
                'prompt': '''从文本中识别人名、地名、机构名

示例1：
文本：张三在北京大学学习。
人名：张三
地名：北京
机构：北京大学

示例2：
文本：李四在上海工作，就职于阿里巴巴。
人名：李四
地名：上海
机构：阿里巴巴

示例3：
文本：王五从清华大学毕业后去了深圳。
人名：王五
地名：深圳
机构：清华大学

示例4：
文本：赵六在腾讯公司担任工程师。
人名：赵六
地名：无
机构：腾讯公司

现在请识别：
文本：马云创立了阿里巴巴集团，总部位于杭州。
人名：
地名：
机构：''',
                'expected_output': '''人名：马云
地名：杭州
机构：阿里巴巴集团''',
                'explanation': '多个示例覆盖了不同情况，包括"无"的情况'
            }
        ]
        
        for ex in examples:
            print(f"\n任务: {ex['task']}")
            print(f"\n提示词:")
            print(ex['prompt'])
            print(f"\n期望输出:")
            print(ex['expected_output'])
            print(f"\n💡 说明: {ex['explanation']}")
            print("-" * 80)

few_shot = FewShotLearning()
few_shot.show_examples()

Few-shot示例设计原则

class FewShotDesignPrinciples:
    """
    Few-shot示例设计原则
    """
    
    def __init__(self):
        self.principles = {
            '多样性': '示例应覆盖不同类型的输入',
            '代表性': '选择最典型的案例',
            '平衡性': '各类别示例数量均衡',
            '清晰性': '示例简洁明了',
            '一致性': '格式保持统一',
            '渐进性': '从简单到复杂'
        }
    
    def show_good_vs_bad(self):
        """展示好坏示例对比"""
        print("\n\nFew-shot示例设计：好坏对比")
        print("=" * 80)
        
        comparisons = [
            {
                'principle': '多样性',
                'bad': '''示例1：这个很好 → 正面
示例2：这个不错 → 正面
示例3：这个很棒 → 正面''',
                'good': '''示例1：这个很好 → 正面
示例2：这个很差 → 负面
示例3：还可以 → 中性''',
                'reason': '好的示例覆盖了所有类别'
            },
            {
                'principle': '清晰性',
                'bad': '''示例1：
输入：这是一个非常复杂的句子，包含了很多从句和修饰语，而且还有一些专业术语...
输出：复杂''',
                'good': '''示例1：
输入：这个句子很复杂。
输出：复杂''',
                'reason': '简洁的示例更容易理解'
            },
            {
                'principle': '一致性',
                'bad': '''示例1：输入 -> 输出
示例2：问题：XXX 答案：YYY
示例3：Q: XXX A: YYY''',
                'good': '''示例1：输入：XXX 输出：YYY
示例2：输入：AAA 输出：BBB
示例3：输入：CCC 输出：DDD''',
                'reason': '统一的格式避免混淆'
            }
        ]
        
        for comp in comparisons:
            print(f"\n原则: {comp['principle']}")
            print(f"\n❌ 不好的示例:")
            print(comp['bad'])
            print(f"\n✅ 好的示例:")
            print(comp['good'])
            print(f"\n💡 原因: {comp['reason']}")
            print("-" * 80)

design = FewShotDesignPrinciples()
design.show_good_vs_bad()

Few-shot vs Zero-shot选择指南

def few_shot_vs_zero_shot():
    """Few-shot vs Zero-shot选择指南"""
    print("\n\nFew-shot vs Zero-shot 选择指南")
    print("=" * 80)
    
    scenarios = [
        {
            'scenario': '任务简单且通用',
            'recommendation': 'Zero-shot',
            'reason': '模型已有足够知识，无需示例',
            'example': '翻译、总结、简单问答'
        },
        {
            'scenario': '特定格式要求',
            'recommendation': 'Few-shot',
            'reason': '示例能明确展示格式',
            'example': 'JSON输出、特定模板'
        },
        {
            'scenario': '领域特定任务',
            'recommendation': 'Few-shot',
            'reason': '示例提供领域知识',
            'example': '医疗诊断、法律分析'
        },
        {
            'scenario': '需要高准确性',
            'recommendation': 'Few-shot',
            'reason': '示例减少理解偏差',
            'example': '数据提取、分类任务'
        },
        {
            'scenario': 'Token预算有限',
            'recommendation': 'Zero-shot',
            'reason': '节省token成本',
            'example': '大量重复任务'
        },
        {
            'scenario': '复杂推理任务',
            'recommendation': 'Few-shot + CoT',
            'reason': '需要展示推理过程',
            'example': '数学问题、逻辑推理'
        }
    ]
    
    print(f"{'场景':<20} {'推荐':<15} {'原因':<30} {'示例':<20}")
    print("-" * 90)
    
    for s in scenarios:
        print(f"{s['scenario']:<20} {s['recommendation']:<15} "
              f"{s['reason']:<30} {s['example']:<20}")

few_shot_vs_zero_shot()

Chain-of-Thought（思维链）

原理与特点

Chain-of-Thought通过展示推理过程，引导模型逐步思考，特别适合复杂推理任务。

class ChainOfThought:
    """
    Chain-of-Thought（思维链）详解
    """
    
    def __init__(self):
        self.key_features = {
            '核心思想': '让模型展示中间推理步骤',
            '关键短语': '"让我们一步步思考"、"首先...然后...最后..."',
            '适用任务': '数学、逻辑、常识推理、复杂分析',
            '性能提升': '在复杂任务上可提升20-50%准确率'
        }
    
    def show_basic_examples(self):
        """展示基础示例"""
        print("\n\nChain-of-Thought基础示例")
        print("=" * 80)
        
        examples = [
            {
                'task': '数学应用题',
                'without_cot': '''问题：一个商店有15个苹果，卖出了8个，又进货了12个。现在有多少个苹果？

答案：''',
                'with_cot': '''问题：一个商店有15个苹果，卖出了8个，又进货了12个。现在有多少个苹果？

让我们一步步思考：
1. 初始数量：15个苹果
2. 卖出后：15 - 8 = 7个苹果
3. 进货后：7 + 12 = 19个苹果

因此，现在有19个苹果。''',
                'improvement': '通过展示推理步骤，减少计算错误'
            },
            {
                'task': '逻辑推理',
                'without_cot': '''所有的猫都是动物。
所有的动物都需要食物。
问：猫需要食物吗？

答案：''',
                'with_cot': '''所有的猫都是动物。
所有的动物都需要食物。
问：猫需要食物吗？

让我们一步步推理：
1. 前提1：所有的猫都是动物
2. 前提2：所有的动物都需要食物
3. 根据前提1，猫属于动物
4. 根据前提2，既然猫是动物，那么猫需要食物

因此，答案是：是的，猫需要食物。''',
                'improvement': '逻辑链条清晰，结论可靠'
            },
            {
                'task': '常识推理',
                'without_cot': '''问题：如果外面在下雨，我应该带什么出门？

答案：''',
                'with_cot': '''问题：如果外面在下雨，我应该带什么出门？

让我们一步步思考：
1. 下雨意味着会淋湿
2. 为了不被淋湿，需要遮挡雨水
3. 常见的遮雨工具有：雨伞、雨衣
4. 雨伞最常用且方便携带

因此，你应该带雨伞出门。''',
                'improvement': '推理过程符合常识，答案合理'
            }
        ]
        
        for ex in examples:
            print(f"\n任务: {ex['task']}")
            print(f"\n❌ 不使用CoT:")
            print(ex['without_cot'])
            print(f"\n✅ 使用CoT:")
            print(ex['with_cot'])
            print(f"\n💡 改进: {ex['improvement']}")
            print("-" * 80)

cot = ChainOfThought()
cot.show_basic_examples()

Zero-shot CoT vs Few-shot CoT

class CoTVariants:
    """
    CoT变体：Zero-shot CoT vs Few-shot CoT
    """
    
    def show_variants(self):
        """展示CoT变体"""
        print("\n\nCoT变体对比")
        print("=" * 80)
        
        print("\n1. Zero-shot CoT（零样本思维链）")
        print("-" * 60)
        print("只需添加'让我们一步步思考'即可激发推理能力\n")
        
        zero_shot_cot = '''问题：一辆车以60公里/小时的速度行驶了2.5小时，行驶了多少公里？

让我们一步步思考：

[模型会自动生成推理步骤]
1. 速度 = 60公里/小时
2. 时间 = 2.5小时
3. 距离 = 速度 × 时间
4. 距离 = 60 × 2.5 = 150公里

答案：150公里'''
        
        print(zero_shot_cot)
        
        print("\n\n2. Few-shot CoT（少样本思维链）")
        print("-" * 60)
        print("提供带推理过程的示例\n")
        
        few_shot_cot = '''示例1：
问题：一个班级有30个学生，其中60%是女生。有多少个女生？
推理：
1. 总学生数：30人
2. 女生比例：60% = 0.6
3. 女生人数 = 30 × 0.6 = 18人
答案：18个女生

示例2：
问题：一本书有200页，小明每天读25页，需要几天读完？
推理：
1. 总页数：200页
2. 每天阅读：25页
3. 需要天数 = 200 ÷ 25 = 8天
答案：8天

现在请解决：
问题：一个水池可以装500升水，现在已经装了300升，还能装多少升？
推理：'''
        
        print(few_shot_cot)
        
        print("\n\n选择建议:")
        print("  • Zero-shot CoT: 简单快速，适合模型能力强的情况")
        print("  • Few-shot CoT: 准确性更高，适合复杂或特定领域任务")

variants = CoTVariants()
variants.show_variants()

高级CoT技术

class AdvancedCoT:
    """
    高级CoT技术
    """
    
    def show_techniques(self):
        """展示高级技术"""
        print("\n\n高级CoT技术")
        print("=" * 80)
        
        techniques = {
            'Self-Consistency': {
                'description': '生成多个推理路径，选择最一致的答案',
                'example': '''问题：[数学题]

生成3个不同的推理过程：

推理路径1：
[步骤1-1] → [步骤1-2] → [步骤1-3] → 答案A

推理路径2：
[步骤2-1] → [步骤2-2] → [步骤2-3] → 答案A

推理路径3：
[步骤3-1] → [步骤3-2] → [步骤3-3] → 答案B

最终答案：A（2/3的路径得出此答案）'''
            },
            
            'Least-to-Most': {
                'description': '将复杂问题分解为子问题，逐个解决',
                'example': '''复杂问题：计算一个复杂表达式的值

步骤1：识别子问题
- 子问题1：计算括号内的值
- 子问题2：处理乘除运算
- 子问题3：处理加减运算

步骤2：解决子问题1
[详细计算]

步骤3：解决子问题2
[详细计算]

步骤4：解决子问题3
[详细计算]

最终答案：[结果]'''
            },
            
            'Tree-of-Thought': {
                'description': '探索多个思维分支，选择最优路径',
                'example': '''问题：[策略问题]

思维树：
根节点：问题
├─ 分支1：方案A
│  ├─ 优点：[列举]
│  └─ 缺点：[列举]
│  └─ 评分：7/10
├─ 分支2：方案B
│  ├─ 优点：[列举]
│  └─ 缺点：[列举]
│  └─ 评分：8/10
└─ 分支3：方案C
   ├─ 优点：[列举]
   └─ 缺点：[列举]
   └─ 评分：6/10

最优选择：方案B（评分最高）'''
            }
        }
        
        for tech, info in techniques.items():
            print(f"\n{tech}")
            print(f"  描述: {info['description']}")
            print(f"\n  示例:")
            for line in info['example'].split('\n'):
                print(f"    {line}")
            print("-" * 80)

advanced = AdvancedCoT()
advanced.show_techniques()

三种技术的组合使用

class CombinedTechniques:
    """
    组合使用三种技术
    """
    
    def show_combination_examples(self):
        """展示组合示例"""
        print("\n\n组合使用示例")
        print("=" * 80)
        
        examples = [
            {
                'scenario': '复杂数据分析',
                'technique': 'Few-shot + CoT',
                'prompt': '''分析以下销售数据并提供洞察

示例1：
数据：Q1销售额100万，Q2销售额120万
分析过程：
1. 计算增长：(120-100)/100 = 20%
2. 判断趋势：增长率为正，趋势向好
3. 识别原因：可能是季节性因素或营销活动
结论：销售表现良好，建议继续当前策略

示例2：
数据：Q1销售额100万，Q2销售额80万
分析过程：
1. 计算增长：(80-100)/100 = -20%
2. 判断趋势：负增长，需要警惕
3. 识别原因：可能是市场竞争或产品问题
结论：需要调查原因并采取改进措施

现在请分析：
数据：[实际数据]
分析过程：'''
            },
            {
                'scenario': '代码调试',
                'technique': 'Zero-shot + CoT',
                'prompt': '''以下代码有bug，请找出并修复

代码：
[代码内容]

让我们一步步分析：
1. 理解代码意图
   - 这段代码想要实现什么功能？
   
2. 检查语法
   - 是否有语法错误？
   
3. 分析逻辑
   - 逻辑是否正确？
   - 边界条件是否处理？
   
4. 识别bug
   - 具体问题在哪里？
   
5. 提供修复
   - 如何修改？
   - 修复后的代码

修复方案：'''
            },
            {
                'scenario': '创意写作',
                'technique': 'Few-shot + 角色设定',
                'prompt': '''你是一位经验丰富的科幻作家。请创作一个短故事。

示例1：
主题：时间旅行
故事：[200字的精彩故事]

示例2：
主题：人工智能觉醒
故事：[200字的精彩故事]

现在请创作：
主题：[新主题]

创作思路：
1. 确定核心冲突
2. 设计主要角色
3. 构思情节转折
4. 设计开放式结尾

故事：'''
            }
        ]
        
        for ex in examples:
            print(f"\n场景: {ex['scenario']}")
            print(f"技术组合: {ex['technique']}")
            print(f"\n提示词:")
            for line in ex['prompt'].split('\n'):
                print(f"  {line}")
            print("-" * 80)

combined = CombinedTechniques()
combined.show_combination_examples()

实战技巧与注意事项

class PracticalTips:
    """
    实战技巧与注意事项
    """
    
    def show_tips(self):
        """展示实战技巧"""
        print("\n\n实战技巧")
        print("=" * 80)
        
        tips = {
            'Zero-shot技巧': [
                '使用清晰的任务描述',
                '提供明确的输出格式',
                '添加约束条件',
                '使用分隔符区分不同部分',
                '测试不同的指令表述'
            ],
            'Few-shot技巧': [
                '示例数量：2-5个最佳',
                '确保示例多样性',
                '保持格式一致',
                '从简单到复杂排列',
                '包含边界情况'
            ],
            'CoT技巧': [
                '使用"让我们一步步思考"',
                '明确推理步骤',
                '展示中间计算',
                '验证每一步',
                '总结最终答案'
            ],
            '通用技巧': [
                '根据任务复杂度选择技术',
                '考虑token成本',
                '测试多个版本',
                '收集反馈迭代',
                '建立提示词库'
            ]
        }
        
        for category, tip_list in tips.items():
            print(f"\n{category}:")
            for tip in tip_list:
                print(f"  ✓ {tip}")
    
    def show_common_mistakes(self):
        """展示常见错误"""
        print("\n\n常见错误")
        print("=" * 80)
        
        mistakes = [
            {
                'mistake': '示例过多',
                'problem': '占用大量token，增加成本',
                'solution': '通常2-5个示例足够'
            },
            {
                'mistake': '示例不一致',
                'problem': '模型难以学习模式',
                'solution': '保持格式和风格统一'
            },
            {
                'mistake': 'CoT步骤过于简单',
                'problem': '没有真正展示推理',
                'solution': '确保每步都有实质内容'
            },
            {
                'mistake': '忽略边界情况',
                'problem': '特殊输入处理不当',
                'solution': '在示例中包含边界情况'
            },
            {
                'mistake': '过度依赖单一技术',
                'problem': '不同任务需要不同方法',
                'solution': '根据任务特点灵活选择'
            }
        ]
        
        for m in mistakes:
            print(f"\n❌ 错误: {m['mistake']}")
            print(f"   问题: {m['problem']}")
            print(f"   ✅ 解决: {m['solution']}")

tips = PracticalTips()
tips.show_tips()
tips.show_common_mistakes()

性能对比与选择指南

class PerformanceComparison:
    """
    性能对比与选择指南
    """
    
    def show_performance_table(self):
        """展示性能对比表"""
        print("\n\n性能对比")
        print("=" * 80)
        
        print("""
任务类型          | Zero-shot | Few-shot | CoT      | Few-shot+CoT
-----------------|-----------|----------|----------|-------------
简单分类          | ⭐⭐⭐⭐    | ⭐⭐⭐⭐⭐   | ⭐⭐⭐     | ⭐⭐⭐⭐⭐
格式转换          | ⭐⭐⭐     | ⭐⭐⭐⭐⭐   | ⭐⭐⭐     | ⭐⭐⭐⭐⭐
数学推理          | ⭐⭐       | ⭐⭐⭐     | ⭐⭐⭐⭐⭐   | ⭐⭐⭐⭐⭐
逻辑推理          | ⭐⭐       | ⭐⭐⭐     | ⭐⭐⭐⭐⭐   | ⭐⭐⭐⭐⭐
常识推理          | ⭐⭐⭐     | ⭐⭐⭐⭐    | ⭐⭐⭐⭐⭐   | ⭐⭐⭐⭐⭐
创意生成          | ⭐⭐⭐⭐    | ⭐⭐⭐⭐⭐   | ⭐⭐⭐     | ⭐⭐⭐⭐
代码生成          | ⭐⭐⭐     | ⭐⭐⭐⭐⭐   | ⭐⭐⭐⭐    | ⭐⭐⭐⭐⭐
信息提取          | ⭐⭐⭐     | ⭐⭐⭐⭐⭐   | ⭐⭐⭐     | ⭐⭐⭐⭐⭐

Token成本         | 低        | 中       | 中       | 高
准备时间          | 短        | 中       | 短       | 中
适用模型规模      | 10B+      | 7B+      | 10B+     | 10B+
""")
    
    def show_decision_tree(self):
        """展示决策树"""
        print("\n\n选择决策树")
        print("=" * 80)
        
        print("""
开始
 │
 ├─ 任务是否需要复杂推理？
 │   ├─ 是 → 使用CoT或Few-shot+CoT
 │   └─ 否 → 继续
 │
 ├─ 是否有特定格式要求？
 │   ├─ 是 → 使用Few-shot
 │   └─ 否 → 继续
 │
 ├─ 任务是否通用且简单？
 │   ├─ 是 → 使用Zero-shot
 │   └─ 否 → 使用Few-shot
 │
 └─ Token预算是否充足？
     ├─ 是 → 可以使用Few-shot+CoT
     └─ 否 → 优先Zero-shot或Few-shot
""")

comparison = PerformanceComparison()
comparison.show_performance_table()
comparison.show_decision_tree()

总结

本文深入探讨了三种核心提示技术：

1. Zero-shot Learning

   • 无需示例，仅靠指令
   • 适合简单通用任务
   • 成本低，速度快

2. Few-shot Learning

   • 提供2-10个示例
   • 适合特定格式和领域任务
   • 准确性高，灵活性强

3. Chain-of-Thought

   • 展示推理过程
   • 适合复杂推理任务
   • 显著提升推理能力

选择建议：

• 简单任务 → Zero-shot
• 特定格式 → Few-shot
• 复杂推理 → CoT
• 最佳效果 → Few-shot + CoT

掌握这三种技术及其组合使用，你就能应对绝大多数提示词工程场景。在下一篇文章中，我们将探讨角色设定、任务分解和输出格式控制等高级技巧。