Day3.参数+Prompt三板斧

Day3.参数+Prompt三板斧

本周位置：大模型/大模型实战/Week01/Day3

本节目标：学会调教模型+写好Prompt

预期成果

​ 能解释Temperature和top_p的区别

​ 能解释prompt三板斧（直接/CoT/Few-shot）并各举一例

​ 用真实工程任务（写代码/debug/写docstring）对比三种策略

​ 在prompts/research/下存了至少三个模板

第一步：理解temperature

temperature是什么：

​ 控制模型输出的随机性

​ 范围0-2（OpenAI）/0-1.5（Deepseek）

​ 低温度（0-0.3）--> 稳定、可复现、几乎同样的问题每次都差不多

​ 高温度（0.7-1.2） --> 随机、有创造性、同一问题每次都不一样

创建param_temperature.py

# param_temperature.py
# Day 3 · 玩 temperature 参数

import os
from openai import OpenAI
from dotenv import load_dotenv

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


# 选一个"工程自动化"场景的开放性问题------有随机性才能看出参数效果
# ↓↓↓ 换成你日常让 LLM 做的真问题 ↓↓↓
QUESTION = "给我详细解释一下生物信息学都包含哪些领域？"

SYSTEM = "你是资深生信工程师，写文档简洁专业。"

TEMPERATURES = [0.0, 0.3, 0.7, 1.2]


def ask(question: str, temperature: float) -> str:
    resp = client.chat.completions.create(
        model="deepseek-chat",
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": question},
        ],
        temperature=temperature,
    )
    return resp.choices[0].message.content


def main():
    for temp in TEMPERATURES:
        print(f"\n{'=' * 60}")
        print(f"### temperature = {temp}")
        print(f"{'=' * 60}\n")

        # 每个温度跑 2 次，看是不是真的不同
        for run in range(1, 3):
            print(f"--- 第 {run} 次 ---")
            print(ask(QUESTION, temp))
            print()


if __name__ == "__main__":
    main()

运行代码

python param_temperature.py

运行结果

第二步：理解top_p

top_p是什么：

​ 核采样阈值（Nucleus Sampling）

​ 范围0-1

​ 模型在生成每个字时，先按概率从高到低排序，累加概率到top_p截止

​ top_p=0.1 --> 只考虑概率最高的极少数词 --> 非常确定

​ top_p=0.9 --> 考虑大部分合理词 --> 平衡（默认）

​ top_p=1.0 --> 考虑所有词 --> 最随机

创建param_top_p.py

# param_top_p.py
# Day 3 · 玩 top_p 参数

import os
from openai import OpenAI
from dotenv import load_dotenv

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


# 用同样的开放性问题，但固定 temperature=0.7
# （用真实问题，不要留占位符------否则 LLM 会原样回显）
QUESTION = "写一个 Python 函数，实现 [1, 2, [3, 4, [5, 6]]] 这种嵌套列表的展平"
SYSTEM = "你是资深 Python 工程师，写代码简洁有注释。"

TOP_PS = [0.5, 0.9, 1.0]
TEMP = 0.7


def ask(question: str, top_p: float) -> str:
    resp = client.chat.completions.create(
        model="deepseek-chat",
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": question},
        ],
        temperature=TEMP,
        top_p=top_p,
    )
    return resp.choices[0].message.content


def main():
    for top_p in TOP_PS:
        print(f"\n{'=' * 60}")
        print(f"### temperature = {TEMP}, top_p = {top_p}")
        print(f"{'=' * 60}\n")
        print(ask(QUESTION, top_p))


if __name__ == "__main__":
    main()

运行结果

============================================================
### temperature = 0.7, top_p = 0.5
============================================================

我来写一个展平嵌套列表的函数，提供两种实现方式：

