【人工智能】新手指南：用提示词优化代码的3个实用技巧

新手指南：用提示词优化代码的 3 个实用技巧

在编程学习和开发过程中，新手常遇到代码运行效率低、可读性差、存在 bug 却难以定位的问题。借助大模型的代码处理能力，通过合理的提示词引导，能快速优化代码质量 —— 比如让冗余代码更简洁、让低效算法更高效、让混乱代码更易读。但很多新手不知道如何写提示词，导致大模型优化后的代码仍不符合预期。本文将聚焦新手需求，详细讲解用提示词优化代码的 3 个核心实用技巧，每个技巧都搭配具体场景案例、提示词模板和效果对比，帮助新手快速上手，用提示词轻松优化代码。

一、基础认知：为什么提示词能优化代码？

1.1 大模型的代码处理能力

目前主流大模型（如 GPT-4、Claude 3、CodeLlama）通过训练海量代码数据，具备了代码理解、语法纠错、逻辑优化、性能提升等能力。它们能识别代码中的冗余结构、低效算法、语法错误，还能根据编程语言规范（如 Python 的 PEP 8、Java 的 Google 编码规范）调整代码格式和风格。

比如输入一段存在冗余循环的 Python 代码，模型能识别出 “重复执行的相同逻辑”，并优化为更简洁的列表推导式；输入一段缩进混乱的 Java 代码，模型能按规范调整缩进，补充必要注释，提升可读性。

1.2 提示词的核心作用

提示词是连接用户需求和大模型能力的桥梁。没有提示词时，模型不知道用户需要 “优化代码的哪方面”（是性能、可读性还是 bug 修复）；有了清晰的提示词，能明确告诉模型 “优化目标、优化标准、输出要求”，让模型精准发力，避免优化方向偏差。

比如简单说 “优化这段代码”，模型可能只做简单格式调整；而提示词 “优化这段 Python 代码：1. 目标：提升循环执行效率，减少运行时间；2. 标准：用列表推导式或内置函数替代 for 循环；3. 输出：对比优化前后的代码，说明优化思路和效率提升点”，模型会按要求聚焦性能优化，给出更有价值的结果。

1.3 新手用提示词优化代码的优势

1.3.1 降低优化门槛

新手对 “代码优化技巧”（如算法选择、语法简化）掌握不足，通过提示词让模型给出优化方案，无需自己深入研究优化原理，就能快速得到高质量代码。

1.3.2 节省时间成本

手动优化代码需要反复调试、验证，新手可能花费几小时才能解决一个性能问题；用提示词引导模型优化，几分钟就能得到优化结果，再结合手动验证，大幅节省时间。

1.3.3 学习优化思路

模型在优化代码时，若提示词要求 “说明优化思路”，新手能通过模型的解释，理解 “为什么这样优化”“优化依据是什么”，间接学习代码优化知识，提升自身编程能力。

二、实用技巧一：明确 “优化维度”，让提示词聚焦目标

2.1 核心逻辑

代码优化包含多个维度（性能、可读性、语法纠错、兼容性等），新手若不明确维度，提示词会过于宽泛，模型可能 “雨露均沾” 却没做好重点优化。明确 “优化维度”，就是在提示词中清晰指出 “要优化代码的哪一方面”，让模型集中资源解决核心问题。

比如需要优化一段 “处理数据的 Python 代码”，若目标是 “让代码运行更快”，就明确 “优化维度为性能”；若目标是 “让同事能看懂代码”，就明确 “优化维度为可读性”。

2.2 常见优化维度及提示词模板

2.2.1 维度 1：性能优化（提升运行效率）

适用场景：代码运行慢（如循环次数多、算法复杂）、占用内存高，需要减少运行时间或内存消耗。

提示词模板：

“请优化以下 [编程语言，如 Python/Java] 代码，优化维度为性能，具体要求：

1. 分析当前代码的性能瓶颈（如冗余循环、低效算法、重复计算）；

1. 针对瓶颈进行优化，优先使用 [具体优化方式，如 “内置函数替代 for 循环”“更高效的算法（如哈希表）”“减少变量重复创建”]；

1. 输出内容包含：① 优化前代码；② 优化后代码；③ 性能瓶颈分析（100 字以内）；④ 优化思路（说明用了什么方法，为什么能提升性能，100 字以内）；⑤ 优化前后的运行时间对比（假设测试数据：[具体测试数据，如 “处理 10000 条数据”]，估算时间即可）。

待优化代码：

[粘贴需要优化的代码]”

2.2.2 维度 2：可读性优化（提升代码易懂性）

适用场景：代码缩进混乱、变量命名不规范、无注释或注释模糊，需要让代码更易读、易维护。

提示词模板：

“请优化以下 [编程语言，如 Python/Java] 代码，优化维度为可读性，具体要求：

1. 按 [编程语言规范，如 “Python PEP 8 规范”“Java Google 编码规范”] 调整代码格式（缩进、空格、换行）；

1. 优化变量 / 函数命名：命名要见名知意（如将 “a” 改为 “user_count”，将 “f1 ()” 改为 “calculate_total_price ()”）；

1. 补充注释：① 在函数 / 类上方添加 “功能说明 + 参数含义 + 返回值含义” 的注释；② 在复杂逻辑（如条件判断、循环）处添加行注释，说明 “为什么这么写”；

1. 输出内容包含：① 优化前代码；② 优化后代码；③ 可读性优化点总结（分点说明：格式调整、命名优化、注释补充的具体内容）。

待优化代码：

[粘贴需要优化的代码]”

2.2.3 维度 3：语法纠错优化（修复代码错误）

适用场景：代码运行报错（如语法错误、逻辑错误、变量未定义），新手无法快速定位和修复。

提示词模板：

“请优化以下 [编程语言，如 Python/Java] 代码，优化维度为语法纠错，具体要求：

1. 先分析代码中的错误（包括语法错误，如括号缺失、变量未定义；逻辑错误，如条件判断错误、循环边界错误）；

1. 修复所有错误，确保代码能正常运行；

1. 输出内容包含：① 原始报错信息（若有，可粘贴；若无，说明 “代码运行时出现 XX 问题，如无输出、结果错误”）；② 错误分析（分点说明每个错误的位置和原因，100 字以内）；③ 修复后代码；④ 修复思路（说明每个错误是如何修复的，为什么这么修复，100 字以内）。

待优化代码：

[粘贴需要优化的代码]

原始报错信息（可选）：

[粘贴报错信息，如 “NameError: name 'x' is not defined”]”

2.3 场景案例：性能优化（Python 代码）

2.3.1 待优化代码（计算 1-10000 内偶数的平方和）

# 计算1-10000内偶数的平方和

total = 0

for i in range(1, 10001):

if i % 2 == 0:

square = i * i

total = total + square

print(total)

问题：用普通 for 循环遍历 1-10000 个数字，再判断是否为偶数，存在冗余循环和判断，运行效率较低。

2.3.2 提示词示例

“请优化以下 Python 代码，优化维度为性能，具体要求：

1. 分析当前代码的性能瓶颈；

1. 针对瓶颈进行优化，优先使用 “列表推导式” 或 “内置函数（如 sum、filter）” 替代 for 循环；

1. 输出内容包含：① 优化前代码；② 优化后代码；③ 性能瓶颈分析；④ 优化思路；⑤ 优化前后的运行时间对比（测试数据：处理 1-10000 内偶数的平方和）。

待优化代码：

计算 1-10000 内偶数的平方和

total = 0

for i in range(1, 10001):

if i % 2 == 0:

square = i * i

total = total + square

print(total)”

2.3.3 模型输出结果

1. 优化前代码：

# 计算1-10000内偶数的平方和

total = 0

for i in range(1, 10001):

if i % 2 == 0:

square = i * i

total = total + square

print(total)

1. 优化后代码：

# 计算1-10000内偶数的平方和

total = sum(i * i for i in range(2, 10001, 2)) # 直接生成偶数序列，用生成器表达式计算平方和

print(total)

1. 性能瓶颈分析：

当前代码用 for 循环遍历 1-10000 个数字，再通过 if 判断筛选偶数，存在 “遍历多余奇数” 和 “手动累加计算” 的冗余操作，增加了运行时间。

1. 优化思路：

