Python快速入门专业版（三十一）：递归函数：自己调用自己的奥秘（斐波那契数列案例）-优快云博客

在这里插入图片描述

前言
一、递归函数的定义：自己调用自己的函数
二、递归三要素：构建有效递归的核心
三、代码演示：递归计算n的阶乘
四、递归的优缺点：何时该用递归？
- 优点：
- 缺点：
五、案例：斐波那契数列的递归与非递归实现
- 1. 递归实现斐波那契数列
- 2. 非递归（循环）实现斐波那契数列
六、总结

前言

在编程中，有一种特殊的函数能够像“俄罗斯套娃”一样自我嵌套——这就是递归函数。它通过“自己调用自己”的方式，将复杂问题拆解为更小的同类问题，最终通过解决小问题推导出大问题的答案。递归不仅是一种编程技巧，更体现了“分而治之”的思维方式，尤其适合解决数学定义中天然带有递归结构的问题，比如阶乘和斐波那契数列。

一、递归函数的定义：自己调用自己的函数

递归函数是指在函数体内直接或间接调用自身的函数。它的核心逻辑是：对于一个复杂问题，若能找到一种方式将其分解为与原问题结构相同但规模更小的子问题，且子问题最终能被直接解决（无需再分解），就可以用递归实现。

递归函数必须满足一个关键条件：存在终止条件。如果没有终止条件，函数会无限递归调用，最终导致内存栈溢出（Stack Overflow）。

二、递归三要素：构建有效递归的核心

一个正确的递归函数必须同时具备三个要素，缺一不可：

1. 终止条件（Base Case）

终止条件是递归的“出口”，指无需递归即可直接返回结果的场景。它能确保递归过程不会无限进行。

2. 递归步骤（Recursive Step）

递归步骤是将原问题分解为更小的子问题的过程，即用函数自身解决规模更小的同类问题。子问题的结构必须与原问题一致，且规模必须逐渐缩小，最终能抵达终止条件。

3. 返回值（Return Value）

递归函数的返回值需要将子问题的结果“合并”为原问题的结果，即子问题的解必须能为原问题的解提供支持。

三、代码演示：递归计算n的阶乘

阶乘的数学定义为：n! = n × (n-1) × (n-2) × ... × 1，且1! = 1。根据定义，n!可以分解为n × (n-1)!，这是典型的递归场景。

def factorial(n):
    # 1. 终止条件：n=1时直接返回1（1! = 1）
    if n == 1:
        return 1
    # 2. 递归步骤：将n!分解为n × (n-1)!，调用自身解决子问题
    # 3. 返回值：将子问题结果与n相乘，得到原问题结果
    else:
        return n * factorial(n - 1)

# 测试：计算5的阶乘
print(f"5的阶乘 = {factorial(5)}")  # 输出：120

执行流程解析（以factorial(5)为例）：

递推阶段（分解问题）：
factorial(5) → 等待5 × factorial(4)的结果
factorial(4) → 等待4 × factorial(3)的结果
factorial(3) → 等待3 × factorial(2)的结果
factorial(2) → 等待2 × factorial(1)的结果
factorial(1) → 触发终止条件，返回1
回归阶段（合并结果）：
factorial(2) 得到结果 2 × 1 = 2 并返回
factorial(3) 得到结果 3 × 2 = 6 并返回
factorial(4) 得到结果 4 × 6 = 24 并返回
factorial(5) 得到结果 5 × 24 = 120 并返回

四、递归的优缺点：何时该用递归？

优点：

代码简洁直观：递归函数的逻辑与数学定义高度一致，无需手动处理循环和状态变量，可读性强。例如阶乘的递归实现直接对应其数学公式。
适合解决分治问题：对于树遍历、图搜索、排列组合等具有递归结构的问题，递归实现比非递归更自然。

缺点：

栈溢出风险：每次递归调用都会在内存栈中保存函数的参数、局部变量等状态，若递归深度过大（如计算factorial(10000)），会耗尽栈空间，导致RecursionError。
效率较低：递归涉及频繁的函数调用和栈操作，且可能存在大量重复计算（如未优化的斐波那契数列），性能通常低于循环实现。
调试困难：多层递归的调用栈复杂，难以追踪中间状态，排查问题时不如循环直观。

五、案例：斐波那契数列的递归与非递归实现

斐波那契数列是递归的经典案例，其定义为：

第1项（F(1)）= 1
第2项（F(2)）= 1
第n项（F(n)）= F(n-1) + F(n-2)（n ≥ 3）

1. 递归实现斐波那契数列

def fibonacci_recursive(n):
    # 终止条件：第1项和第2项均为1
    if n == 1 or n == 2:
        return 1
    # 递归步骤：F(n) = F(n-1) + F(n-2)
    return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)

# 测试前10项
print("斐波那契数列前10项（递归）：")
for i in range(1, 11):
    print(fibonacci_recursive(i), end=" ")  # 输出：1 1 2 3 5 8 13 21 34 55

问题分析：
递归实现存在严重的重复计算。例如计算fibonacci_recursive(5)时，fib(3)被计算2次，fib(2)被计算3次。随着n增大，重复计算呈指数级增长，导致n=30时计算明显变慢。

2. 非递归（循环）实现斐波那契数列

为解决递归效率问题，可用循环实现，通过迭代避免重复计算：

def fibonacci_iterative(n):
    # 处理前两项的终止条件
    if n == 1 or n == 2:
        return 1
    # 用变量保存前两项的结果，避免重复计算
    a, b = 1, 1  # a=F(n-2)，b=F(n-1)
    for _ in range(3, n + 1):
        c = a + b  # 当前项 = 前两项之和
        a, b = b, c  # 更新前两项，为下一次迭代做准备
    return b

# 测试前10项
print("\n斐波那契数列前10项（循环）：")
for i in range(1, 11):
    print(fibonacci_iterative(i), end=" ")  # 输出：1 1 2 3 5 8 13 21 34 55