```python
from typing import List, Any, Iterable


def flatten_recursive(nested_list: List[Any]) -> List[Any]:
    """
    使用递归方式展平嵌套列表

    Args:
        nested_list: 可能包含嵌套列表的列表

    Returns:
        展平后的一维列表
    """
    result = []
    for item in nested_list:
        if isinstance(item, list):
            # 递归处理子列表
            result.extend(flatten_recursive(item))
        else:
            result.append(item)
    return result


def flatten_iterative(nested_list: List[Any]) -> List[Any]:
    """
    使用迭代方式展平嵌套列表（避免递归深度限制）

    Args:
        nested_list: 可能包含嵌套列表的列表

    Returns:
        展平后的一维列表
    """
    result = []
    stack = list(nested_list)  # 使用栈模拟递归

    while stack:
        item = stack.pop(0)  # 取出第一个元素
        if isinstance(item, list):
            # 将子列表的元素逆序压入栈中，保持原始顺序
            stack = list(item) + stack
        else:
            result.append(item)
    return result


# 测试示例
if __name__ == "__main__":
    test_list = [1, 2, [3, 4, [5, 6]]]

    print("原始列表:", test_list)
    print("递归展平:", flatten_recursive(test_list))
    print("迭代展平:", flatten_iterative(test_list))

    # 更复杂的测试
    complex_list = [1, [2, 3], [4, [5, [6, 7]]], 8]
    print("\n复杂列表:", complex_list)
    print("递归展平:", flatten_recursive(complex_list))
    print("迭代展平:", flatten_iterative(complex_list))
```

**输出结果：**
```
原始列表: [1, 2, [3, 4, [5, 6]]]
递归展平: [1, 2, 3, 4, 5, 6]
迭代展平: [1, 2, 3, 4, 5, 6]

复杂列表: [1, [2, 3], [4, [5, [6, 7]]], 8]
递归展平: [1, 2, 3, 4, 5, 6, 7, 8]
迭代展平: [1, 2, 3, 4, 5, 6, 7, 8]
```

**两种实现方式的区别：**

1. **递归方式** (`flatten_recursive`)：
   - 代码简洁直观，易于理解
   - 适合嵌套层数不深的情况（Python 默认递归深度限制约 1000 层）

2. **迭代方式** (`flatten_iterative`)：
   - 使用栈模拟递归，避免递归深度限制
   - 适合处理深层嵌套的列表
   - 时间复杂度 O(n)，空间复杂度 O(n)

如果需要更简洁的写法，还可以使用生成器：

```python
def flatten_generator(nested_list):
    """使用生成器实现，惰性求值"""
    for item in nested_list:
        if isinstance(item, list):
            yield from flatten_generator(item)
        else:
            yield item

# 使用示例
test_list = [1, 2, [3, 4, [5, 6]]]
flattened = list(flatten_generator(test_list))
print(flattened)  # [1, 2, 3, 4, 5, 6]
```

============================================================
### temperature = 0.7, top_p = 0.9
============================================================

以下是实现嵌套列表展平的 Python 函数，包含递归和迭代两种方式，并附带详细注释：

```python
def flatten_recursive(nested_list):
    """
    使用递归方式展平嵌套列表

    参数:
        nested_list: 嵌套列表，例如 [1, 2, [3, 4, [5, 6]]]

    返回:
        展平后的一维列表，例如 [1, 2, 3, 4, 5, 6]
    """
    result = []
    for item in nested_list:
        if isinstance(item, list):
            # 如果是列表，递归展平并扩展结果
            result.extend(flatten_recursive(item))
        else:
            # 如果不是列表，直接添加
            result.append(item)
    return result


def flatten_iterative(nested_list):
    """
    使用迭代方式（栈）展平嵌套列表，避免递归深度限制

    参数:
        nested_list: 嵌套列表

    返回:
        展平后的一维列表
    """
    result = []
    stack = [nested_list]  # 用栈保存待处理的列表

    while stack:
        current = stack.pop()  # 取出当前处理的列表
        # 倒序遍历，保持原始顺序
        for item in reversed(current):
            if isinstance(item, list):
                stack.append(item)  # 如果是列表，压入栈
            else:
                result.append(item)  # 如果是元素，直接添加
    return result


# 测试示例
if __name__ == "__main__":
    test_list = [1, 2, [3, 4, [5, 6]]]

    print("原始嵌套列表:", test_list)
    print("递归展平结果:", flatten_recursive(test_list))
    print("迭代展平结果:", flatten_iterative(test_list))

    # 更复杂的测试
    complex_list = [1, [2, 3], [4, [5, [6, 7]]], 8]
    print("\n复杂嵌套列表:", complex_list)
    print("递归展平结果:", flatten_recursive(complex_list))
    print("迭代展平结果:", flatten_iterative(complex_list))
```