用 range (2, 10001, 2) 直接生成 1-10000 内的偶数序列（步长为 2，从 2 开始），减少 “筛选奇数” 的判断；用 sum () 内置函数替代手动累加，sum () 是 C 语言实现的内置函数，运行速度比 Python 手动循环更快。

1. 运行时间对比：

• 优化前：遍历 10000 个数字 + 10000 次判断 + 5000 次累加，估算运行时间约 0.002 秒；

• 优化后：生成 5000 个偶数 + 1 次 sum () 计算，估算运行时间约 0.0005 秒，效率提升约 4 倍。

2.3.4 新手操作建议

优化后，新手可通过 Python 的 time 模块验证实际运行时间：

import time

# 测试优化前代码

start1 = time.time()

total1 = 0

for i in range(1, 10001):

if i % 2 == 0:

total1 = total1 + i * i

end1 = time.time()

print(f"优化前运行时间：{end1 - start1:.6f}秒")

# 测试优化后代码

start2 = time.time()

total2 = sum(i * i for i in range(2, 10001, 2))

end2 = time.time()

print(f"优化后运行时间：{end2 - start2:.6f}秒")

通过实际测试，能更直观看到优化效果，同时理解 “内置函数比手动循环高效” 的原因。

三、实用技巧二：补充 “上下文信息”，让提示词更精准

3.1 核心逻辑

新手优化代码时，常只粘贴代码却不提供 “上下文信息”（如代码用途、运行环境、输入输出要求），导致模型误解代码的实际场景，优化后的代码虽 “看似优化”，却不符合实际使用需求。补充 “上下文信息”，就是在提示词中告诉模型 “代码是做什么的”“在什么环境下运行”“有什么特殊约束”，让模型的优化贴合实际场景。

比如一段 “处理 Excel 数据的 Python 代码”，若不说明 “Excel 文件的格式（如.xlsx/.csv）”“数据量大小（如 100 行 / 10 万行）”，模型可能优化为 “只适合小数据量的方法”，导致处理 10 万行数据时仍效率低下。

3.2 必补充的上下文信息类型

3.2.1 信息 1：代码用途（核心功能）

说明代码的核心目标，让模型知道 “优化不能改变代码的原始功能”。比如 “这段代码用于从 MySQL 数据库中查询用户订单数据，计算每个用户的月度消费总额”“这段代码用于读取本地 CSV 文件，筛选出年龄大于 18 岁的用户信息并保存到新文件”。

3.2.2 信息 2：运行环境（约束条件）

说明代码的运行环境和约束，如 “运行在 Python 3.8 环境，不能使用 Python 3.9 及以上的新语法”“运行在嵌入式设备中，内存有限，优化时需控制内存占用”“依赖的第三方库：只能使用 pandas，不能使用 numpy（项目已固定依赖）”。

3.2.3 信息 3：输入输出要求（数据特征）

说明代码的输入数据特征（如数据量、格式）和输出要求（如输出格式、精度），如 “输入数据是 10 万行的 CSV 文件，每行包含‘用户 ID、消费金额、消费时间’3 列”“输出结果需要保留 2 位小数，且按‘用户 ID’升序排序”“输入的字符串可能包含中文和特殊字符（如‘#、@’），优化时需确保字符处理正确”。

3.3 提示词模板（含上下文信息）

以 “优化 Python 数据处理代码” 为例，模板如下：

“请优化以下 Python 代码，具体要求：

1. 优化维度：[选择维度，如 “性能”“可读性”]；

1. 上下文信息：

① 代码用途：从本地 CSV 文件（包含 “用户 ID、商品 ID、购买数量、单价、购买时间”5 列）中，计算每个商品的总销量（购买数量之和），并将结果保存到新的 CSV 文件；

② 运行环境：Python 3.7，依赖库只能使用 pandas（版本 1.3.5），不能使用其他库；

③ 输入输出要求：输入 CSV 文件约 10 万行数据，输出 CSV 文件需包含 “商品 ID、总销量”2 列，且按 “总销量” 降序排序；

1. 输出内容：① 优化前代码；② 优化后代码；③ 优化思路（说明如何结合上下文信息进行优化）；④ 验证方法（如何验证优化后的代码功能与原代码一致）。

待优化代码：

[粘贴需要优化的代码]”

3.4 场景案例：含上下文的可读性优化（Python 代码）

3.4.1 待优化代码（处理 CSV 数据）

import pandas as pd

def f(d):

d1 = d.groupby('商品ID')['购买数量'].sum()

d2 = d1.reset_index()

d2.columns = ['a', 'b']

d2 = d2.sort_values('b', ascending=False)

d2.to_csv('r.csv', index=False)

return d2

df = pd.read_csv('s.csv')

result = f(df)

print(result.head())

问题：函数命名 “f ()”、变量命名 “d/d1/d2/a/b” 无意义，无注释，代码格式混乱，且未说明上下文，模型若误判 “数据量小”，优化可能不贴合 10 万行数据场景。

3.4.2 提示词示例

“请优化以下 Python 代码，具体要求：

1. 优化维度：可读性；

1. 上下文信息：

① 代码用途：从本地 CSV 文件（s.csv，包含 “用户 ID、商品 ID、购买数量、单价、购买时间”5 列）中，计算每个商品的总销量（购买数量之和），并将结果保存到新的 CSV 文件（r.csv）；

② 运行环境：Python 3.7，依赖库为 pandas 1.3.5，无需考虑性能（数据量 10 万行已满足当前需求）；

③ 输入输出要求：输入 s.csv 约 10 万行，输出 r.csv 需包含 “商品 ID、总销量”2 列，按 “总销量” 降序排序，输出前 5 行结果；

1. 输出内容：① 优化前代码；② 优化后代码；③ 优化思路；④ 验证方法。

待优化代码：

import pandas as pd

def f (d):

d1 = d.groupby (' 商品 ID')[' 购买数量 '].sum ()

d2 = d1.reset_index ()

d2.columns = ['a', 'b']

d2 = d2.sort_values ('b', ascending=False)

d2.to_csv ('r.csv', index=False)

return d2

df = pd.read_csv('s.csv')

result = f(df)

print(result.head())”

3.4.3 模型输出结果

1. 优化前代码：

import pandas as pd

def f(d):

d1 = d.groupby('商品ID')['购买数量'].sum()

d2 = d1.reset_index()

d2.columns = ['a', 'b']

d2 = d2.sort_values('b', ascending=False)

d2.to_csv('r.csv', index=False)

return d2

df = pd.read_csv('s.csv')

result = f(df)

print(result.head())

1. 优化后代码：

import pandas as pd

def calculate_product_total_sales(input_df):

"""

计算每个商品的总销量，并将结果保存到CSV文件

参数：

input_df (pd.DataFrame): 输入数据框，需包含"商品ID"和"购买数量"列（来自s.csv）

返回：

pd.DataFrame: 包含"商品ID"和"总销量"的结果数据框，按总销量降序排序

"""

# 按商品ID分组，计算每个商品的购买数量之和（即总销量）

product_sales = input_df.groupby('商品ID')['购买数量'].sum()

# 将Series转换为DataFrame，重置索引（让商品ID从索引变为列）

product_sales_df = product_sales.reset_index()

# 重命名列：确保列名见名知意

product_sales_df.columns = ['商品ID', '总销量']

# 按总销量降序排序（满足输出要求）

sorted_sales_df = product_sales_df.sort_values('总销量', ascending=False)

# 保存结果到CSV文件（输出文件名为r.csv，不保留索引列）

sorted_sales_df.to_csv('r.csv', index=False)

return sorted_sales_df

# 读取输入CSV文件（s.csv）

input_dataframe = pd.read_csv('s.csv')

# 调用函数计算商品总销量

sales_result = calculate_product_total_sales(input_dataframe)

# 打印结果的前5行（验证输出格式）

print("商品总销量前5名：")

print(sales_result.head())

1. 优化思路：

① 命名优化：将无意义的 “f ()” 改为 “calculate_product_total_sales ()”（体现函数功能），“d/d1/d2” 改为 “input_df/product_sales/product_sales_df”（体现数据含义），“a/b” 改为 “商品 ID / 总销量”（与业务含义一致）；

