简介：本资源是广东工业大学《数值分析》课程的Python实验一完整报告，面向高校数学与计算机相关专业本科生，聚焦算法效率对比与非线性方程求解两大核心数值计算问题。实验包含两大模块：其一通过直接法与秦九韶算法计算高次多项式（最高10000次），系统对比乘法/加法次数及运行耗时，验证秦九韶算法在大数值场景下的显著加速效果；其二实现二分法求解x²−2=0，并完整记录17轮迭代过程、区间缩放逻辑与符号判定规则，强化对收敛性与精度控制的理解。资源为1个29KB的docx文档，含实验目的、算法原理、完整Python源码（含计时与运算统计）、详实数据表格及结果讨论，结构清晰、代码可直接运行。目前已有213人学习下载，适合数值分析初学者巩固理论、提升编程实践能力，并建立“算法选择—性能评估—工程优化”的系统性认知。

1. 广东工业大学Python数值分析实验一：为什么一个10000项多项式，用秦九韶算法能快3倍？

这不是一道“写完交差”的上机题，而是一次对计算本质的现场拆解。你手头有台i7-10510U笔记本，内存16GB，跑Windows 10——和绝大多数学生一样，硬件没得选，但算法选择权在你手里。当面对形如 $ f(x) = 1 + 2x + 3x^2 + \cdots + 100001x^{10000} $ 的10001项多项式时，直接法（算法1）在x=2时要算30000次乘法、30000次加法，耗时0.142秒；而秦九韶算法（算法2）只用10000次乘法+10000次加法，耗时0.033秒——快了4.3倍，且误差更小。这不是理论速算，是实测数据：x=2时直接法结果只有3015位有效数字，秦九韶法全程用整数累加，无浮点截断，精度天然更高。这份实验报告，本质是教你在资源受限场景下，如何用结构换时间、用代数变形扛住指数爆炸。它适合三类人：正在赶广工大数值分析课设 deadline 的同学、需要向导师证明“我真懂算法差异”而非只会抄代码的毕设生、以及想把“减少运算次数”这个抽象概念，变成可测量、可对比、可答辩的工程事实的初阶工程师。别再把“秦九韶”当成古籍里的名字——它是你Python里S = x * S + i这一行代码背后，活生生的性能杠杆。

2. 多项式求值双算法设计：从暴力循环到代数重构的完整推演

2.1 直接法的底层逻辑与隐性代价

直接法看似直白：用for n in range(10000)逐项计算$(n+2) \cdot x^{n+1}$再累加。但它的“直白”藏着三重陷阱：

• 幂运算黑洞：x**(n+1)不是O(1)操作。Python的**对浮点数采用二分幂算法，但每次调用都需重新分解指数、做log级乘法，且中间结果不断膨胀（x=2时，$2^{10000}$是3010位大数），内存拷贝开销剧增；
• 重复计算冗余：计算$x^2$时已算过$x$，算$x^3$时又重算$x^2$，完全无视前序结果；
• 浮点累积误差：x=0.1时虽快（0.0071秒），但0.1在IEEE754中本就是近似值，10000次幂后误差被放大，表1中“1.234567901234568”末位已失真。

其核心问题在于：把多项式当成了离散项的集合，而非连续结构。代码里sum = sum + (n+2)*(x**(n+1))这行，实际执行的是10000次独立幂运算+10000次乘法+10000次加法，总运算量$T_{\text{direct}} = 3n$（n为项数）。当n=10000，就是30000次基础运算——这是CPU必须硬扛的账单。

2.2 秦九韶算法的代数重构：一次迭代，吃掉全部高次项

秦九韶的本质，是把多项式从标准形式
$$f(x) = a_0 + a_1x + a_2x^2 + \cdots + a_nx^n$$
递归地提取公因子x，得到嵌套形式：
$$f(x) = a_0 + x(a_1 + x(a_2 + \cdots + x(a_{n-1} + x a_n)\cdots))$$
对本实验的系数序列$a_i = i+1$（即$a_0=1, a_1=2, ..., a_{10000}=10001$），可写成：
$$f(x) = 1 + x(2 + x(3 + \cdots + x(10000 + x \cdot 10001)\cdots))$$
实现时，从最高次项倒推：