**运行结果：**
```
原始嵌套列表: [1, 2, [3, 4, [5, 6]]]
递归展平结果: [1, 2, 3, 4, 5, 6]
迭代展平结果: [1, 2, 3, 4, 5, 6]

复杂嵌套列表: [1, [2, 3], [4, [5, [6, 7]]], 8]
递归展平结果: [1, 2, 3, 4, 5, 6, 7, 8]
迭代展平结果: [1, 2, 3, 4, 5, 6, 7, 8]
```

**代码说明：**

1. **递归版本 (`flatten_recursive`)**:
   - 遍历列表中的每个元素
   - 如果元素是列表，递归调用自身并扩展结果
   - 如果不是列表，直接添加到结果中
   - 代码简洁直观，但嵌套过深时可能触发递归限制

2. **迭代版本 (`flatten_iterative`)**:
   - 使用栈（后进先出）数据结构
   - 倒序遍历当前列表，保持元素的原始顺序
   - 遇到列表就压入栈，遇到元素就添加到结果
   - 不受递归深度限制，适合处理非常深的嵌套

两种方法都能正确处理任意深度的嵌套列表，可以根据实际需求选择使用。

============================================================
### temperature = 0.7, top_p = 1.0
============================================================

以下是实现嵌套列表展平的 Python 函数，包含注释和多种实现方式：

```python
def flatten(nested_list):
    """
    将嵌套列表展平为一维列表

    参数:
        nested_list: 嵌套列表，例如 [1, 2, [3, 4, [5, 6]]]

    返回:
        展平后的一维列表，例如 [1, 2, 3, 4, 5, 6]
    """
    result = []

    def _flatten_recursive(items):
        """递归辅助函数"""
        for item in items:
            if isinstance(item, list):
                # 如果元素是列表，递归处理
                _flatten_recursive(item)
            else:
                # 如果是普通元素，直接添加
                result.append(item)

    _flatten_recursive(nested_list)
    return result


# 简洁的递归版本
def flatten_simple(nested_list):
    """使用列表推导式的递归版本"""
    return [
        item
        for sublist in nested_list
        for item in (flatten_simple(sublist) if isinstance(sublist, list) else [sublist])
    ]


# 使用生成器的版本（内存友好）
def flatten_generator(nested_list):
    """生成器版本，逐项产出展平结果"""
    for item in nested_list:
        if isinstance(item, list):
            yield from flatten_generator(item)
        else:
            yield item


# 使用栈的迭代版本（无递归限制）
def flatten_iterative(nested_list):
    """迭代版本，使用栈避免递归深度限制"""
    stack = nested_list[::-1]  # 反转列表作为栈
    result = []
    while stack:
        item = stack.pop()
        if isinstance(item, list):
            # 将列表元素逆序压入栈，保持原顺序
            stack.extend(item[::-1])
        else:
            result.append(item)
    return result


# 测试代码
if __name__ == "__main__":
    test_list = [1, 2, [3, 4, [5, 6]]]

    print("原始列表:", test_list)
    print("递归版本:", flatten(test_list))
    print("简洁版本:", flatten_simple(test_list))
    print("生成器版本:", list(flatten_generator(test_list)))
    print("迭代版本:", flatten_iterative(test_list))

    # 测试更复杂的嵌套
    complex_list = [1, [2, [3, [4, [5]]]], 6, [7, 8]]
    print("\n复杂嵌套:", complex_list)
    print("展平结果:", flatten(complex_list))
```

