> **GESP等级：四级 | 考级考点：GESP Python 四级**

# 第12节 递归初探

**课程主题**：递归算法思想入门
**课时**：60分钟
**授课对象**：7-10岁少儿
**教学形式**：五段式教学（10min导入 + 20min知识点 + 10min演示 + 15min实操 + 5min小测）

---

## 一、教学目标

### 知识与技能
1. 理解递归的核心概念——函数调用自己
2. 掌握递归的两个关键要素：终止条件 + 递归调用
3. 能用递归计算阶乘
4. 能用递归画分形树
5. 理解递归的执行过程（递去 + 归来）

### 过程与方法
- 通过"俄罗斯套娃"类比理解递归
- 通过"阶乘"建立递归的数学基础
- 通过"分形树"可视化递归过程
- 通过"递去归来"动作建立身体记忆

### 情感态度价值观
- 体会"大事化小，小事化了"的思维
- 感受递归之美——简单规则产生复杂图案
- 培养从复杂问题中找规律的能力

---

## 二、教学重难点

### 重点
- 递归的定义：函数调用自己
- 递归的两个要素：终止条件 + 递归调用
- 阶乘的递归实现

### 难点
- 理解递归的执行流程（递去和归来）
- 递归的终止条件设计（避免无限递归）
- 递归思维的建立（从"怎么做"到"怎么描述"）

---

## 三、教学准备

| 项目 | 内容 |
|------|------|
| 硬件 | 电脑（每生一台）、投影仪 |
| 软件 | Python IDLE 或 VS Code |
| 教具 | 俄罗斯套娃（实物或图片）、镜子两面（对镜无限反射） |
| 素材 | 分形树图片（不同类型） |

---

## 四、教学过程

---

### 第一阶段：故事导入（10分钟）

#### 1.1 "俄罗斯套娃"故事

**老师**：（拿出俄罗斯套娃）小朋友们，看老师带来了什么？

**学生**：套娃/娃娃！

**老师**：对！这个娃娃特别有意思——打开它，里面有个小一点的；再打开，还有更小的...

（老师现场打开一个套娃，展示3-4层）

**老师**：打开最大的，里面有中等的；打开中等的，里面有小的；打开小的，里面有最小的...
这就是我们今天要学的**递归**！

#### 1.2 生活中的递归

| 场景 | 递归描述 |
|------|---------|
| 俄罗斯套娃 | 打开一个，里面还有一个更小的 |
| 两面镜子对着照 | 镜子里有镜子里的镜子... |
| 故事《从前有座山》 | 山里有座庙，庙里有个老和尚在讲故事... |
| 西兰花（花椰菜） | 一朵西兰花掰开，每小朵像一整朵 |

#### 1.3 身体锚点

**"递去归来"动作**：
- 左手张开五指（大问题）
- 右手做越来越小的动作（问题在缩小）
- 右手握拳（到最小了——终止条件！）
- 慢慢张开五指（返回的过程）

**全班做3遍**：张开→缩小→握拳→张开！

**口诀**：
> "往前递，往回归"
> "递去的时候拆问题，归来的时候出结果"

#### 1.4 引出课题

"今天我们来学一个神奇的本领——让**函数调用自己**！这就是递归！"

---

### 第二阶段：知识点讲解（20分钟）

---

#### 2.1 什么是递归？

**递归** = 函数调用自己。

**比喻**：
- 像俄罗斯套娃一样——大娃娃里面有小娃娃
- 像照镜子——镜子里有镜子里的镜子...
- 像数学公式——用自己定义自己

```python
# 递归函数的基本结构
def 递归函数(参数):
    if 终止条件:      # ① 终止条件
        return 结果
    else:
        # ② 递归调用（缩小问题规模）
        return 递归函数(更小的参数)
```

**记忆口诀**：
> "递归递归，自己调用自己"
> "两个要点记住：终止条件+缩小范围"

---

#### 2.2 递归的两个关键

**关键1：终止条件（最小的娃娃）**
- 递归不能无限进行下去
- 必须要有一个"最小的"情况，直接返回答案
- 像套娃——最小的娃娃不能再打开了

**关键2：递归调用（缩小问题）**
- 每次调用都让问题变得更小
- 像套娃——每次打开，里面的娃娃更小
- 最终一定会到达"最小的"那个

```python
# 错误示范：没有终止条件
def bad_recursion():
    return bad_recursion()  # 永远不停止！→ 崩溃！

# 正确示范：有终止条件
def good_recursion(n):
    if n == 1:           # 终止条件
        return 1
    return good_recursion(n - 1)  # 缩小问题
```