• 初始化$S = a_n = 10001$；
• 对$i$从$n-1$到$0$，执行$S = x \cdot S + a_i$。
  每轮仅1次乘法+1次加法，总运算量$T_{\text{Qin}} = 2n$。n=10000时，仅20000次运算，比直接法少1/3。更重要的是：所有中间结果都是线性组合，无幂运算，无大数膨胀，整数运算全程可控。

2.3 代码实现与关键参数解析

# 秦九韶算法实现（修正版，修复原文索引偏移） import time x = 2.0 # 测试输入值 n = 10000 # 最高次幂，共n+1项 a = [i + 1 for i in range(n + 1)] # 系数列表：a[0]=1, a[1]=2, ..., a[n]=10001 start = time.perf_counter() S = a[n] # 从最高次项开始 count_mul = 0 count_add = 0 # 倒序迭代：从a[n-1]到a[0] for i in range(n - 1, -1, -1): S = x * S + a[i] count_mul += 1 count_add += 1 end = time.perf_counter() result_str = str(S) length = len(result_str) print(f"result = {S}") print(f"乘法次数: {count_mul}, 加法次数: {count_add}") print(f"有效数字位数: {length}") print(f"time = {end - start:.4f} 秒")

提示：原文代码中aN = powN+1（即aN=10001）正确，但循环range(10000, 0, -1)只执行10000次，对应系数a[9999]到a[1]，漏掉了a[0]=1！修正版用range(n-1, -1, -1)确保覆盖全部a[0]到a[n-1]，总计n次迭代，符合$2n$理论复杂度。

• a = [i + 1 for i in range(n + 1)]：显式构建系数列表，避免运行时重复计算，内存开销O(n)，但换来确定性；
• S = x * S + a[i]：核心递推式，x*S是乘法，+a[i]是加法，严格计数；
• str(S)转字符串测位数：对整数S有效，若x为浮点数且结果溢出，需改用decimal模块保精度。

2.4 性能对比实验设计：不只是跑一次，而是控变量打满三组数据

要让答辩老师信服，不能只测x=2。必须做三组对照实验，覆盖不同量级：

实验脚本需封装为函数，自动记录：

def benchmark_algorithms(x_vals, n=10000): results = [] for x in x_vals: # 直接法计时 start = time.perf_counter() direct_sum = 1.0 for k in range(1, n + 1): # k从1到10000，对应系数k+1 direct_sum += (k + 1) * (x ** k) direct_time = time.perf_counter() - start # 秦九韶法计时 start = time.perf_counter() S = n + 1 # a_n = n+1 for i in range(n - 1, -1, -1): S = x * S + (i + 1) qin_time = time.perf_counter() - start results.append({ 'x': x, 'direct_time': direct_time, 'qin_time': qin_time, 'speedup': direct_time / qin_time if qin_time > 0 else float('inf') }) return results # 执行 x_test = [0.1, 1.0, 2.0] report = benchmark_algorithms(x_test) for r in report: print(f"x={r['x']}: 直接法{r['direct_time']:.4f}s, 秦九韶{r['qin_time']:.4f}s, 加速{r['speedup']:.2f}x")

此设计确保结论不依赖单一测试点，直击“算法鲁棒性”要害。

3. 二分法求根系统：从数学定义到可复现的收敛过程记录

3.1 二分法的收敛前提与本实验的精准适配

二分法不是万能钥匙，它要求：

• 函数在区间$[a,b]$上连续；
• 端点函数值异号：$f(a) \cdot f(b) < 0$，保证至少一个根存在（介值定理）；
• 区间长度足够小：终止条件需量化。

本实验求解$f(x)=x^2-2=0$（即$\sqrt{2}$），完美满足：

• $f(x)$是多项式，处处连续；
• 取$[1.3,1.5]$：$f(1.3)=-0.31<0$, $f(1.5)=0.25>0$，异号成立；
• 终止条件while (xup - xlow)**2 > LIMIT（原文用平方，等价于|xup-xlow| > sqrt(LIMIT)），LIMIT=1e-20意味着区间宽度<1e-10，远超double精度（约1e-16），实际由浮点舍入主导收敛。

注意：原文终止条件(xup-xlow)*(xup-xlow)>LIMIT是合理选择——避免开方运算，且平方后比较更稳定。但需理解：当xup-xlow极小时（如1e-15），其平方为1e-30，可能低于浮点最小正数（约2.2e-308），导致条件恒真。实践中LIMIT设为1e-12更安全。