② 注释补充：函数上方添加 “功能 + 参数 + 返回值” 注释，复杂逻辑处添加行注释（如分组计算、列重命名），说明 “为什么这么做”；

③ 格式调整：按 Python PEP 8 规范调整缩进（4 个空格）、换行（运算符前后空格），添加打印说明（如 “商品总销量前 5 名：”），提升可读性；

④ 贴合上下文：保留 pandas 依赖，未引入其他库，确保符合 “Python 3.7+ pandas 1.3.5” 的环境要求，输出格式与 “商品 ID、总销量” 的要求一致。

1. 验证方法：

① 功能验证：分别运行优化前和优化后代码，对比输出的 “r.csv” 文件内容（如商品 ID 对应的总销量是否一致）、打印的前 5 行结果是否相同，确保功能未改变；

② 可读性验证：让其他新手同事阅读两段代码，判断优化后代码是否能更快理解 “代码做什么、每个步骤的作用”。

四、实用技巧三：添加 “示例引导”，让提示词对齐预期

4.1 核心逻辑

新手对 “优化效果” 有预期（如希望代码用特定语法、特定结构），但只用文字描述难以让模型精准对齐预期。添加 “示例引导”，就是在提示词中给出 “符合预期的优化示例”（如优化后的代码片段、命名风格示例），让模型参考示例进行优化，确保结果符合新手的具体要求。

比如新手希望将 “for 循环优化为列表推导式”，但不确定如何描述，就可以在提示词中给出示例：“优化示例：将‘for i in range (5): list.append (i)’优化为‘list = [i for i in range (5)]’”，模型会参考示例的优化方式处理目标代码。

4.2 示例引导的两种常见形式

4.2.1 形式 1：优化方式示例（告诉模型 “用什么方法优化”）

适用于新手知道 “要用到的优化方法”，但不确定如何让模型应用该方法的场景。比如 “用 lambda 函数替代简单的 def 函数”“用 try-except 捕获特定异常”，可给出方法示例。

示例模板：

“优化方式示例：

• 原代码（简单函数）：def add (a, b): return a + b

• 优化后（lambda 函数）：add = lambda a, b: a + b

请参考以上示例，将待优化代码中的简单函数（只有 1 行返回值）优化为 lambda 函数，其他部分保持功能不变。”

4.2.2 形式 2：输出格式示例（告诉模型 “优化后是什么样”）

适用于新手对 “优化后的代码格式、风格” 有明确要求，比如 “注释格式为‘# 功能：XXX’”“变量命名为‘小写 + 下划线’风格”，可给出格式示例。

示例模板：

“输出格式示例：

1. 注释格式：# 功能：读取 CSV 文件，参数为文件路径

1. 变量命名：user_info、order_total、calculate_price（小写 + 下划线）

1. 代码缩进：每个层级缩进 4 个空格，函数内代码与 def 行缩进一致

请参考以上示例，优化待优化代码的格式和命名，确保符合示例风格。”

4.3 提示词模板（含示例引导）

以 “优化 Java 代码的异常处理” 为例，模板如下：

“请优化以下 Java 代码，具体要求：

1. 优化维度：语法纠错 + 可读性（添加异常处理，避免运行报错）；

1. 上下文信息：代码用途是读取本地 txt 文件（路径为 “D:/test.txt”），输出文件内容；运行环境为 Java 8；

1. 示例引导（异常处理示例）：

原代码（无异常处理）：

FileReader fr = new FileReader ("test.txt");

BufferedReader br = new BufferedReader (fr);

String line = br.readLine ();

优化后（含异常处理）：

try (FileReader fr = new FileReader ("test.txt");

BufferedReader br = new BufferedReader (fr)) {

String line = br.readLine ();

while (line != null) {

System.out.println (line);

line = br.readLine ();

}

} catch (FileNotFoundException e) {

System.out.println ("文件未找到：" + e.getMessage ());

} catch (IOException e) {

System.out.println ("文件读取错误：" + e.getMessage ());

}

1. 输出内容：① 优化前代码；② 优化后代码；③ 优化说明（对比示例，说明如何参考示例进行异常处理）。

待优化代码：

[粘贴需要优化的 Java 代码]”

4.4 场景案例：示例引导的语法纠错优化（Java 代码）

4.4.1 待优化代码（读取 txt 文件，无异常处理）

import java.io.FileReader;

import java.io.BufferedReader;

public class ReadFile {

public static void main(String[] args) {

FileReader fr = new FileReader("D:/test.txt");

BufferedReader br = new BufferedReader(fr);

String line = br.readLine();

while (line != null) {

System.out.println(line);

line = br.readLine();

}

br.close();

fr.close();

}

}

问题：无异常处理（若文件不存在或读取错误，会直接报错崩溃），且未使用 Java 8 的 try-with-resources 语法（可能导致流未关闭，占用资源）。

4.4.2 提示词示例

“请优化以下 Java 代码，具体要求：

1. 优化维度：语法纠错 + 可读性（添加异常处理，确保文件流正确关闭）；

1. 上下文信息：代码用途是读取本地 txt 文件（路径 “D:/test.txt”）并打印内容；运行环境为 Java 8；

1. 示例引导（异常处理 + try-with-resources 示例）：

原代码（无异常处理）：

FileReader fr = new FileReader ("test.txt");

BufferedReader br = new BufferedReader (fr);

String line = br.readLine ();

优化后（含异常处理）：

try (FileReader fr = new FileReader ("test.txt");

BufferedReader br = new BufferedReader (fr)) {

String line = br.readLine ();

while (line != null) {

System.out.println (line);

line = br.readLine ();

}

} catch (FileNotFoundException e) {

System.out.println ("文件未找到：" + e.getMessage ());

} catch (IOException e) {

System.out.println ("文件读取错误：" + e.getMessage ());

}

1. 输出内容：① 优化前代码；② 优化后代码；③ 优化说明。

待优化代码：

import java.io.FileReader;

import java.io.BufferedReader;

public class ReadFile {

public static void main(String[] args) {

FileReader fr = new FileReader("D:/test.txt");

BufferedReader br = new BufferedReader(fr);

String line = br.readLine();

while (line != null) {

System.out.println(line);

line = br.readLine();

}

br.close();

fr.close();

}

}”

4.4.3 模型输出结果

1. 优化前代码：

import java.io.FileReader;

import java.io.BufferedReader;

public class ReadFile {

public static void main(String[] args) {

FileReader fr = new FileReader("D:/test.txt");

BufferedReader br = new BufferedReader(fr);

String line = br.readLine();

while (line != null) {

System.out.println(line);

line = br.readLine();

}

br.close();

fr.close();

}

}

1. 优化后代码：

import java.io.FileReader;

import java.io.BufferedReader;

import java.io.FileNotFoundException;

import java.io.IOException; // 导入所需异常类

public class ReadFile {

public static void main(String[] args) {

// 参考示例，使用try-with-resources语法（Java 8+），自动关闭文件流，无需手动close()

try (FileReader fr = new FileReader("D:/test.txt");

BufferedReader br = new BufferedReader(fr)) {

String line = br.readLine();

// 循环读取文件内容，直到读取到null（文件末尾）

while (line != null) {

System.out.println(line);

line = br.readLine(); // 读取下一行

}

} catch (FileNotFoundException e) {

// 捕获“文件未找到”异常，给出友好提示（参考示例格式）

System.out.println("文件未找到：" + e.getMessage());

} catch (IOException e) {

// 捕获“文件读取错误”异常（如权限不足、文件损坏）

System.out.println("文件读取错误：" + e.getMessage());

}

}

}

1. 优化说明：

① 异常处理：参考示例，添加了 FileNotFoundException（文件未找到）和 IOException（读取错误）的捕获，避免代码直接崩溃，同时输出友好的错误提示，方便定位问题；

② 资源关闭：参考示例的 try-with-resources 语法，将 FileReader 和 BufferedReader 放在 try 后的括号中，Java 会自动在代码执行完后关闭文件流，解决了原代码 “手动 close () 可能未执行” 的问题（如中间报错导致 close () 被跳过）；

③ 语法完善：导入了所需的异常类（FileNotFoundException、IOException），原代码缺少导入会导致编译报错，优化后确保代码能正常编译运行。

4.4.1 新手操作建议

优化后，新手可通过两种方式验证：

