这是一个典型的**级数求和问题**，利用自然对数底 $ e $ 的泰勒展开式（即指数函数 $ e^x $ 在 $ x=1 $ 处的麦克劳林级数）： $$ e = \sum_{n=0}^{\infty} \frac{1}{n!} = 1 + \frac{1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \cdots $$ 题目要求：**累加直到某一项 $ \frac{1}{n!} $ 的绝对值 < $ 10^{-5} $**（即 $ 0.00001 $）为止。注意： - 第 0 项是 $ \frac{1}{0!} = 1 $ - 每一项可**递推计算**：$ \frac{1}{n!} = \frac{1}{(n-1)!} \times \frac{1}{n} $，避免重复计算阶乘（更高效、更精确，防止大数阶乘溢出或浮点误差累积） ✅ 我们将： - 初始化 `e_approx = 1.0`（对应 $ n=0 $ 项） - 初始化 `term = 1.0`（当前项，起始为 $ \frac{1}{0!} = 1 $） - 从 $ n = 1 $ 开始循环，每次更新 `term /= n`，然后加到 `e_approx` - 当 `abs(term) < 1e-5` 时**跳出循环**（注意：由于 term 始终为正，`abs()` 可省略，但保留更严谨） 下面是完整、清晰、带注释的 Python 实现： ```python # 求自然对数 e 的近似值，精度要求：最后一项 < 1e-5 e_approx = 1.0 # 第 0 项：1/0! = 1 term = 1.0 # 当前项，初始为第 0 项 n = 1 # 从第 1 项（即 1/1!）开始 while True: term /= n # term = term / n → 即 1/(n-1)! / n = 1/n! if term < 1e-5: # 题目要求“最后一项的绝对值小于 10^-5”，满足则停止 break e_approx += term n += 1 print(f"e 的近似值（精度 < 1e-5）: {e_approx}") print(f"共累加了 {n} 项（n 从 0 到 {n-1}，含第0项）") print(f"Python 内置 math.e = {__import__('math').e}") ``` 📌 **运行输出示例**（实际值可能因浮点精度略有差异）： ``` e 的近似值（精度 < 1e-5）: 2.71827876984127 共累加了 10 项（n 从 0 到 9，含第0项） Python 内置 math.e = 2.718281828459045 ``` 🔍 **关键解释**： - 使用**递推法**计算 `term`（而非每次调用 `math.factorial(n)`），时间复杂度从 $ O(n^2) $ 降至 $ O(n) $，且避免大整数阶乘导致的性能下降或潜在整数溢出（虽 Python 支持大整数，但 float 转换仍可能损失精度）。 - 循环条件判断的是**当前新算出的项 `term` 是否已小于阈值**，即该项是“最后一项”（不参与累加），因此我们是在 `term < 1e-5` **之后 break**，而**不加这一项** —— 这严格符合题意：“直到最后一项的绝对值小于 10⁻⁵ 为止”，即**最后一项是满足条件的那个未被累加的项**。 ✅ 但注意：常见理解（包括本题上下文）中，“直到…为止”通常指**累加所有 ≥ 1e-5 的项，停止于第一个 < 1e-5 的项（不加）**。上述代码正是如此：`term /= n` 后立即检查，若太小就 `break`，不执行 `e_approx += term`。✔️ 正确。 ⚠️ 补充验证：第 9 项是 $ \frac{1}{9!} = \frac{1}{362880} \approx 2.7557 \times 10^{-6} < 10^{-5} $，所以实际累加到第 8 项（$ \frac{1}{8!} \approx 2.48 \times 10^{-5} $），共 9 项（n=0 到 8）。但我们的循环变量 `n` 从 1 开始，`term /= n` 后 `n` 自增，需结合打印调试确认。上面代码中 `n` 是下一项的阶乘阶数，最终 `n` 值为 10，说明计算了 `n=1` 到 `n=9` 的 term（即 1/1! 到 1/9!），但只累加了其中 ≥1e-5 的部分（即 1/1! ~ 1/8!），共 9 项（0!~8!）→ 总共 9 项？等等，我们来厘清： | n (循环中) | term 计算后值 | 是否累加？ | 对应项 | |------------|----------------|-------------|---------| | n=1 | 1/1! = 1.0 | 是 | 1/1! | | n=2 | 1/2! = 0.5 | 是 | 1/2! | | ... | ... | ... | ... | | n=8 | 1/8! ≈ 2.48e-5 | 是 | 1/8! | | n=9 | 1/9! ≈ 2.76e-6 | ❌ break | （不加）| → 所以 `n` 循环执行了 1~8（共 8 次 `term /= n` 并累加），加上初始 `e_approx = 1.0`（即 0! 项），**总共累加了 9 项（n=0 到 n=8）**。代码中 `n` 最终为 9（break 前 `n` 已自增为 9，但未进入下一轮），所以 `共累加了 {n} 项` 输出为 `9` 更准确。我们稍作修正（统计项数）： ✅ 更严谨的版本（显式计数）： ```python e_approx = 1.0 # n = 0 项 term = 1.0 n = 1 count = 1 # 已包含第 0 项 while True: term /= n if term < 1e-5: break e_approx += term count += 1 n += 1 print(f"e 的近似值（精度 < 1e-5）: {e_approx}") print(f"共累加了 {count} 项（对应 0! 到 (count-1)! 的倒数）") print(f"math.e = {__import__('math').e}") ``` 此版本明确 `count` 统计累加项数（初始为 1，每成功加一项 `count += 1`），结果为 `count = 9`，对应 $ \frac{1}{0!} + \frac{1}{1!} + \cdots + \frac{1}{8!} $。 ---