**输出结果：**
```
原始列表: [1, 2, [3, 4, [5, 6]]]
递归版本: [1, 2, 3, 4, 5, 6]
简洁版本: [1, 2, 3, 4, 5, 6]
生成器版本: [1, 2, 3, 4, 5, 6]
迭代版本: [1, 2, 3, 4, 5, 6]

复杂嵌套: [1, [2, [3, [4, [5]]]], 6, [7, 8]]
展平结果: [1, 2, 3, 4, 5, 6, 7, 8]
```

**主要实现说明：**

1. **递归版本 (`flatten`)**：最直观，通过递归处理嵌套列表，将所有非列表元素收集到结果中。

2. **简洁版本 (`flatten_simple`)**：使用列表推导式一行实现，但可读性稍差。

3. **生成器版本 (`flatten_generator`)**：使用 `yield` 惰性生成结果，节省内存，适合处理大型数据。

4. **迭代版本 (`flatten_iterative`)**：使用栈模拟递归，避免 Python 递归深度限制（默认约 1000 层）。

**选择建议：**
- 日常使用推荐 `flatten`（简单易懂）
- 处理超大列表用 `flatten_generator`（内存友好）
- 嵌套层级极深时用 `flatten_iterative`（避免递归限制）

第三步：理解Prompt三板斧

为什么需要Prompt工程：同一道题，写法不同输出天差地别。下面三种套路覆盖90%场景

板斧1：直接提问（Zero-shot）

prompt = "用 Python 写一个快速排序函数"

• 最简单，但最不可控
• 适合：闲聊、简单问答、初稿

板斧2：思维链（Chain-of-Thought，CoT）

prompt = """用 Python 写一个快速排序函数。

请一步步思考：

1. 先写出快速排序的算法步骤（用自然语言）
2. 把每一步翻译成代码
3. 把它们组合成完整函数
4. 给一个测试用例验证"""

• 激活词: "请一步步思考"、"Let's think step by step"、"请分步骤考虑"
• 适合: debug、代码审查、复杂分析
• 原理: 让模型"先想后答"，避免跳步错误

板斧3：Few-shot（In-Context Learning）

prompt = """你是写严谨 Python 代码的工程师，输出必须带类型注解和 docstring。

示例 1：用 Python 写一个二分搜索函数。
```python
from typing import List

def binary_search(arr: List[int], target: int) -> int:
    """
    在有序数组中查找 target 的索引。

    Args:
        arr: 有序整数数组
        target: 要查找的目标值

    Returns:
        target 的索引；如果不存在返回 -1
    """
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1
```
"""

• 先给 1-5 个"输入 → 输出"示例，模型会模仿格式和风格
• 适合：输出格式固定、批处理任务、风格统一
• 原理：示例即"上下文学习"，模型不需要重新训练就能学会新模式

三板斧的"性价比"

板斧	写起来费劲	输出稳定性	适用面
直接提问	★	★★	★★★★★
思维链	★★	★★★★	★★★★
Few-shot	★★★	★★★★★	★★★

工程场景的实战经验：

• CoT 几乎总是更强
  多花一句话"请一步步"，质量明显提升
• Few-shot 在"格式统一"任务中最强
  比如让模型固定表格 / 写统一格式的 commit msg
• 直接提问只在问题很简单时用
  比如"X 是什么"

第四步：用真实工程任务做Prompt对比

创建prompt_strategies.py

# prompt_strategies.py
# Day 3 · 三种 Prompt 策略对比

import os
from openai import OpenAI
from dotenv import load_dotenv

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