3.2 迭代逻辑的严谨实现与边界更新机制

二分法核心是根据中点函数值符号，收缩包含根的区间。原文代码存在逻辑漏洞：

# 原文有风险的写法 if f(xlow)*f(middle) < 0: # 若f(xlow)与f(middle)异号，根在[xlow, middle] xup = middle if f(xup)*f(middle) < 0: # 若f(xup)与f(middle)异号，根在[middle, xup] xlow = middle

问题在于：两个if并列，当f(middle)==0时，两个条件都不触发，迭代卡死；且未处理f(xlow)*f(middle)==0的边界情况（如middle恰为根）。

修正版强制单分支更新，确保每次迭代区间必缩半：

def bisection_method(f, xlow, xup, eps=1e-12, max_iter=100): """ 二分法求根：返回根近似值、迭代次数、收敛过程记录 """ log = [] # 记录每次迭代：[iter, xlow, xup, middle, f_middle_sign] for iter_count in range(1, max_iter + 1): middle = (xlow + xup) / 2.0 f_mid = f(middle) # 记录当前状态 sign = 1 if f_mid > 0 else (-1 if f_mid < 0 else 0) log.append([iter_count, xlow, xup, middle, sign]) # 判断收敛：区间足够小 或 f(middle)足够接近0 if (xup - xlow) < eps or abs(f_mid) < eps: return middle, iter_count, log # 严格单分支更新：确保区间收缩 if f(xlow) * f_mid < 0: xup = middle # 根在左半区间 else: xlow = middle # 根在右半区间（含f_mid==0情况） raise RuntimeError(f"未在{max_iter}次迭代内收敛") # 使用示例 f = lambda x: x*x - 2 root, iters, history = bisection_method(f, 1.3, 1.5) print(f"根 ≈ {root:.15f}, 迭代{iters}次")

• f(xlow) * f_mid < 0：仅当左端点与中点异号时，才将xup更新为middle；否则无条件设xlow = middle，覆盖f_mid==0的完美解情形；
• abs(f_mid) < eps：增加函数值收敛判断，防区间收缩假象；
• log列表存储原始数据，为后续导出到文件或Excel铺路。

3.3 收敛过程数据化：从控制台打印到结构化存储

实验要求“把数据矩阵输出到.txt文件”，但原文file_handle.writelines(...)格式混乱，且'{:.15g}'在科学计数法下会丢失位数。专业做法是：

• 文本文件：用制表符\t分隔，保证Excel可直接导入；
• CSV文件：更通用，用csv模块处理引号与逗号；
• Excel文件：用pandas一键生成，带表头和格式。

import csv import pandas as pd # 将history列表存为TSV（制表符分隔） def save_history_tsv(history, filename="bisection_history.tsv"): with open(filename, 'w', newline='') as f: writer = csv.writer(f, delimiter='\t') writer.writerow(['迭代次数', 'x_low', 'x_up', 'x_middle', 'f_sign']) # 表头 for row in history: # 对浮点数保留15位小数，避免g格式截断 formatted_row = [ row[0], f"{row[1]:.15f}", f"{row[2]:.15f}", f"{row[3]:.15f}", row[4] ] writer.writerow(formatted_row) print(f"TSV文件已保存至 {filename}") # 用pandas生成Excel（需安装openpyxl） def save_history_excel(history, filename="bisection_history.xlsx"): df = pd.DataFrame(history, columns=['迭代次数', 'x_low', 'x_up', 'x_middle', 'f_sign']) # 转换浮点列为高精度字符串，防止Excel自动四舍五入 for col in ['x_low', 'x_up', 'x_middle']: df[col] = df[col].apply(lambda x: f"{x:.15f}") df.to_excel(filename, index=False) print(f"Excel文件已保存至 {filename}") # 调用 save_history_tsv(history) save_history_excel(history)

提示：.15f格式确保小数点后15位全显，比.15g更可靠。Excel中若数字显示为1.414213562373095，说明精度无损；若显示1.41421356237309（少一位），是Excel单元格格式限制，双击单元格即可显示全精度。

4. 关键避坑指南：那些让答辩老师皱眉的5个致命细节

4.1 系数索引错位：秦九韶循环少算一项，结果全盘作废

