Python计算1到n阶乘之和的for循环实现

计算 1 到 n 的阶乘之和，即求和公式 S = 1! + 2! + 3! + ... + n! 的计算结果。在 Python 中，使用 for 循环实现该任务最简洁且高效的路径是单层循环累乘法：在遍历数字 1 到 n 的过程中，借助递推性质 i! = (i - 1)! * i 持续累乘当前项，并实时累加到总和变量中。这种方式仅需单层循环即可在 O(n) 时间内完成运算。

一、核心算法思想与执行流程

很多初学者在面对阶乘和时，容易联想到“先写一个函数算阶乘，再写一个循环加起来”。这种思路虽然直观，但会导致历史项被反复重复乘算。实际上，相邻两项阶乘之间存在天然的递推关系：只要保留上一轮循环得到的 (i - 1)!，将其直接乘以当前数字 i，即可获得 i!，完全无需重新从 1 乘到 i。

整个求解过程清晰地拆解为以下五个步骤：

1. 初始化变量：设立累计总和 total_sum = 0 以及当前阶乘临时变量 current_factorial = 1。
2. 区间遍历：使用 range(1, n + 1) 产生从 1 到 n 的整数序列，注意右边界必须是 n + 1。
3. 递推累乘：每进入一轮循环，执行 current_factorial *= i，直接求得当前 i 的阶乘。
4. 同步累加：执行 total_sum += current_factorial，将当前阶乘结果纳入总和。
5. 返回输出：循环结束时，total_sum 即为 1 到 n 阶乘之和。

二、标准实现：推荐的单层 for 循环代码

下面给出具备参数校验与边界防御的完整 Python 函数实现。该代码可在标准 Python 3 环境下直接运行：

def sum_of_factorials(n: int) -> int:
    """
    使用单层 for 循环计算 1! + 2! + ... + n! 之和
    时间复杂度: O(n)，空间复杂度: O(1)
    """
    # 边界处理与输入合法性校验
    if not isinstance(n, int) or n < 1:
        raise ValueError("参数 n 必须是大于或等于 1 的正整数")

    total_sum = 0          # 保存 1 到 n 的阶乘总和
    current_factorial = 1  # 保存当前迭代项 i 的阶乘值

    # 遍历 1 到 n，注意 range 右边界为 n + 1
    for i in range(1, n + 1):
        current_factorial *= i   # 利用上一轮结果递推计算: i! = (i-1)! * i
        total_sum += current_factorial  # 累加当前阶乘到总和中

    return total_sum


# 验证示例
if __name__ == "__main__":
    test_cases = [1, 3, 4, 5]
    for num in test_cases:
        result = sum_of_factorials(num)
        print(f"n = {num}: 1! + ... + {num}! = {result}")

三、对照分析：单层循环与双层嵌套循环的本质差异

为了加深对递推累乘价值的理解，我们可以对比另一种常见的初学者写法——双层嵌套 for 循环。在双层循环中，外层控制 i 从 1 遍历到 n，内层循环对每个 i 从 1 重新乘到 i：

# 双层嵌套 for 循环（对照示例：存在大量重复计算）
def sum_of_factorials_nested(n: int) -> int:
    total_sum = 0
    for i in range(1, n + 1):
        factorial_i = 1
        for j in range(1, i + 1):  # 内层每次都从 1 重新相乘
            factorial_i *= j
        total_sum += factorial_i
    return total_sum

这两种方案在功能上完全等价，但在运算逻辑与效率上存在决定性差异：

四、推导演示：变量状态迭代追踪

为了清晰观察单循环在执行中是如何“承前启后”的，我们以 n = 4 为例，追踪每一轮循环进入与结束时变量的具体取值变化：

从追踪过程可以清楚看到：在第 3 轮计算 3! 时，直接由第 2 轮遗留下来的 2 乘以 3 得到 6；在第 4 轮计算 4! 时，直接用 6 乘以 4 得到 24。每一轮只消耗一次乘法和一次加法，既精准又高效。

五、常见易错点与边界处理

在编写与应用上述 for 循环代码时，有两处细节极易被疏忽：

• range 区间右端点遗漏加 1：Python 的 range(start, stop) 遵循“左闭右开”规则（包含 start，但不包含 stop）。若写成 range(1, n)，实际遍历只到 n - 1，导致最终结果遗漏了 n!。因此必须显式写为 range(1, n + 1)。
• 大整数自动扩展与性能认知：Python 3 的整型（int）内部支持任意精度大整数，不会像 C/C++ 或 Java 那样在 n > 12 或 n > 20 时产生 32 位或 64 位整数溢出报错。即便计算 n = 100 的阶乘和，Python 也能准确计算出完整数值。但需要注意，由于阶乘增长极其迅猛，过大的 n（例如 n > 10000）会导致单次高精度大整数乘法耗时增加，应避免不必要的超大范围运算。

六、知识梳理与总结

使用 for 循环实现 1 到 n 阶乘之和的核心要诀可以归纳为四条规范：

掌握“递推状态复用”这一技巧，不仅能以最精简的几行代码解决阶乘和问题，也是后续理解动态规划、前缀和等经典算法的基础思维模型。