# === 你只需要改这里 ===
YOUR_TASK = "Python 生信工具开发"
YOUR_QUESTION = "如何写一个DNA序列比对的小工具？"
# === 改完这里就行，下面不用动 ===


SYSTEM = f"""你是 {YOUR_TASK} 方向的资深工程师。
回答要求：
- 简洁准确，不超过 300 字
- 代码示例用 Markdown 代码块
- 必须带类型注解

数学公式用 LaTeX"""

# 策略 A：直接提问
PROMPT_A = YOUR_QUESTION

# 策略 B：思维链
PROMPT_B = f"""{YOUR_QUESTION}

请一步步分析：

1. 核心问题是什么？
2. 解决思路有哪些？各有什么优缺点？
3. 推荐哪种实现？为什么？
4. 给出完整代码示例
"""

# 策略 C：Few-shot
PROMPT_C = f"""你是 {YOUR_TASK} 方向的资深工程师，写代码规范、带类型注解。

示例问题：如何写一个检测重复文件的 Python 工具？
示例答案：
```python
import hashlib
from pathlib import Path
from typing import Dict, List

def find_duplicates(dir_path: str) -> Dict[str, List[str]]:
    \\\"\\\"\\\"
    找出目录中的重复文件（按内容 hash）。

    Args:
        dir_path: 要扫描的目录路径

    Returns:
        字典：hash -> [重复文件路径列表]。无重复返回空 dict。
    \\\"\\\"\\\"
    hash_map: Dict[str, List[str]] = {{}}
    for filepath in Path(dir_path).rglob("*"):
        if filepath.is_file():
            content = filepath.read_bytes()
            file_hash = hashlib.md5(content).hexdigest()
            hash_map.setdefault(file_hash, []).append(str(filepath))
    return {{h: paths for h, paths in hash_map.items() if len(paths) > 1}}
```
现在请回答：

{YOUR_QUESTION}"""


def ask(prompt: str) -> tuple[str, int]:
    resp = client.chat.completions.create(
        model="deepseek-chat",
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": prompt},
        ],
        temperature=0.5,
    )
    return resp.choices[0].message.content, resp.usage.total_tokens


def main():
    strategies = {
        "A · 直接提问": PROMPT_A,
        "B · 思维链 (CoT)": PROMPT_B,
        "C · Few-shot": PROMPT_C,
    }

    for name, prompt in strategies.items():
        print(f"\n{'=' * 70}")
        print(f"### 策略 {name}")
        print(f"{'=' * 70}\n")
        answer, tokens = ask(prompt)
        print(answer)
        print(f"\n[tokens: {tokens}]")


if __name__ == "__main__":
    main()

运行

python prompt_strategies.py

结果

======================================================================
### 策略 A · 直接提问
======================================================================

```python
from typing import Tuple, List

def needleman_wunsch(seq1: str, seq2: str, match: int = 1, mismatch: int = -1, gap: int = -2) -> Tuple[int, str, str]:
    """全局比对（Needleman-Wunsch算法）"""
    m, n = len(seq1), len(seq2)
    dp = [[0] * (n+1) for _ in range(m+1)]

    # 初始化
    for i in range(m+1): dp[i][0] = i * gap
    for j in range(n+1): dp[0][j] = j * gap

    # 动态规划
    for i in range(1, m+1):
        for j in range(1, n+1):
            score = match if seq1[i-1] == seq2[j-1] else mismatch
            dp[i][j] = max(
                dp[i-1][j-1] + score,
                dp[i-1][j] + gap,
                dp[i][j-1] + gap
            )

    # 回溯
    align1, align2 = [], []
    i, j = m, n
    while i > 0 or j > 0:
        if i > 0 and j > 0 and dp[i][j] == dp[i-1][j-1] + (match if seq1[i-1]==seq2[j-1] else mismatch):
            align1.append(seq1[i-1]); align2.append(seq2[j-1])
            i -= 1; j -= 1
        elif i > 0 and dp[i][j] == dp[i-1][j] + gap:
            align1.append(seq1[i-1]); align2.append('-')
            i -= 1
        else:
            align1.append('-'); align2.append(seq2[j-1])
            j -= 1

    return dp[m][n], ''.join(reversed(align1)), ''.join(reversed(align2))

# 使用示例
score, a1, a2 = needleman_wunsch("ACGT", "AGT")
print(f"Score: {score}\n{a1}\n{a2}")
```