---

#### 2.3 阶乘 —— 递归的数学基础

**阶乘公式**：
> n! = n × (n-1)!
> 1! = 1
> 例如：5! = 5 × 4 × 3 × 2 × 1 = 120

**递归写法**：
```python
def factorial(n):
    # 终止条件
    if n == 1:
        return 1
    # 递归调用
    return n * factorial(n - 1)
```

**执行过程图解（以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(1) = 1
        factorial(2) = 2 * 1 = 2
      factorial(3) = 3 * 2 = 6
    factorial(4) = 4 * 6 = 24
  factorial(5) = 5 * 24 = 120
```

**老师用板书画出这个"漏斗"形状**：
```
factorial(5)
  └── 5 * factorial(4)
        └── 4 * factorial(3)
              └── 3 * factorial(2)
                    └── 2 * factorial(1)
                          └── 1    ← 触底
                    └── 2 * 1 = 2
              └── 3 * 2 = 6
        └── 4 * 6 = 24
  └── 5 * 24 = 120
```

**身体锚点配合**：
- "递去"：右手不断缩小（5→4→3→2→1）
- "触底"：握拳（到1了！）
- "归来"：手慢慢张开（1→2→6→24→120）

---

#### 2.4 递归 vs 循环

同样的阶乘，用循环怎么写？

```python
# 循环写法
def factorial_loop(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# 递归写法
def factorial_recursive(n):
    if n == 1:
        return 1
    return n * factorial_recursive(n - 1)
```

| 对比 | 循环 | 递归 |
|------|------|------|
| 思路 | 一步步算 | 大事化小 |
| 代码 | 有变量跟踪 | 代码简洁 |
| 理解 | 直观 | 稍难但优雅 |
| 适合 | 简单重复 | 分治问题 |

---

#### 2.5 更多递归例子：斐波那契数列

**定义**：
> fib(1) = 1
> fib(2) = 1
> fib(n) = fib(n-1) + fib(n-2)

```python
def fib(n):
    if n == 1 or n == 2:
        return 1
    return fib(n - 1) + fib(n - 2)
```

**执行图解（fib(5)）**：
```
          fib(5)
         /      \
    fib(4)      fib(3)
    /    \      /    \
fib(3)  fib(2) fib(2) fib(1)
/    \
fib(2) fib(1)
```

**老师解释**：这像一棵倒着的树！每个问题分成两个更小的问题。

---

#### 2.6 递归的执行过程深度理解

**递归的核心思维**：
1. **递去**（递推）：把大问题拆成小问题，一直拆到不能再拆
2. **触底**（终止）：到达终止条件，直接返回
3. **归来**（回归）：小问题的答案组合成稍大问题的答案，一直回到最初

**记忆口诀**：
> "递归像套娃，一层层打开（递去），再一层层回来（归来）"
> "往前递，往回归"

**三个"要"和三个"不要"**：

| 要做的 | 不要做的 |
|--------|---------|
| 要写终止条件 | 不要忘记终止条件（会死循环） |
| 要让问题变小 | 不要让问题变大（永远到不了终点） |
| 要相信递归能算对 | 不要一层层去追踪（要相信它！） |

---

### 第三阶段：教师演示（10分钟）

#### 3.1 演示1：阶乘递归

```python
def factorial(n):
    print(f"  计算 factorial({n})...")
    if n == 1:
        print(f"  → factorial(1) = 1 （触底！）")
        return 1
    result = n * factorial(n - 1)
    print(f"  → factorial({n}) = {n} × factorial({n-1}) = {result}")
    return result

print("计算 5! =")
result = factorial(5)
print(f"结果 = {result}")
```

**运行过程**，让学生看到"递去"和"归来"的过程。

#### 3.2 演示2：turtle分形树

运行 `04_递归初探.py` 的turtle分形树演示。

**老师讲解**：
```
画一棵树的递归规则：
  ① 画树干
  ② 在树干顶端分两枝（左枝、右枝）
  ③ 每根树枝继续分两枝...
  ④ 树枝太短了就停止（终止条件）
```

#### 3.3 演示3：递归执行过程可视化

用打印缩进展示递归的"递去归来"过程。

---

### 第四阶段：学生实操（15分钟）

#### 实操任务1：写阶乘递归（5分钟）

**要求**：
1. 写一个递归函数 factorial(n)
2. 添加 print 语句，打印每次调用的过程
3. 计算 6! 并输出

**参考代码**：
```python
def factorial(n):
    print(f"调用 factorial({n})")
    if n == 1:
        print(f"返回 1")
        return 1
    result = n * factorial(n - 1)
    print(f"返回 {n} × {n-1}! = {result}")
    return result

print(factorial(6))
```

#### 实操任务2：递归求和（5分钟）

**要求**：
用递归计算 1 + 2 + 3 + ... + n 的和。

**递归公式**：
> sum(n) = n + sum(n-1)
> sum(1) = 1

```python
def sum_recursive(n):
    # 你的代码
    pass
```

#### 实操任务3：递归画正方形嵌套（5分钟）

**要求**：
用turtle画嵌套正方形——大正方形里面套小正方形...

```python
import turtle

t = turtle.Turtle()
t.speed(5)

def draw_squares(size):
    if size < 20:  # 太小就不画了
        return
    # 画一个正方形
    for _ in range(4):
        t.forward(size)
        t.left(90)
    # 缩小，画里面的
    t.penup()
    t.forward(10)
    t.left(90)
    t.forward(10)
    t.right(90)
    t.pendown()
    draw_squares(size - 20)  # 递归！

draw_squares(200)
turtle.done()
```

---

### 第五阶段：小测验（5分钟）

#### 题目1（选择题）
递归是什么？
A. 函数调用另一个函数  B. 函数调用自己  C. 循环执行代码  D. 用if判断条件

**答案**：B

#### 题目2（填空题）
递归的两个关键要素是：①________ ②________

**答案**：终止条件、递归调用（缩小问题）

#### 题目3（判断题）
递归函数可以没有终止条件。（对/错）

**答案**：错。没有终止条件会导致无限递归，程序崩溃。

#### 题目4（计算题）
```python
def f(n):
    if n == 0:
        return 0
    return n + f(n - 1)

print(f(4))
```

输出结果是什么？
**答案**：10（4+3+2+1+0=10）

#### 题目5（选择题）
递归的"递去"和"归来"分别指什么？
A. 递去=拆问题，归来=组合答案
B. 递去=组合答案，归来=拆问题
C. 递去=计算答案，归来=输出
D. 递去=开始，归来=结束

**答案**：A

---

## 五、板书设计

```
+========================================+
|          递归初探（俄罗斯套娃）          |
+========================================+
|                                         |
|  定义：函数调用自己                     |
|                                         |
|  两个关键：                             |
|  ① 终止条件 —— 最小的娃娃              |
|  ② 递归调用 —— 缩小问题                |
|                                         |
|  阶乘：n! = n × (n-1)!                |
|  5! = 5×4×3×2×1 = 120                |
|                                         |
|  过程：递去（拆）→ 触底 → 归来（合）   |
|                                         |
|  分形树：简单规则产生复杂图案           |
+========================================+
```

---

## 六、课后作业说明

参见《课后练习_第12节.md》文件。

**作业要点**：
1. 递归阶乘练习——巩固基础
2. 递归求和/求积——举一反三
3. 画分形树——创意应用

---

## 七、常见错误与应对

| 错误 | 原因 | 解决方法 |
|------|------|---------|
| RecursionError | 递归太深或没有终止条件 | 检查终止条件是否可达 |
| 返回值错误 | return位置不对 | 确保每层都返回了值 |
| 死循环 | 问题没有缩小 | 检查参数是否在变化 |
| 思维混乱 | 试图跟踪每一层 | 用"信任递归"思维 |

---

## 八、教学反思（教师填写）

| 维度 | 评价 | 备注 |
|------|------|------|
| 导入环节 | ___/5 | 套娃是否直观 |
| 递归概念讲解 | ___/5 | 学生是否理解"自己调用自己" |
| 阶乘演示 | ___/5 | 是否理解递去归来过程 |
| 分形树演示 | ___/5 | 是否引起兴趣 |
| 小测 | ___/5 | 正确率 |

---

## 九、拓展延伸

### 递归的更多应用
- 文件目录遍历（文件夹里嵌套文件夹）
- 汉诺塔游戏
- 快速排序和归并排序
- 语法分析（编译器）
- 分形图形（雪花曲线、谢尔宾斯基地毯）

### 家庭互动
- 和爸妈一起在网上搜索"分形图案"，感受递归之美
- 看看家里的西兰花——它是不是也是递归结构？

---

*教案编写日期：2026年6月*
*适用阶段：19_文件与算法入门*