1. 正常场景：在 D 盘创建 test.txt 文件，写入几行内容，运行代码，查看是否能正确打印内容；

1. 异常场景：删除 D 盘的 test.txt 文件，运行代码，查看是否输出 “文件未找到” 的提示（而非报错崩溃），确保异常处理生效。

五、用提示词优化代码的常见问题及解决方法

5.1 问题一：模型优化后的代码功能改变

5.1.1 问题表现

优化后的代码与原代码功能不一致，比如原代码 “计算 1-10 的偶数和”，优化后代码 “计算 1-10 的奇数和”，或原代码 “保存数据到 CSV”，优化后代码 “保存数据到 TXT”。

5.1.2 错误原因

1. 提示词未明确 “保留原功能”，模型为了优化可能简化或修改了核心逻辑；

1. 未提供 “原代码功能说明”，模型误解了代码的核心目标（如把 “筛选偶数” 误解为 “筛选奇数”）；

1. 示例引导中的示例与原功能冲突，模型参考示例时偏离了原目标。

5.1.3 解决方法

1. 提示词中强制要求 “保留原功能”：在提示词开头添加 “优化时必须保证代码功能与原代码完全一致，不得改变核心逻辑（如计算逻辑、输入输出目标）”；

1. 详细说明原代码功能：在上下文信息中添加 “原代码核心功能：XXX”，如 “原代码核心功能：计算 1-100 内所有偶数的和，输出结果为整数”；

1. 检查示例与原功能的一致性：确保示例引导中的示例与原代码功能相关，不冲突，比如原代码是 “CSV 数据处理”，示例不要用 “TXT 数据处理” 的例子。

5.2 问题二：模型优化过度，代码复杂度增加

5.2.1 问题表现

模型为了追求 “极致优化”，将简单代码改为复杂代码，比如原代码 “用 for 循环计算求和”（新手能理解），优化后代码 “用复杂的递归 + lambda 函数计算求和”（新手无法理解，且没必要），或原代码处理 100 行数据，优化后代码添加了 “分布式处理” 的复杂逻辑（过度优化）。

5.2.2 错误原因

1. 提示词未明确 “优化程度”，模型默认按 “最高标准” 优化，忽略了新手的理解能力和实际需求；

1. 未说明 “代码的使用场景”（如数据量、维护人员），模型不知道 “代码只需满足简单场景”。

5.2.3 解决方法

1. 提示词中明确 “优化程度”：添加 “优化后的代码需符合新手理解能力，避免使用复杂语法（如递归、高级设计模式）和冗余逻辑，以‘简洁、易懂’为优先，而非‘极致性能’”；

1. 说明使用场景的约束：在上下文信息中添加 “使用场景：处理 100 行以内的小数据量，维护人员为编程新手，代码需易于理解和修改”，让模型根据场景调整优化程度；

1. 限制优化方法：在提示词中指定 “只能使用 XXX 优化方法”，如 “只能使用列表推导式优化 for 循环，不得使用递归、多线程等复杂方法”。

5.3 问题三：模型无法优化特定类型代码

5.3.1 问题表现

对于某些特定代码（如小众编程语言代码、包含特殊业务逻辑的代码），模型无法给出有效优化，比如输出 “无法识别该编程语言”“无法理解业务逻辑，无法优化”，或优化结果只是简单格式调整，无实质优化。

5.3.2 错误原因

1. 模型对小众编程语言（如 Rust、Go 以外的冷门语言）的支持不足，训练数据少，无法理解语法和优化技巧；

1. 代码包含特殊业务逻辑（如公司内部的加密算法、自定义数据格式处理），提示词未提供业务逻辑说明，模型无法理解代码含义，无法优化；

1. 提示词中的代码格式混乱（如缩进错误、语法错误过多），模型无法正确解析代码，自然无法优化。

5.3.3 解决方法

1. 选择支持目标语言的模型：先确认模型支持的编程语言（如 GPT-4 支持 Python、Java、C++ 等主流语言，CodeLlama 对代码的支持更专业），小众语言优先使用专门的代码模型；

1. 补充特殊业务逻辑说明：在上下文信息中添加 “业务逻辑说明：XXX”，如 “业务逻辑：这段代码是公司内部的用户密码加密逻辑，其中‘encrypt ()’函数是自定义加密函数，优化时不得修改该函数，只需优化调用逻辑”；

1. 先修复代码基础错误：若原代码存在语法错误或格式混乱，先让模型 “先修复语法错误和格式”，再进行优化，可使用 “语法纠错优化” 的提示词模板，修复后再用其他优化技巧。

5.4 问题四：优化后的代码存在潜在 bug

5.4.1 问题表现

优化后的代码能运行，但存在潜在问题，比如原代码 “处理字符串时区分大小写”，优化后代码 “不区分大小写”（导致数据错误），或优化后的代码在特定输入下报错（如输入为空时崩溃），但模型未发现。

5.4.2 错误原因

1. 提示词未要求 “验证优化后的代码”，模型只关注 “优化”，未考虑边界场景（如空输入、异常数据）；

1. 未提供 “测试数据”，模型无法模拟实际输入验证代码是否存在 bug；

1. 模型自身的局限性：对于复杂的边界场景，模型可能无法完全覆盖，导致遗漏潜在 bug。

5.4.3 解决方法

1. 提示词要求模型 “验证代码”：添加 “优化后需提供‘测试方案’，包括至少 3 种测试场景（正常输入、边界输入如空数据、异常输入如错误格式），并说明每种场景的预期输出，确保代码在所有场景下无 bug”；

1. 提供具体测试数据：在提示词中添加 “测试数据：① 正常输入：XXX；② 边界输入：XXX；③ 异常输入：XXX”，如 “测试数据：① 正常输入：[1,2,3,4]；② 边界输入：[]（空列表）；③ 异常输入：[1,'a',3]（包含非数字）”；

1. 新手手动验证：优化后，新手需用测试数据实际运行代码，检查是否存在 bug，尤其是模型未覆盖的场景，不要完全依赖模型的优化结果。

六、用提示词优化代码的工具推荐

6.1 提示词生成工具（快速生成优化提示词）

6.1.1 豆包提示词生成器

• 特点：支持 “代码优化提示词” 专项生成，新手只需输入 “编程语言（如 Python/Java）”“优化维度（性能 / 可读性 / 纠错）”“上下文信息（代码用途、运行环境）”，工具会自动生成包含 “维度要求、上下文、输出格式” 的完整提示词；生成的提示词语言简单，符合大模型理解习惯，无需手动梳理结构。

• 适用人群：新手，适合快速生成符合要求的优化提示词，节省时间。

• 使用步骤：1. 打开豆包提示词生成器，选择 “代码优化” 分类；2. 输入编程语言（如 “Python”）；3. 选择优化维度（如 “性能优化”）；4. 填写上下文信息（代码用途：“计算偶数和”，运行环境：“Python 3.8”）；5. 点击 “生成”，工具生成提示词；6. 复制提示词，粘贴到大模型中，补充待优化代码即可。

6.1.2 PromptBase（代码优化提示词模板）

• 特点：包含大量 “代码优化提示词” 模板，覆盖 Python、Java、C++ 等主流语言，每个模板都针对特定优化场景（如 “Python 列表推导式优化”“Java 异常处理优化”“代码可读性规范优化”）；模板中已包含 “维度要求、上下文示例、输出格式”，新手只需替换 “待优化代码” 和 “具体上下文” 即可使用。

• 适用人群：所有用户，适合快速找到对应语言和场景的模板，避免从零开始写提示词。

• 使用步骤：1. 打开 PromptBase 官网，搜索 “代码优化”+ 编程语言（如 “Python code optimization”）；2. 浏览模板，选择与需求匹配的（如 “Python Performance Optimization Prompt”）；3. 查看模板内容，替换模板中的 “[待优化代码]”“[上下文信息]” 为自己的内容；4. 将修改后的提示词输入大模型，生成优化结果。

6.2 代码优化大模型推荐

6.2.1 CodeLlama（Meta 推出，代码专用模型）

• 特点：专门针对代码处理优化的大模型，支持 Python、Java、C++、JavaScript 等多种主流编程语言；对代码的理解和优化能力强，尤其擅长 “性能优化”“语法纠错”“代码补全”；支持生成详细的优化思路和注释，适合新手学习；开源版本可本地部署，适合对数据隐私有要求的场景。