**核心要点**：
1. 使用动态规划（DP）解决全局比对问题
2. 时间复杂度 O(mn)，空间 O(mn)
3. 支持自定义匹配/错配/空位罚分
4. 返回比对得分和两条对齐序列

如需局部比对（Smith-Waterman），只需修改初始化逻辑和回溯终止条件。

[tokens: 634]

======================================================================
### 策略 B · 思维链 (CoT)
======================================================================

1. **核心问题**：给定两条DNA序列，找到最优比对（匹配/错配/缺口），常用于序列相似性分析。

2. **解决思路**：
   - **全局比对（Needleman-Wunsch）**：适合长度相近序列，动态规划保证最优，但O(n²)时空复杂度。
   - **局部比对（Smith-Waterman）**：找高相似片段，适合域分析，同样O(n²)。
   - **启发式（BLAST）**：速度快，但非最优，适合大规模搜索。

3. **推荐**：小工具选**全局比对**，实现简单且结果可解释，适合教学或短序列。

4. **代码示例**：
```python
from typing import Tuple, List

def needleman_wunsch(seq1: str, seq2: str, match: int = 1, mismatch: int = -1, gap: int = -1) -> Tuple[str, str, int]:
    n, m = len(seq1), len(seq2)
    dp = [[0] * (m+1) for _ in range(n+1)]

    # 初始化
    for i in range(n+1): dp[i][0] = i * gap
    for j in range(m+1): dp[0][j] = j * gap

    # 填充矩阵
    for i in range(1, n+1):
        for j in range(1, m+1):
            diag = dp[i-1][j-1] + (match if seq1[i-1] == seq2[j-1] else mismatch)
            up = dp[i-1][j] + gap
            left = dp[i][j-1] + gap
            dp[i][j] = max(diag, up, left)

    # 回溯
    i, j = n, m
    a1, a2 = [], []
    while i > 0 or j > 0:
        if i > 0 and j > 0 and dp[i][j] == dp[i-1][j-1] + (match if seq1[i-1] == seq2[j-1] else mismatch):
            a1.append(seq1[i-1]); a2.append(seq2[j-1]); i -= 1; j -= 1
        elif i > 0 and dp[i][j] == dp[i-1][j] + gap:
            a1.append(seq1[i-1]); a2.append('-'); i -= 1
        else:
            a1.append('-'); a2.append(seq2[j-1]); j -= 1

    return ''.join(reversed(a1)), ''.join(reversed(a2)), dp[n][m]

# 使用示例
s1, s2, score = needleman_wunsch("ACGT", "AGT")
print(f"{s1}\n{s2}\nScore: {score}")
```

[tokens: 738]

======================================================================
### 策略 C · Few-shot
======================================================================