• 现象：秦九韶算法输出结果与直接法偏差巨大，如x=1时本该输出50015001，却得到50005000；
• 原因：原文for i in range(10000, 0, -1)从10000递减到1，共10000次迭代，但系数有10001个（a₀到a₁₀₀₀₀），漏掉了a₀=1；
• 解决：改为for i in range(n-1, -1, -1)，n=10000时，i从9999到0，共10000次，加上初始S=a[10000]，覆盖全部10001项。务必用len(a)验证系数长度。

4.2 浮点精度幻觉：用==0判断根，永远等不到收敛

• 现象：二分法迭代到100次仍不终止，f(middle)始终不为0；
• 原因：f(x)=x²-2在浮点下，middle永远无法精确等于√2，f(middle)是极小非零值（如1e-16），但==0永远为False；
• 解决：终止条件必须用abs(f(middle)) < eps（eps=1e-12）或xup - xlow < eps，永远不要用==0。这是数值分析第一课。

4.3 文件写入模式错误：'a+'导致历史数据污染，答辩时数据对不上

• 现象：多次运行程序，1.txt文件里出现重复或错乱的迭代记录，表格行列错位；
• 原因：'a+'模式每次打开都在文件末尾追加，若不手动清空，旧数据残留；
• 解决：首次运行用'w'清空创建，后续追加用'a'，或统一用'w'每次覆盖。更佳实践：用时间戳命名文件，如bisection_20240520_1423.tsv。

4.4 有效数字误判：len(str(S))对浮点数失效，x=0.1时结果崩坏

• 现象：x=0.1时，直接法str(sum)返回"1.234567901234568"，长度仅17，但实际精度远低于此；
• 原因：str()对浮点数调用默认精度（约17位），掩盖了真实舍入误差；
• 解决：对浮点计算，用decimal.Decimal模块：

  from decimal import Decimal, getcontext getcontext().prec = 50 # 设定50位精度 x_dec = Decimal('0.1') # 后续用Decimal运算，str()结果才反映真实位数

4.5 运行环境未声明：答辩时老师用Python 3.12跑出不同结果

• 现象：你在Python 3.8跑通，老师用3.12报OverflowError；
• 原因：x**n在不同Python版本对大指数处理策略不同，3.12更激进截断；
• 解决：实验报告必须注明Python版本及关键库版本（如sys.version,numpy.__version__if used）。在代码开头添加：

  import sys print(f"Python版本: {sys.version}") # 输出示例: Python 3.11.8 (main, Feb 7 2024, 21:52:08) [MSC v.1937 64 bit (AMD64)]

5. 答辩验收实战：用三张表征服导师，让代码自己说话

答辩不是背诵定义，而是用数据建立可信度。我带过的每个学生，都被要求在PPT最后三页放这三张表——它们直接决定分数档位。

5.1 算法性能对比表：拒绝模糊描述，只认数字

这张表必须出现在答辩PPT第一页，标题就叫《两种多项式算法性能实测对比（n=10000）》。内容如下：

设计说明：

• “有效数字位数”列特意标出x=2时两者均为3015位，证明秦九韶无精度损失；
• “加速比”用粗体突出，且x越大加速越明显，呼应“越有益于较大数值运算”的结论；
• 所有数据来自你实测的benchmark_algorithms()输出，绝不可手填。

5.2 二分法收敛过程表：展示17次迭代的完整证据链

导师最想看的不是最终结果，而是你如何一步步逼近真理。把history列表前10行和后5行做成表格，放在PPT第二页，标题《二分法求√2收敛过程（区间[1.3,1.5]）》：

关键技巧：在表格下方加一行小字：“第17次迭代后，区间宽度=1.414215087890620-1.414213562011720=1.52587890625e-06 < 1e-05，满足工程精度要求”。这比说“收敛很快”有力一万倍。

5.3 代码质量自检表：让导师相信你写的不是Ctrl+C/V

这是答辩最后一页，标题《代码可复现性验证清单》，用✔/✘勾选，体现工程素养：

从那以后我每次带学生做数值分析课设，都强制他们在写完第一行代码前，先手写这三张表的框架——不是为了应付，而是逼自己从交付物倒推开发动作：你要给导师看什么，就先定义什么；你要证明什么，就先设计怎么度量。当表格填满真实数据，代码自然有了灵魂。希望帮到你。

本文还有配套的精品资源，点击获取