• 适用人群：新手，尤其是需要频繁处理代码优化的用户。

• 使用方式：1. 在线使用：通过 Hugging Face、Replicate 等平台在线调用；2. 本地部署：下载开源模型（如 CodeLlama-7B-Code），使用 PyTorch 或 TensorFlow 框架部署，适合有一定环境配置能力的新手；3. 提示词适配：使用本文中的提示词模板，无需额外调整，模型能准确理解 “优化维度、上下文信息”。

6.2.2 GPT-4（通用大模型，代码优化能力强）

• 特点：通用大模型中代码处理能力顶尖，能理解复杂代码逻辑，支持多语言代码优化；擅长 “结合上下文信息优化”，比如根据 “数据量、运行环境” 调整优化策略；能生成详细的优化说明和验证方法，帮助新手理解优化思路；支持多轮交互，若优化结果不符合预期，可通过追问调整（如 “再优化一下，不要用递归”）。

• 适用人群：所有用户，适合处理复杂代码优化（如多语言混合代码、包含业务逻辑的代码）。

• 使用方式：1. 在线使用：通过 ChatGPT 官网或 API 调用；2. 提示词使用：直接输入本文中的提示词模板，补充待优化代码和上下文信息；3. 多轮优化：若第一次优化结果不佳，追问 “请修改优化方式，要求：1. 保留原功能；2. 不使用 XXX 语法；3. 补充注释”，模型会根据追问调整。

6.2.3 通义千问（阿里推出，中文提示词适配好）

• 特点：对中文提示词的理解能力强，适合新手用中文撰写提示词（如 “优化这段 Python 代码，提升可读性”）；支持主流编程语言，优化结果符合中文开发者的编码习惯（如注释用中文，命名符合中文业务场景）；提供 “代码解释” 功能，能详细说明优化后的代码每一步的作用，帮助新手理解。

• 适用人群：中文新手用户，适合用中文沟通和理解优化过程。

• 使用方式：1. 在线使用：通过通义千问官网或 APP；2. 提示词使用：直接用中文输入提示词，如 “请优化以下 Python 代码，要求：1. 提升运行效率；2. 代码用途是处理 10 万行 CSV 数据；3. 输出优化前后的代码和思路”；3. 代码解释：生成优化结果后，可追问 “请解释优化后代码的每一步作用”，模型会用中文详细说明。

6.3 代码验证工具（验证优化后代码的正确性）

6.3.1 在线代码运行平台（如 JDoodle、OnlineGDB）

• 特点：支持多编程语言在线运行代码，无需本地配置环境；能快速运行优化前后的代码，对比输出结果是否一致；支持输入测试数据，验证代码在不同场景下的运行情况；部分平台（如 JDoodle）支持代码语法检查，能提前发现语法错误。

• 适用人群：所有新手，适合快速验证代码功能和语法正确性。

• 使用步骤：1. 打开平台（如 JDoodle），选择目标编程语言（如 Python）；2. 粘贴优化前代码，输入测试数据，点击 “Run”，记录输出结果；3. 粘贴优化后代码，输入相同测试数据，点击 “Run”，对比两次输出结果是否一致；4. 若不一致，返回大模型调整提示词，重新优化。

6.3.2 代码质量检查工具（如 SonarLint、Pylint）

• 特点：专门检查代码质量，包括 “可读性（命名、注释）”“性能（冗余代码、低效算法）”“语法规范（缩进、空格）”；能生成详细的质量报告，指出优化后的代码是否仍存在问题（如 “变量命名不规范”“存在未使用的变量”）；支持集成到本地 IDE（如 VS Code、PyCharm），实时检查代码质量。

• 适用人群：需要提升代码质量的新手，适合验证优化后的代码是否符合行业规范。

• 使用步骤：1. 安装工具（如在 VS Code 中安装 Pylint 插件）；2. 打开优化后的代码文件；3. 工具自动运行检查，在代码旁标注问题（如红色波浪线表示错误，黄色波浪线表示警告）；4. 根据工具提示，手动调整代码（如修改变量命名、补充注释），进一步优化代码质量。

七、实际应用拓展：不同场景下的提示词优化案例

7.1 场景一：Python 数据分析代码优化（性能 + 可读性）

7.1.1 需求背景

新手用 pandas 处理 10 万行用户消费数据（CSV 文件），代码运行慢且可读性差，需要优化性能（减少运行时间）和可读性（添加注释、规范命名）。

7.1.2 待优化代码

import pandas as pd

def f1(df):

df1 = df[df['消费金额'] > 100]

df2 = df1.groupby('用户ID')['消费金额'].sum()

df3 = df2.reset_index()

df3.columns = ['u', 'm']

df4 = df3.sort_values('m', ascending=False)

return df4

df = pd.read_csv('user_data.csv')

r = f1(df)

print(r.head(10))

7.1.3 提示词示例

“请优化以下 Python 代码，具体要求：

1. 优化维度：性能 + 可读性；

1. 上下文信息：

① 代码用途：读取 10 万行用户消费数据（user_data.csv，含 “用户 ID、消费金额、消费时间”3 列），筛选出消费金额 > 100 的记录，计算每个用户的总消费金额，按总消费金额降序排序，输出前 10 名用户；

② 运行环境：Python 3.9，pandas 2.0.3，无其他依赖库限制；

③ 输入输出要求：输入 CSV 文件 10 万行，输出前 10 名用户的 “用户 ID、总消费金额”；

1. 输出内容：① 优化前代码；② 优化后代码；③ 性能优化点 + 可读性优化点（分点说明）；④ 运行时间对比（估算 10 万行数据的运行时间）。

待优化代码：

import pandas as pd

def f1 (df):

df1 = df [df [' 消费金额 '] > 100]

df2 = df1.groupby (' 用户 ID')[' 消费金额 '].sum ()

df3 = df2.reset_index ()

df3.columns = ['u', 'm']

df4 = df3.sort_values ('m', ascending=False)

return df4

df = pd.read_csv('user_data.csv')

r = f1(df)

print(r.head(10))”

7.1.4 模型输出结果（核心部分）

优化后代码：

import pandas as pd

def calculate_high_spend_user_total(df):

"""

筛选高消费用户并计算总消费金额

参数：

df (pd.DataFrame): 输入用户消费数据框，需包含"用户ID"和"消费金额"列

返回：

pd.DataFrame: 消费金额>100的用户总消费数据，按总消费金额降序排序，含"用户ID、总消费金额"列

"""

# 性能优化：合并筛选和分组计算，减少中间DataFrame创建（原代码创建4个DataFrame，现减少为2个）

# 1. 筛选消费金额>100的记录，同时保留需要的列（减少数据量）

high_spend_df = df[df['消费金额'] > 100][['用户ID', '消费金额']]

# 2. 按用户ID分组计算总消费金额，并重命名列（见名知意）

user_total_spend = high_spend_df.groupby('用户ID', as_index=False)['消费金额'].sum()

user_total_spend.columns = ['用户ID', '总消费金额']

# 3. 按总消费金额降序排序，性能优化：sort_values默认已优化，无需额外调整

sorted_user_spend = user_total_spend.sort_values('总消费金额', ascending=False)

return sorted_user_spend

# 读取用户消费数据，性能优化：指定dtype减少内存占用（若已知列类型）

user_consume_df = pd.read_csv('user_data.csv', dtype={'用户ID': str, '消费金额': float})

# 计算高消费用户总金额

high_spend_result = calculate_high_spend_user_total(user_consume_df)

# 输出前10名用户，添加说明提升可读性

print("消费金额>100的用户总消费TOP10：")

print(high_spend_result.head(10))

优化点说明：

• 性能优化：① 合并筛选和列选择（df [df [' 消费金额 ']>100][[' 用户 ID',' 消费金额 ']]），减少中间 DataFrame 创建；② 读取 CSV 时指定 dtype，减少内存占用；

• 可读性优化：① 函数 / 变量命名见名知意；② 补充函数注释和行注释；③ 打印时添加说明文字。

7.2 场景二：Java 后端接口代码优化（可读性 + 异常处理）

7.2.1 需求背景

