如何编写递归的 Python 函数来计算阶乘？

一个数的阶乘是从 1 到该数的所有正整数的积。例如，4 的阶乘是 4*3*2*1 = 24。

要使用递归的 Python 函数来计算一个数的阶乘，我们可以定义一个函数，该函数将使用较小的输入调用自身，直到它达到基本情况，即阶乘为 1 的情况。

下面是使用递归的 Python 函数计算一个数的阶乘的代码：

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)

在这个代码中，函数 factorial(n) 接受一个数字 n 作为输入，并返回该数字的阶乘。第一个 if 语句检查输入数字 n 是否为 1。如果 n 为 1，则函数返回 1 作为基本情况。如果 n 不为 1，则函数返回 n 与 n-1 的阶乘的乘积。这就是递归函数调用发生的地方，其中函数使用输入 n-1 调用自身。

要使用这个函数，你可以简单地通过要查找阶乘的数字来调用它，例如：

示例

查找 8 的阶乘

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)
print(factorial(8))

输出

40320

示例

以下代码计算了 n=6 和 n=15 的阶乘

def factorial(n):
    if n == 1:
      return 1
    else:
      res = n * factorial(n-1)
    return res
print ("factorial(6) = %d"  %factorial(6))
print ("factorial(15) = %d"  %factorial(15))

输出

factorial(6) = 720
factorial(15) = 1307674368000

下面是代码的示例：

示例

def factorial(n):
    if n==0 or n == 1:
        return 1
    else:
        return n * factorial(n-1)
print(factorial(5))

运行此代码将输出 120，这是 5 的阶乘。

输出

120

为了理解该函数的工作原理，让我们看看它如何计算 5 的阶乘：

该函数使用输入 5 被调用。

由于 5 不为 1，执行 else 块。

该函数返回 5 * factorial(4) 。

要找到 4 的阶乘，再次使用输入 4 调用该函数。

由于 4 不是 1，执行 else 块。

该函数返回 4 * factorial(3)。

要找到 3 的阶乘，再次使用输入 3 调用该函数。

由于 3 不为 1，执行 else 块。

该函数返回 3 * factorial(2) 。

要找到 2 的阶乘，再次使用输入 2 调用函数。

由于 2 不为 1，执行 else 块。

该函数返回 2 * factorial(1) 。

要找到 1 的阶乘，再次使用输入 1 调用该函数。

由于 1 等于 1，if 块被执行。

该函数返回 1 作为基本情况。

前面的函数调用继续被解决。

2 * factorial(1) 解析为 2 * 1 = 2。

3 * factorial(2) 解析为 3 * 2 = 6。

4 * factorial(3) 解析为 4 * 6 = 24。

5 * factorial(4) 解析为 5 * 24 = 120。

返回最终结果 120。

输出

120

这个过程展示了该函数如何使用递归，以重复调用自身，并使用较小的输入重复调用自身，直到它达到 1 的基本情况，然后通过将其与下一个更小输入的阶乘相乘，返回每个输入的阶乘。

以下是一些使用递归函数计算不同数字的阶乘的更多示例：

示例

找到7的阶乘

def factorial(n): 
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)
print(factorial(7))

输出

5040

示例

找到10的阶乘

def factorial(n): 
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)
print(factorial(10))

输出

3628800

示例

找到1的阶乘

def factorial(n): 
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)
print(factorial(1))

输出

1

示例

找到0的阶乘（注意，0的阶乘被定义为1）

def factorial(n):    
    if n == 1 or n == 0:
        return 1
    else:
        return n * factorial(n-1)
print(factorial(0))

输出

1

这些示例展示了如何使用函数找到不同数字的阶乘，包括0和1的边界情况。

以下是另一个示例，说明函数如何处理大型输入：

示例

找到20的阶乘

def factorial(n):    
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)

print(factorial(20))

输出

2432902008176640000

此示例表明函数可以处理大型输入，而不会遇到错误或性能问题。但是，值得注意的是，对于非常大的输入，递归函数可能会遇到堆栈溢出问题或花费很长时间才能执行，因此在这些情况下，最好使用阶乘函数的迭代实现。

以下是Python中阶乘函数的迭代实现的示例：

def factorial(n):
    result = 1
    for i in range(1, n+1):
        result *= i
    return result

在这个实现中，函数迭代所有从1到n的数字，将它们相乘以计算阶乘。结果存储在变量结果中，该变量初始化为1。

要使用此功能，可以使用要找到其阶乘的数字调用该函数，如下所示：

示例

 def factorial(n):
    result = 1
    for i in range(1, n+1):
        result *= i
    return result
print(factorial(9))

这将输出362880，即9的阶乘。

输出

362880

对于非常大的输入，这种迭代实现比递归实现具有一些优点。首先，它不会遇到堆栈溢出问题，因为它不使用函数调用来计算阶乘。其次，它通常比递归实现更快，因为它没有函数调用和堆栈操作的开销。但是，对于较小的输入，递归实现可能更简洁易懂。