```python
from typing import Tuple

def align_dna(seq1: str, seq2: str, match: int = 2, mismatch: int = -1, gap: int = -2) -> Tuple[int, str, str]:
    """
    基于 Needleman-Wunsch 算法的全局比对。

    Args:
        seq1: 第一条 DNA 序列
        seq2: 第二条 DNA 序列
        match/mismatch/gap: 打分参数

    Returns:
        (得分, 比对后序列1, 比对后序列2)
    """
    m, n = len(seq1), len(seq2)
    dp = [[0] * (n+1) for _ in range(m+1)]

    # 初始化
    for i in range(1, m+1):
        dp[i][0] = i * gap
    for j in range(1, n+1):
        dp[0][j] = j * gap

    # 动态规划
    for i in range(1, m+1):
        for j in range(1, n+1):
            score = match if seq1[i-1] == seq2[j-1] else mismatch
            dp[i][j] = max(
                dp[i-1][j-1] + score,
                dp[i-1][j] + gap,
                dp[i][j-1] + gap
            )

    # 回溯
    i, j = m, n
    align1, align2 = "", ""
    while i > 0 or j > 0:
        if i > 0 and j > 0 and dp[i][j] == dp[i-1][j-1] + (match if seq1[i-1] == seq2[j-1] else mismatch):
            align1 += seq1[i-1]
            align2 += seq2[j-1]
            i -= 1; j -= 1
        elif i > 0 and dp[i][j] == dp[i-1][j] + gap:
            align1 += seq1[i-1]
            align2 += "-"
            i -= 1
        else:
            align1 += "-"
            align2 += seq2[j-1]
            j -= 1

    return dp[m][n], align1[::-1], align2[::-1]
```

**使用示例**：
```python
score, a1, a2 = align_dna("ACGT", "AGT")
print(f"得分: {score}\n{a1}\n{a2}")
# 输出：
# 得分: 2
# ACGT
# A-GT
```

**说明**：
- 采用全局比对算法，适合长度相近的序列
- 支持自定义打分参数
- 返回比对结果和得分，便于后续分析

第五步：写第一个Prompt模板

创建prompts/ 目录的组织方式

Linux：

mkdir -p prompts/research
touch prompts/research/day03_prompt_direct.txt
touch prompts/research/day03_prompt_cot.txt
touch prompts/research/day03_prompt_fewshot.txt

Windows PowerShell：

ni prompts\research -ItemType Directory -Force
ni prompts\research\day03_prompt_direct.txt -Force
ni prompts\research\day03_prompt_cot.txt -Force
ni prompts\research\day03_prompt_fewshot.txt -Force

模板1：直接提问

[问题]

模板2：思维链

[问题]

请一步步分析：

1. [维度 1：根据问题类型填]
2. [维度 2]
3. [维度 3]

模板3：Few-shot工程问答

你是 [方向] 方向的资深工程师，回答结构化、可执行。

示例问题：[示例 1]
示例答案：
1. [答案 1]
2. [答案 2]
3. [答案 3]

示例问题：[示例 2]
示例答案：
1. [答案 1]
2. [答案 2]
...

现在请回答：

[你的问题]

小结

理解temperature 0/0.3/0.7/1.2 四档差异

理解top_p与temperature协同

掌握prompt三板斧：直接/CoT/Few-shot

首次建立prompt模板库

n4X7-1786112390510)]

第五步：写第一个Prompt模板

创建prompts/ 目录的组织方式

Linux：

mkdir -p prompts/research
touch prompts/research/day03_prompt_direct.txt
touch prompts/research/day03_prompt_cot.txt
touch prompts/research/day03_prompt_fewshot.txt

Windows PowerShell：

ni prompts\research -ItemType Directory -Force
ni prompts\research\day03_prompt_direct.txt -Force
ni prompts\research\day03_prompt_cot.txt -Force
ni prompts\research\day03_prompt_fewshot.txt -Force

模板1：直接提问

[问题]

模板2：思维链

[问题]

请一步步分析：

1. [维度 1：根据问题类型填]
2. [维度 2]
3. [维度 3]

模板3：Few-shot工程问答

你是 [方向] 方向的资深工程师，回答结构化、可执行。

示例问题：[示例 1]
示例答案：
1. [答案 1]
2. [答案 2]
3. [答案 3]

示例问题：[示例 2]
示例答案：
1. [答案 1]
2. [答案 2]
...

现在请回答：

[你的问题]

小结

理解temperature 0/0.3/0.7/1.2 四档差异

理解top_p与temperature协同

掌握prompt三板斧：直接/CoT/Few-shot

首次建立prompt模板库

量化对比能力