新手编写 Java 后端接口代码（查询用户信息），代码无异常处理（如数据库连接失败、用户不存在），命名不规范，需要优化可读性和稳定性。

7.2.2 待优化代码

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.Statement;

public class UserDAO {

public static void getU(String id) {

Connection c = null;

Statement s = null;

ResultSet r = null;

try {

Class.forName("com.mysql.cj.jdbc.Driver");

c = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");

s = c.createStatement();

String sql = "select * from user where user_id=" + id;

r = s.executeQuery(sql);

while (r.next()) {

System.out.println("用户ID：" + r.getString("user_id") + "，姓名：" + r.getString("user_name"));

}

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

if (r != null) r.close();

if (s != null) s.close();

if (c != null) c.close();

} catch (Exception e) {

e.printStackTrace();

}

}

}

public static void main(String[] args) {

getU("1");

}

}

7.2.3 提示词示例

“请优化以下 Java 代码，具体要求：

1. 优化维度：可读性 + 异常处理；

1. 上下文信息：

① 代码用途：Java 后端 DAO 层代码，通过用户 ID 从 MySQL 数据库（test 库 user 表）查询用户信息（user_id、user_name）并打印；

② 运行环境：Java 8，MySQL 8.0，依赖 mysql-connector-java 8.0.30；

③ 异常场景：可能出现 “数据库连接失败”“SQL 语法错误”“用户 ID 不存在”“结果集为空” 等场景；

1. 输出内容：① 优化前代码；② 优化后代码；③ 优化说明（可读性优化点 + 异常处理优化点）。

待优化代码：

[粘贴上述 Java 代码]”

7.2.4 模型输出结果（核心部分）

优化后代码：

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.Statement;

import java.sql.SQLException;

import java.sql.ClassNotFoundException;

/**

* 用户数据访问对象（DAO）：负责从MySQL数据库查询用户信息

*/

public class UserDAO {

// 数据库连接常量：避免硬编码，提升可维护性

private static final String DB_URL = "jdbc:mysql://localhost:3306/test";

private static final String DB_USER = "root";

private static final String DB_PASSWORD = "123456";

private static final String DRIVER_CLASS = "com.mysql.cj.jdbc.Driver";

/**

* 根据用户ID查询用户信息并打印

* @param userId 用户ID（字符串类型，避免SQL注入风险）

* @throws ClassNotFoundException 驱动类未找到异常（如依赖缺失）

* @throws SQLException SQL异常（如连接失败、语法错误、查询失败）

*/

public static void getUserInfoById(String userId) throws ClassNotFoundException, SQLException {

// 资源声明：使用try-with-resources语法，自动关闭连接、Statement、ResultSet

try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);

Statement stmt = conn.createStatement()) {

// 1. 加载数据库驱动

Class.forName(DRIVER_CLASS);

// 2. 构建SQL（优化：避免字符串拼接，减少SQL注入风险，此处简化处理，实际建议用PreparedStatement）

String sql = String.format("select user_id, user_name from user where user_id = '%s'", userId);

// 3. 执行查询

try (ResultSet rs = stmt.executeQuery(sql)) {

// 检查结果集是否为空（处理“用户ID不存在”场景）

if (!rs.next()) {

System.out.println("查询结果：未找到用户ID为【" + userId + "】的用户");

return;

}

// 遍历结果集（若有多个用户，此处假设user_id唯一）

do {

String userIdFromDb = rs.getString("user_id");

String userNameFromDb = rs.getString("user_name");

System.out.println("查询结果：用户ID=" + userIdFromDb + "，用户姓名=" + userNameFromDb);

} while (rs.next());

}

} catch (ClassNotFoundException e) {

System.err.println("数据库驱动加载失败：" + e.getMessage() + "，请检查mysql-connector依赖是否正确");

throw e; // 抛出异常，让调用者处理

} catch (SQLException e) {

// 区分不同SQL异常场景，给出具体提示

if (e.getSQLState().startsWith("08")) {

System.err.println("数据库连接失败：" + e.getMessage() + "，请检查URL、用户名、密码是否正确");

} else if (e.getSQLState().startsWith("42")) {

System.err.println("SQL语法错误：" + e.getMessage() + "，SQL语句：" + sql);

} else {

System.err.println("查询用户信息失败：" + e.getMessage());

}

throw e;

}

}

public static void main(String[] args) {

try {

// 测试查询：存在的用户ID

getUserInfoById("1");

// 测试查询：不存在的用户ID

getUserInfoById("999");

} catch (ClassNotFoundException | SQLException e) {

System.err.println("程序执行失败：" + e.getMessage());

}

}

}

优化说明：

• 可读性优化：① 类 / 方法 / 变量命名规范（UserDAO、getUserInfoById、DB_URL）；② 补充类注释和方法注释；③ 提取数据库常量，避免硬编码；

• 异常处理优化：① 细分异常场景（驱动加载失败、连接失败、语法错误、用户不存在），给出具体提示；② 使用 try-with-resources 自动关闭资源；③ 处理结果集为空场景，避免无输出。

八、注意事项：新手用提示词优化代码的关键原则

8.1 始终验证优化后的代码

8.1.1 核心原则

不要完全信任模型的优化结果，必须手动验证代码的 “功能一致性” 和 “正确性”，尤其是涉及业务逻辑、数据处理、资金计算的代码（如订单金额计算、用户数据筛选）。

8.1.2 验证方法

1. 功能验证：运行优化前后的代码，输入相同的测试数据，对比输出结果是否完全一致（如计算结果、生成的文件、打印的内容）；

1. 异常验证：测试边界场景（如空输入、错误输入、大数据量），确保优化后的代码能正确处理异常，不崩溃；

1. 性能验证（若优化性能）：用 time 模块（Python）或 System.currentTimeMillis ()（Java）计算运行时间，确认性能确实有提升，而非模型估算。

8.2 提示词不要过于复杂

8.2.1 核心原则

新手写提示词时，以 “简单、清晰” 为优先，避免在一个提示词中包含过多要求（如同时优化性能、可读性、兼容性、异常处理），导致模型无法兼顾，优化效果差。

8.2.2 实践建议

1. 分步骤优化：先优化 “语法纠错”，确保代码能运行；再优化 “可读性”，让代码易懂；最后优化 “性能”，提升效率，分 3 次提示词完成，而非 1 次；

1. 每次聚焦一个核心目标：每个提示词只包含 1 个优化维度（如 “本次只优化可读性，不考虑性能”），让模型集中资源处理一个目标。

8.3 结合自身学习，理解优化思路

8.3.1 核心原则

用提示词优化代码的同时，要理解 “模型为什么这么优化”，而不是 “直接复制使用优化后的代码”，否则无法提升自身编程能力，下次遇到类似问题仍需依赖模型。

8.3.2 学习方法

1. 分析模型的优化思路：重点看模型输出的 “优化思路”“优化说明”，理解 “为什么用这种方法优化”（如 “为什么用列表推导式比 for 循环快”）；

1. 手动复现优化过程：尝试不看模型的优化结果，自己按优化思路手动修改代码，对比与模型结果的差异，找出自己的不足；

1. 记录优化技巧：将常用的优化技巧（如 “用 sum () 替代手动累加”“try-with-resources 关闭资源”）记录到笔记中，定期复习，逐步内化为自己的知识。

8.4 尊重代码版权和安全性

8.4.1 核心原则

优化代码时，确保待优化代码的版权归属（如自己编写的代码、公司授权的代码），不优化他人无授权的代码；同时注意代码安全性，不将包含敏感信息（如数据库密码、用户隐私数据）的代码粘贴到公共大模型中。

8.4.2 安全建议

1. 脱敏处理：若代码包含敏感信息，优化前先脱敏，如将 “数据库密码 = 123456” 改为 “数据库密码 =”，将 “用户手机号 = 13800138000” 改为 “用户手机号 =”；

1. 选择安全模型：处理敏感代码时，优先使用本地部署的开源模型（如 CodeLlama），而非公共在线模型，避免敏感信息泄露；

1. 确认版权：优化公司代码前，确认公司允许使用大模型辅助优化，不违反公司的代码管理规定。

   九、不同编程语言的提示词优化差异

   9.1 核心逻辑

   不同编程语言的语法规则、优化方向、常用库不同，提示词若不结合语言特性，优化效果会大打折扣。比如 Python 侧重 “内置函数、列表推导式” 优化，Java 侧重 “异常处理、资源关闭” 优化，JavaScript 侧重 “异步逻辑、DOM 操作效率” 优化。因此，针对不同语言，需在提示词中调整 “优化方式” 和 “上下文信息”，贴合语言特性。

   9.2 主流编程语言的提示词优化要点及示例

   9.2.1 Python 语言

2. 核心优化方向：性能（内置函数、生成器、pandas 优化）、可读性（PEP 8 规范、命名风格）、语法简洁（列表推导式、lambda 函数）；
3. 提示词要点：需说明 “是否使用第三方库（如 pandas、numpy）”“数据量大小”“Python 版本（如 3.7/3.10）”；
4. 示例模板（pandas 数据处理优化）：

5. “请优化以下 Python 代码（Python 3.9，依赖 pandas 2.0），优化维度为性能，上下文信息：

   ① 代码用途：处理 10 万行 CSV 数据（含 “用户 ID、消费时间、消费金额”），筛选出 2024 年的消费记录，计算每个用户的月均消费金额；

   ② 优化要求：优先使用 pandas 的向量化操作替代 for 循环，减少中间 DataFrame 创建；

   ③ 输出：优化前后代码、性能瓶颈分析、运行时间对比（测试数据：10 万行 CSV）。

   待优化代码：

   import pandas as pd

   df = pd.read_csv ('user_spend.csv')

   df [' 消费时间 '] = pd.to_datetime (df [' 消费时间 '])

   2024_data = []

   for index, row in df.iterrows ():

   if row [' 消费时间 '].year == 2024:

   2024_data.append (row)

   2024_df = pd.DataFrame (2024_data)

   user_monthly = 2024_df.groupby ([' 用户 ID', 2024_df [' 消费时间 '].dt.month])[' 消费金额 '].sum ()

   user_avg = user_monthly.groupby (' 用户 ID').mean ()

   print (user_avg.head ())”

   9.2.2 Java 语言

6. 核心优化方向：异常处理（try-with-resources、细分异常）、资源管理（流关闭、连接池）、代码规范（Google 编码规范、命名）；
7. 提示词要点：需说明 “Java 版本（如 8/11）”“依赖框架（如 Spring、JDBC）”“运行环境（如后端服务、Android）”；
8. 示例模板（JDBC 查询优化）：

9. “请优化以下 Java 代码（Java 8，依赖 mysql-connector 8.0），优化维度为可读性 + 异常处理，上下文信息：

   ① 代码用途：通过 JDBC 查询商品表（goods），根据商品 ID 获取商品名称和价格；

   ② 优化要求：按 Google 编码规范调整格式，用 try-with-resources 关闭资源，细分 SQL 异常场景；

   ③ 输出：优化前后代码、优化说明（可读性 + 异常处理点）。

   待优化代码：

   import java.sql.*;

   public class GoodsDAO {

   public static void getGoods (String id) {

   Connection conn = null;

   PreparedStatement pstmt = null;

   ResultSet rs = null;

   try {

   Class.forName ("com.mysql.cj.jdbc.Driver");

   conn = DriverManager.getConnection ("jdbc:mysql://localhost:3306/shop", "root", "123456");

   String sql = "select name, price from goods where id=?";

   pstmt = conn.prepareStatement(sql);

   pstmt.setString(1, id);

   rs = pstmt.executeQuery();

   if (rs.next()) {

   System.out.println(rs.getString(1) + "," + rs.getDouble(2));

   }

   } catch (Exception e) {

   e.printStackTrace();

   } finally {

   try {

   if (rs != null) rs.close();

   if (pstmt != null) pstmt.close();

   if (conn != null) conn.close();

   } catch (Exception e) {}

   }

   }

   }”

   9.2.3 JavaScript 语言

10. 核心优化方向：异步逻辑（Promise、async/await 替代回调）、DOM 操作（减少重排重绘）、性能（数组方法替代 for 循环）；
11. 提示词要点：需说明 “运行环境（浏览器 / Node.js）”“是否依赖前端框架（如 Vue、React）”“异步场景（如接口请求、文件读取）”；
12. 示例模板（异步接口请求优化）：

13. “请优化以下 JavaScript 代码（浏览器环境，无框架），优化维度为可读性 + 性能，上下文信息：

    ① 代码用途：先请求用户接口（/api/user）获取用户 ID，再用用户 ID 请求订单接口（/api/orders?userId=XXX），展示订单列表；

    ② 优化要求：用 async/await 替代回调函数，添加请求异常处理（如接口报错、无数据），减少全局变量使用；

    ③ 输出：优化前后代码、优化思路（异步逻辑 + 异常处理）。

    待优化代码：

    let userId;

    \(.get('/api/user', function(userData) { userId = userData.id; \).get ('/api/orders?userId=' + userId, function (orderData) {

    if (orderData.length > 0) {

    for (let i = 0; i < orderData.length; i++) {

    console.log (orderData [i].id);

    }

    }

    }, function (err) {

    console.log (' 订单接口错了 ');

    });

    }, function (err) {

    console.log (' 用户接口错了 ');

    });”

    9.3 新手操作建议

14. 先明确编程语言特性：优化前简单了解目标语言的核心优化方向（如 Python 的向量化、Java 的资源管理），避免在提示词中提 “不符合语言特性” 的要求（如让 Java 用列表推导式）；
15. 参考语言官方规范：在提示词中引用官方规范（如 Python PEP 8、Java Google 规范），让模型优化更贴合行业标准；
16. 测试语言兼容性：优化后确认代码在目标语言版本中能运行（如 Python 3.7 不支持某些 3.10 语法），避免因版本问题导致代码报错。

17. 十、提示词优化代码的进阶场景

    10.1 场景一：多语言混合代码优化（如 Python+Shell、Java+JavaScript）

    10.1.1 需求背景

    新手处理跨语言脚本（如 Python 调用 Shell 脚本执行命令，Java 后端调用 JavaScript 前端接口），代码逻辑混乱、交互效率低，需要优化代码结构和交互方式。

    10.1.2 待优化代码（Python 调用 Shell 脚本）

    import os

    # 调用Shell脚本获取系统内存信息，再用Python处理数据

    os.system("sh get_memory.sh > memory.txt")

    f = open("memory.txt", "r")

    content = f.read()

    f.close()

    lines = content.split('\n')

    used_mem = 0

    for line in lines:

    if "Used" in line:

    used_mem = line.split(':')[1].strip()

    print("已用内存：" + used_mem)

    问题：用文件（memory.txt）传递数据，效率低；无异常处理（Shell 脚本执行失败、文件不存在）；代码结构混乱。

    10.1.3 提示词示例

    “请优化以下 Python+Shell 混合代码，具体要求：

18. 优化维度：性能 + 可读性；
19. 上下文信息：

20. ① 代码用途：Python 调用 Shell 命令获取系统内存信息（无需单独 Shell 脚本），提取 “已用内存” 并打印，运行环境为 Linux+Python 3.8；

    ② 优化要求：用 subprocess 模块替代 os.system（避免生成中间文件），添加异常处理（命令执行失败、无内存数据），规范代码结构；

21. 输出：优化前后代码、优化说明（性能提升点 + 可读性优化点）。

22. 待优化代码：

    [粘贴上述 Python 代码]”

    10.1.4 模型输出结果（核心部分）

    优化后代码：

    import subprocess

    from subprocess import CalledProcessError

    def get_and_parse_system_memory():

    """

    调用Shell命令获取Linux系统已用内存信息并解析

    返回：str，已用内存（如"8GB"）；若失败返回空字符串

    """

    try:

    # 优化1：用subprocess.check_output直接获取Shell命令输出，避免生成中间文件（memory.txt）

    # 执行free命令获取内存信息，-h参数显示人类可读格式

    result = subprocess.check_output(

    ["free", "-h"], # Shell命令及参数

    stderr=subprocess.STDOUT, # 捕获标准错误

    text=True # 输出为字符串（无需解码）

    )

    # 优化2：结构化解析输出，避免冗余循环

    lines = result.strip().split('\n')

    for line in lines:

    # 匹配"Mem:"开头的行（内存信息行）

    if line.startswith("Mem:"):

    # 拆分列（Mem: total used free shared buff/cache available）

    mem_cols = line.split()

    used_mem = mem_cols[2] # 第3列是已用内存

    return used_mem

    # 未找到内存数据时的异常

    raise ValueError("未从Shell命令输出中找到内存信息")

    except CalledProcessError as e:

    # 处理Shell命令执行失败（如命令不存在、权限不足）

    print(f"Shell命令执行失败：{e.output}，返回码：{e.returncode}")

    return ""

    except ValueError as e:

    print(f"数据解析失败：{str(e)}")

    return ""

    except Exception as e:

    print(f"未知错误：{str(e)}")

    return ""

    # 主逻辑：调用函数并打印结果

    if __name__ == "__main__":

    used_memory = get_and_parse_system_memory()

    if used_memory:

    print(f"系统已用内存：{used_memory}")

    else:

    print("获取内存信息失败")

    优化说明：

23. 性能优化：用 subprocess.check_output 直接获取 Shell 输出，删除中间文件操作，减少 IO 开销；
24. 可读性优化：函数封装逻辑，添加注释，结构化解析数据；
25. 异常处理：捕获命令执行失败、数据解析失败等场景，确保代码稳定。

26. 10.2 场景二：包含第三方框架的代码优化（如 Python Django、Java Spring Boot）

    10.2.1 需求背景

    新手用框架开发项目（如 Django 开发网站、Spring Boot 开发后端接口），代码未遵循框架规范（如 Django 的 ORM 使用、Spring 的依赖注入），导致性能低、扩展性差。

    10.2.2 待优化代码（Django 视图函数，查询用户数据）

    # Django视图函数：查询所有用户，筛选出年龄>18的用户并返回

    from django.http import JsonResponse

    from myapp.models import User

    def get_adult_users(request):

    users = User.objects.all() # 查询所有用户，数据量大时性能低

    adult_users = []

    for user in users:

    if user.age > 18: # Python层面筛选，效率低

    adult_users.append({

    "id": user.id,

    "name": user.name,

    "age": user.age

    })

    return JsonResponse({"adult_users": adult_users})

    问题：查询所有用户后在 Python 层面筛选（数据量大时性能低）；无分页（10 万用户时返回数据过大）；未处理请求异常（如数据库连接失败）。

    10.2.3 提示词示例

    “请优化以下 Django 视图函数代码（Django 4.2，Python 3.10），具体要求：

27. 优化维度：性能 + 框架规范；
28. 上下文信息：

29. ① 代码用途：Django 视图函数，接收 GET 请求，查询 User 模型中年龄 > 18 的用户，返回 JSON 数据（支持分页，每页 10 条）；

    ② 优化要求：用 Django ORM 的 filter 在数据库层面筛选（避免 Python 层面筛选），添加分页（Django Paginator），处理数据库异常；

30. 输出：优化前后代码、优化说明（框架规范 + 性能优化）。

31. 待优化代码：

    [粘贴上述 Django 代码]”

    10.2.4 模型输出结果（核心部分）

    优化后代码：

    from django.http import JsonResponse

    from django.core.paginator import Paginator, EmptyPage

    from django.db import DatabaseError

    from myapp.models import User

    def get_adult_users(request):

    try:

    # 优化1：遵循Django ORM规范，在数据库层面用filter筛选年龄>18的用户

    # 避免查询所有用户（User.objects.all()），减少数据库查询数据量

    adult_users_queryset = User.objects.filter(age__gt=18).only("id", "name", "age")

    # 优化2：添加分页（每页10条），支持前端传page参数（默认第1页）

    page_num = request.GET.get("page", 1)

    paginator = Paginator(adult_users_queryset, 10) # 每页10条数据

    try:

    current_page_users = paginator.page(page_num)

    except EmptyPage:

    # 处理页码不存在的情况（如请求page=1000，实际只有5页）

    current_page_users = paginator.page(paginator.num_pages)

    # 转换为JSON格式数据

    adult_users_data = [

    {"id": user.id, "name": user.name, "age": user.age}

    for user in current_page_users

    ]

    # 返回分页信息和数据

    response_data = {

    "adult_users": adult_users_data,

    "pagination": {

    "total_users": paginator.count, # 总用户数

    "total_pages": paginator.num_pages, # 总页数

    "current_page": current_page_users.number, # 当前页码

    "page_size": 10 # 每页条数

    }

    }

    return JsonResponse(response_data, status=200)

    except DatabaseError as e:

    # 处理数据库异常（如连接失败、SQL错误）

    return JsonResponse({"error": f"数据库查询失败：{str(e)}"}, status=500)

    except Exception as e:

    # 处理其他未知异常

    return JsonResponse({"error": f"请求处理失败：{str(e)}"}, status=400)

    优化说明：

32. 框架规范：用 Django ORM 的 filter（数据库层面筛选）和 only（只查询需要的字段），遵循 Django 数据查询最佳实践；
33. 性能优化：分页减少返回数据量，数据库层面筛选减少数据传输；
34. 异常处理：捕获数据库异常和分页异常，返回标准 HTTP 状态码，符合接口开发规范。

35. 十一、提示词优化代码的后续学习方向

    11.1 学习提示词的精细化设计

    11.1.1 核心目标

    从 “能生成优化代码” 进阶到 “生成高质量、贴合需求的优化代码”，比如根据 “代码复杂度” 调整提示词细节（简单代码用简洁提示词，复杂代码用详细提示词）。

    11.1.2 学习方法

36. 分析优秀提示词模板：研究 PromptBase、GitHub 上的代码优化提示词模板，学习 “如何用最少的文字传递准确需求”；
37. 尝试变量化提示词：将提示词中的固定内容（如编程语言、优化维度）设为变量，形成 “通用模板”，比如 “优化以下 {{语言}} 代码，优化维度为 {{维度}}，上下文信息：{{信息}}”；
38. 多轮交互优化：若一次优化不满足需求，学习用追问补充需求，如 “之前的优化忽略了分页，请补充 Django 分页功能，每页 20 条数据”。

39. 11.2 结合代码优化理论，提升提示词针对性

    11.2.1 核心目标

    理解代码优化的底层理论（如时间复杂度、空间复杂度、数据库索引优化），让提示词中的 “优化要求” 更专业、更有针对性。

    11.2.2 学习方法

40. 入门基础理论：阅读《代码整洁之道》《算法图解》等书籍，了解 “可读性规范”“算法效率” 的基础概念；
41. 针对性补充提示词：将理论融入提示词，如 “优化这段 SQL 查询代码，要求：1. 分析当前 SQL 的执行计划，添加合适的索引；2. 避免全表扫描（时间复杂度 O (n)），优化为索引查询（O (log n)）”；
42. 验证理论落地：优化后用代码质量工具（如 EXPLAIN 分析 SQL 执行计划）验证优化效果，理解 “理论如何通过代码落地”。

43. 11.3 探索 AI 与代码优化的深度结合

    11.3.1 核心目标

    了解 AI 在代码优化中的高级应用（如 AI 生成单元测试、AI 检测潜在性能风险），拓展提示词的应用场景。

    11.3.2 学习方向

44. 提示词 + 单元测试：学习用提示词让模型为优化后的代码生成单元测试，如 “为优化后的 Django 视图函数生成单元测试，覆盖正常查询、分页、数据库异常 3 种场景”；
45. 提示词 + 性能分析：让模型分析代码的性能风险，如 “分析这段 Java 代码的潜在性能风险（如内存泄漏、死锁），给出优化建议”；
46. 尝试 AI 代码工具：使用 Copilot X、CodeGeeX 等 AI 代码工具，体验 “实时提示词优化”（边写代码边优化），学习工具的提示词交互逻辑。

47. 11.4 新手实践建议

48. 每周固定练习：每周选择 1-2 段自己写的代码，用本文的技巧写提示词优化，对比优化前后的差异；
49. 记录优化案例：建立 “提示词 - 优化代码” 案例库，记录每次的提示词、优化结果、遇到的问题，定期复盘；
50. 参与社区交流：在 CSDN、GitHub、Stack Overflow 的 AI 代码优化社区分享自己的案例，学习他人的提示词技巧。