# 第13节教案 —— 算术运算符完整 + - * / // % ** + 运算优先级（60分钟）
> **GESP等级：一级 | 考级考点：GESP Python 一级**


> **GESP 考点**：#12 算术运算符（+ - * / // % **）及运算优先级
> **教学形式**：旧知导入（0-10min）→ 七种算符精讲 + 优先级（10-30min）→ 演示/整除/取余（30-40min）→ 上机实操（40-55min）→ 小测收尾（55-60min）
> **时长**：60 分钟 | **对应文件**：`第13节_算术运算.py`、`课堂练习册_第13节_算术运算.md`、`课后练习卡_第13节_算术运算.md`
> **核心定位**：完整算术运算符体系。孩子必须建立"Python 的算术和数学算术基本一致，但多了 // % ** 三个特殊算符"的认知。这是后续所有几何计算、游戏逻辑、数值处理的基础。

---

## GESP 知识映射

| GESP-1 考点 | 本关对应 | 身体锚点 |
|------------|---------|---------|
| #12 算术运算符 | `+` `-` `*` `/` `//` `%` `**` 七种运算符的含义与使用 | 手指比划七种操作 |
| #12 运算优先级 | 括号 > `**` > `*` `/` `//` `%` > `+` `-` | 身体叠罗汉（优先级从高到低） |

---

## 教学目标

孩子下课后能：

- **列出七种算术运算符**：`+` `-` `*` `/` `//` `%` `**`
- **说清 // 和 / 的区别**：`/` 得小数（10/3=3.333...），`//` 取整数部分（10//3=3）
- **说清 % 的含义**：`%` 取余数（10%3=1），"分完还剩多少"
- **说清 ** 的含义**：`**` 指数运算（2**10=1024），"自己乘自己 N 次"
- **用运算符组合计算**：在 turtle 中直接用算术表达式控制前进长度、角度、循环次数
- **用 % 判断整除**：`n % 2 == 0` 是偶数，用 `i % 3 == 0` 控制抬笔画虚线
- **记住优先级口诀**：括号 > 幂 > 乘除 > 加减
- **回答小测题**：`10//3=? 10%3=? 2**3=?`

---

## 教学节奏总览

| 时间段 | 时长 | 阶段 | 核心内容 | 身体锚点 | 关键记忆句 |
|--------|------|------|---------|---------|-----------|
| 0-10min | 10min | 导入——360÷N 引出全套算术 | 回顾 360/边数 → "除法能用来算，那加减乘除全套呢？" → 引出七种运算符 | 手掌张开七根手指代表七种算符 | "`//` 整除去小数，`%` 取余数，`**` 指数爆炸" |
| 10-30min | 20min | 知识点精讲 | ①`+`加 ②`-`减 ③`*`乘 ④`/`除 ⑤`//`整除 ⑥`%`取余 ⑦`**`幂 ⑧运算优先级 | 每讲一种算符配合一个手指+一个 turtle 场景 | "优先级：括号 > 幂 > 乘除 > 加减" |
| 30-40min | 10min | 演示——/ 与 // 与 % 的区别 | `print(10/3)` vs `print(10//3)` vs `print(10%3)` → 三种不同结果 | 分糖果实物演示 | "`/` 分得精确带小数，`//` 只管整数，`%` 只管剩下多少" |
| 40-55min | 15min | 上机实操 | ①计算100//7和100%7 ②用**画爆炸螺旋 ③用%画虚线 | 上机巡视+个别指导 | "// 整除去小数，% 取余数" |
| 55-60min | 5min | 小测收尾 | "10//3=? 10%3=? 2**3=?" + 全班齐读口诀 | 口答三问 | "//整除去小数%取余数**指数爆炸" |

> **节奏设计逻辑**：旧知回顾（360÷边数）→ 七种算符体系引入 → 重点区分 / // % → 三种上机实操 → 小测巩固。

---

## 课前准备

### 讲台道具清单
- **一包糖果或小饼干**（约 30 颗，用在演示 / // % 区别时实物分糖果）
- **10 颗棋子/硬币**（演示 10//3 和 10%3 用）
- **黑板/白板布局**：
  - 正中顶部：**➕ 第13节：算术运算符 + - * / // % ** ➖**
  - 左侧：七种运算符表格区
  - 中央：优先级金字塔图
  - 右侧：实操题目区 + 口诀区

### 学生电脑环境（课前确认）
- 每台电脑已打开 `第13节_算术运算.py`
- Python 环境正常，`turtle` 模块可用

---

## 阶段一：导入——360÷N 引出全套算术（0-10 分钟）

### 1.1 旧知回顾——360÷边数用过除法（0-3 分钟）

> "同学们，还记得当初我们画正多边形时，怎么算转多少度的？"

引导回答 → 板书：

```python
t.right(360 / 边数)    # 360 除以 边数 = 每次转的角度
```

> "对！`360 / 边数`——除法！那时候我们就用除法了。但是 Python 里的算术运算符可不止有除法和我们之前用过的加减乘——它一共有 **7 种**！"

### 1.2 七种算符总览——张开一只手还不够（3-5 分钟）

老师伸出左手，竖起 5 根手指：

> "5 根手指——代表你们已经会的 5 种：`+` `-` `*` `/`——加减乘除，还有 `=` 赋值。但 Python 还有 3 个你们没学过的新朋友！"

板书七种算符：

```
Python 七种算术运算符：

  旧朋友（学过的）：   +  -  *  /
  新朋友（今天学）：   //  %  **
```

> "`//` 叫**整除**，`%` 叫**取余**（取余数），`**` 叫**幂**（指数运算）。今天我们要把这三兄弟和四老友一网打尽！"

### 1.3 生活场景导入——分糖果（5-10 分钟）

老师拿出 10 颗糖果：

> "假设我有 10 颗糖果要分给 3 个小朋友——每人能分几颗？"

孩子可能回答"3 颗"或"3.333..."。

> "如果用普通除法——`10 / 3 = 3.333...`——每人 3.333 颗，糖果不能掰开啊！如果问每人**整数**几颗——`10 // 3 = 3`——整除，每人 3 颗。那还剩几颗？`10 % 3 = 1`——取余数，分了 3×3=9 颗，还剩 1 颗！"

实物演示：10 颗糖分给 3 个小朋友，每人 3 颗，剩 1 颗。

```
10 ÷ 3 = 3.333...     →  /  普通除法
10 // 3 = 3            →  // 整除（只要整数部分）
10 % 3 = 1             →  %  取余数（分完还剩多少）
```

> "这三个新朋友就是干这三件事的！"

**关键记忆句**（全班齐读 2 遍）：

> **"`//` 整除去小数，`%` 取余数，`**` 指数爆炸！"**

---

## 阶段二：知识点精讲——七种运算符 + 优先级（10-30 分钟）

### 2.1 运算符①：`+` 加——在 turtle 中直接运算（10-13 分钟）

> "加号最简单——1+1=2。但在 turtle 里，我们可以直接在 `forward()` 里面做加法，不用先算好！"

板书：

```python
t.forward(50 + 50)    # Python 先算 50+50=100，再 forward(100)
```

> "这行代码，Python 先算 `50 + 50`，得到 `100`，然后执行 `forward(100)`——一步到位！"

**对比**（板书）：

```python
# 老方法：先算好再写
距离 = 100
t.forward(距离)

# 新方法：直接在括号里算
t.forward(50 + 50)    # 等价！Python 自己会算
```

> "而且不只能加数字——还能加变量！"

```python
base = 50
t.forward(base + 30)   # 先算 base+30=80，再 forward(80)
```

**身体锚点**——双手交叉比 +：**"加！合在一起变多！"**

### 2.2 运算符②：`-` 减——360-180=180° 掉头（13-15 分钟）

> "减法也一样——直接在 turtle 里算！"

板书：

```python
t.right(360 - 180)    # 算 360-180=180，转 180° 掉头
```

> "t.right(360-180) 等于 t.right(180)——乌龟掉头！这是把数学计算藏在了代码里。"

**现场演示**：

```python
# 掉头效果
t.forward(100)
t.right(360 - 180)    # 等于 t.right(180)——掉头
t.forward(100)
# 乌龟画一条线出去，再画一条线回来——形成一个矩形的一条边加折返
```

> "用 `360 - 180` 写，比直接写 `180` 更能让人明白"这是转了半圈"——180 是 360 的一半嘛！"

**身体锚点**——双手一前一后拉开比 -：**"减！变少变小变方向！"**

### 2.3 运算符③：`*` 乘——边长 × 3（15-17 分钟）

> "乘法——`*` 号，电脑上不是 ×，是星号 `*`。"

```python
t.forward(边长 * 3)    # 边长 50，则 forward(150)，三倍长！
```

**对比演示**：

```python
边长 = 50
t.forward(边长)        # 走 50
t.forward(边长 * 3)    # 走 150——三倍！
```

> "`边长 * 3`——把边长放大三倍。不用重新算，Python 帮你算好！"

**身体锚点**——双手交叉比大 X 姿势：**"乘！翻倍放大！"**

### 2.4 运算符④：`/` 除——360 / 边数（17-19 分钟）

> "除法——老朋友了！画正多边形的核心公式："

```python
t.right(360 / 边数)    # 360 除以边数 = 每次转的角度
```

> "`/` 除法的结果**永远是小数**（浮点数），即使能整除："

```python
print(10 / 2)   # 5.0  （不是 5，是 5.0——小数！）
print(10 / 3)   # 3.3333333333333335
```

> "如果你不想要小数——往下看 `//` 整除！"

### 2.5 运算符⑤：`//` 整除——100 // 3 = 33（19-21 分钟）

> "`//`——两个除号连在一起——叫**整除**。它只管"整数部分"，不要小数！"

```python
print(100 / 3)     # 33.333333333333336  — 普通除法
print(100 // 3)    # 33                  — 整除，只要整数部分
```

**实物演示——10 个棋子分给 3 人**：

老师拿出 10 颗棋子和 3 个纸杯：
- `/` 除法：10 ÷ 3 = 3.333...（每人 3.333 颗——不可能！）
- `//` 整除：10 // 3 = 3（每人整 3 颗——可以！）
- `%` 取余：10 % 3 = 1（分完剩 1 颗——看下面！）

**板书对比**：

```
10 / 3   →   3.333...    普通除法（保留小数）
10 // 3  →   3           整除（去掉小数部分，向下取整）
```

**关键对比**：

```
  正数整除：  10 // 3 = 3      (3×3=9，最接近 10 但不大于 10)
              100 // 7 = 14    (14×7=98，最接近 100)
              99 // 10 = 9     (9×10=90)
```

> "记住：`//` 是**取整**！不是四舍五入——是直接去掉小数部分！"

### 2.6 运算符⑥：`%` 取余——100 % 3 = 1（21-24 分钟）

> "`%`——百分号？不，在这里它叫**取余**——取余数。分完还剩多少？"

```python
print(100 % 3)    # 1   100 ÷ 3 = 33 余 1
print(10 % 3)     # 1   10 ÷ 3 = 3 余 1
print(7 % 2)      # 1   7 ÷ 2 = 3 余 1（奇数）
print(8 % 2)      # 0   8 ÷ 2 = 4 余 0（偶数！）
```

**实物棋盘演示**：

```
10 颗棋子 ÷ 3 人：
 每人 3 颗 → 3×3=9 → 还剩 1 颗
 10 // 3 = 3  （每人整数颗）
 10 % 3 = 1   （还剩 1 颗）
```

> "`%` 最常用的地方——判断奇偶数！一个数 `% 2` 等于 0 就是偶数，等于 1 就是奇数。"

```python
如果是  % 2 == 0  → 偶数
如果是  % 2 == 1  → 奇数
```

> "这个后面画**虚线**的时候特别好用——每 3 次抬一次笔，就用 `i % 3 == 0` 来判断！"

### 2.7 运算符⑦：`**` 幂——2 ** 10 = 1024（24-26 分钟）

> "`**`——两个乘号连在一起。不是乘法——是**幂运算**（指数），也叫"次方"。"

```python
print(2 ** 10)     # 1024   2 的 10 次方 = 2×2×2×2×2×2×2×2×2×2
print(3 ** 3)      # 27     3 的 3 次方 = 3×3×3
print(10 ** 2)     # 100    10 的 2 次方 = 10×10（也就是平方）
```

**板书对比**：

```
2 * 10    = 20         （2 重复加 10 次）
2 ** 10   = 1024       （2 重复乘 10 次）—— 指数爆炸！
```

> "看到了吗？`2 * 10 = 20`——只是 2 加了 10 次。但 `2 ** 10 = 1024`——2 自乘 10 次，结果是 1024——**50 倍**！这就是**指数爆炸**——数字会飞一样增长！"

**爆炸感演示**：

```
2**1 = 2
2**2 = 4
2**3 = 8
2**4 = 16
2**5 = 32
2**6 = 64
2**7 = 128
2**8 = 256
2**9 = 512
2**10 = 1024    ← 从 2 到 1024，爆炸了！
```

> "用 `**` 画图——边长从 1² 到 10²——1, 4, 9, 16, 25...——每次增加都不一样——这就是"爆炸螺旋"！"

### 2.8 运算优先级——括号 > 幂 > 乘除 > 加减（26-30 分钟）

> "如果一行代码里既有加法又有乘法——先算谁？"

板书：

```python
print(2 + 3 * 4)    # 先算 3×4=12，再算 2+12=14，不是 20！
```

> "Python 和数学一样——**先乘除，后加减**。不是从左到右！"

**优先级金字塔**（板书画金字塔）：

```
        🏆 最高优先级
        ┌─────────┐
        │  ( )    │   括号——先算括号里的
        ├─────────┤
        │  **     │   幂——次方
        ├─────────┤
        │ * / // %│   乘、除、整除、取余
        ├─────────┤
        │  + -    │   加、减——最低
        └─────────┘
        最低优先级
```

**逐层讲解**：

> **第一层：括号 `( )`**——永远最先算。想改变计算顺序就加括号。
> **第二层：幂 `**`**——次方，指数运算。
> **第三层：乘 `*`、除 `/`、整除 `//`、取余 `%`**——同一级，从左到右算。
> **第四层：加 `+`、减 `-`**——同一级，从左到右算。

**黑板举例**：

```python
print(2 + 3 * 4 ** 2)     # 先算 4**2=16 → 3*16=48 → 2+48=50
print((2 + 3) * 4 ** 2)   # 先算 (2+3)=5 → 4**2=16 → 5*16=80
```

**逐行推演**：

```
2 + 3 * 4 ** 2
   ↓ 先算 **
2 + 3 * 16
   ↓ 再算 *
2 + 48
   ↓ 最后算 +
50
```

**对比加括号**：

```
(2 + 3) * 4 ** 2
   ↓ 先算括号
5 * 4 ** 2
   ↓ 再算 **
5 * 16
   ↓ 最后算 *
80
```

> "看到了吗？加不加括号，结果完全不同——`50` vs `80`！括号决定了顺序！"

**身体锚点——优先级叠罗汉**：

全班起立：
- 蹲最低：加、减（最低优先级）
- 站起来：乘、除、整除、取余（中间）
- 站椅子上：幂 **（高）
- 高举双手比圆：括号（最高）

齐喊："**括号 > 幂 > 乘除 > 加减！**"

---

## 阶段三：演示——/ 与 // 与 % 三种不同结果（30-40 分钟）

### 3.1 三行代码，三种结果（30-33 分钟）

打开 `第13节_算术运算.py`，投影运行模式 1：

```python
# 三种除法结果对比
print("10 / 3  =", 10 / 3)      # 普通除法
print("10 // 3 =", 10 // 3)     # 整除
print("10 % 3  =", 10 % 3)      # 取余
```

运行结果：

```
10 / 3  = 3.3333333333333335
10 // 3 = 3
10 % 3  = 1
```

> "看到了吗？同一个 `10` 和 `3`，三种不同的运算符——三种完全不同的结果！
> - `/` 普通除法：3.333...（精确但带小数）
> - `//` 整除：3（只要整数部分）
> - `%` 取余：1（剩下 1 颗糖）"

### 3.2 再算一组——更多数字对比（33-35 分钟）

```python
print("===== 更多对比 =====")
print("100 / 7  =", 100 / 7)
print("100 // 7 =", 100 // 7)
print("100 % 7  =", 100 % 7)
print()
print("7 / 2  =", 7 / 2)
print("7 // 2 =", 7 // 2)
print("7 % 2  =", 7 % 2)
```

> "100 ÷ 7：7×14=98，还剩 2——所以 `100//7=14`，`100%7=2`。"

### 3.3 验证：// 和 % 是互补的（35-37 分钟）

> "整除和取余是什么关系？看好了——"

```python
a = 100
b = 7
商 = a // b    # 14
余 = a % b     # 2
print(商 * b + 余)    # 14 * 7 + 2 = 98 + 2 = 100
```

> "`商 × 除数 + 余数 = 被除数`——整除和取余是配对的！`14 × 7 + 2 = 100`——验证了！"

板书：

```
被除数 ÷ 除数 = 商 ... 余数
  100   ÷  7  = 14  ...  2

验证： 14 × 7 + 2 = 98 + 2 = 100 ✅

公式： a // b = 商，a % b = 余数
       (a // b) * b + (a % b) == a  ← 永远成立！
```

### 3.4 用 % 判断奇偶——"除以 2 看余数"（37-40 分钟）

> "`%` 最常见的用途——判断一个数是奇数还是偶数。"

```python
print("===== % 判断奇偶 =====")
n = 7
print(n, "% 2 =", n % 2)   # 1 → 奇数
n = 8
print(n, "% 2 =", n % 2)   # 0 → 偶数
```

> "任何整数除以 2——余数为 0 就是偶数，余数为 1 就是奇数。这是编程里判断奇偶的标准写法！"

**关键记忆句**：

> **"n % 2 == 0 → 偶数，n % 2 == 1 → 奇数！"**

---

## 阶段四：上机实操——三道题（40-55 分钟）

> "现在轮到你们亲自动手了！三道实操——从⭐到⭐⭐⭐，难度递增。"

### 实操①：计算 100//7 和 100%7（40-45 分钟 · ⭐）

**题目**：打开 `第13节_算术运算.py` 的模式 4，用 `print()` 计算并输出结果。

```python
# 实操①：计算 100//7 和 100%7
print("===== 实操①：100 // 7 和 100 % 7 =====")

# 请在下方写出代码：
# 1. 计算并输出 100 // 7
# 2. 计算并输出 100 % 7
# 3. 验证： 商 × 7 + 余数 = 100？
```

**预期输出**：

```
===== 实操①：100 // 7 和 100 % 7 =====
100 // 7 = 14
100 % 7 = 2
验证：14 × 7 + 2 = 100 ✅
```

**巡视重点**：
| 检查项目 | 通过标准 |
|---------|---------|
| `//` 写法 | 两个除号，不是 `/` |
| `%` 写法 | 百分号，不是 `/` |
| 验证公式 | `(100//7)*7 + (100%7) == 100` |

**引导话术**：
> "100 颗糖分给 7 个小朋友——每人整颗能分多少？还剩多少？用 `//` 和 `%` 一秒算出来！"

### 实操②：用 ** 画爆炸螺旋（45-50 分钟 · ⭐⭐）

**题目**：用 `**` 幂运算让边长指数增长，画出"爆炸螺旋"——边长从 1²=1, 2²=4, 3²=9, 4²=16... 越来越大，速度越来越快！

```python
# 实操②：用 ** 画爆炸螺旋
import turtle
t = turtle.Turtle()
t.shape("turtle")
t.speed(8)

t.color("red")
for i in range(1, 11):        # i 从 1 到 10
    step = i ** 2             # ★ 边长 = i 的平方
    t.forward(step)
    t.right(61)

# 加标注
t.penup()
t.goto(-300, 220)
t.pendown()
t.color("darkred")
t.write("爆炸螺旋: step = i**2 → 1, 4, 9, 16, 25...", font=("Arial", 10, "normal"))
turtle.done()
```

**对比普通螺旋（自增 +3）vs 爆炸螺旋（**）**：

```
普通螺旋（+=3）：step = 5, 8, 11, 14, 17...  每次加 3 → 温和增长
爆炸螺旋（**）：  step = 1, 4, 9, 16, 25...  指数增长 → 越来越猛！
```

**引导话术**：
> "之前学的自增 `+= 3`——每次加 3，增长很均匀。现在用 `**`——边长是 i 的平方：1²=1, 2²=4, 3²=9, 4²=16...——增长越来越快，最后几圈会'爆炸'一样变大！"

**变化挑战**（完成后尝试）：
- `step = i ** 3`——立方爆炸（1, 8, 27, 64... 更剧烈！）
- `step = 2 ** i`——指数爆炸（2, 4, 8, 16, 32, 64, 128... 最剧烈！）
- 改变角度：`right(89)` `right(121)`

### 实操③：用 % 画虚线——每 3 笔抬笔（50-55 分钟 · ⭐⭐⭐）

**题目**：用 `%` 取余判断——每 3 笔画完后抬笔（`penup()`），让乌龟画出一条"虚线"。

```python
# 实操③：用 % 画虚线——每 3 笔抬笔
import turtle
t = turtle.Turtle()
t.shape("turtle")
t.speed(6)

t.color("blue")
for i in range(1, 16):       # i 从 1 到 15
    t.forward(30)
    # ★ 关键：每 3 笔抬一次笔
    if i % 3 == 0:           # i 能被 3 整除？
        t.penup()            # 抬笔——不画线
    else:
        t.pendown()          # 落笔——画线

turtle.done()
```

**如果只想显示虚线部分**（更直观的版本）：

```python
# 更直观的画法：每 3 笔画一段，抬笔移动一段
t.pendown()                  # 先落笔
for i in range(1, 16):
    t.forward(30)
    if i % 3 == 0:           # 画了 3 笔
        t.penup()            # 抬笔
        t.forward(15)        # 空走一段（虚线间隔）
        t.pendown()          # 再落笔继续画
```

**板书画图推演**：

```
循环次数 i:  1    2    3    4    5    6    7    8    9   10 ...
画线状态:    ━━━ ━━━ ━━━    ━━━ ━━━ ━━━    ━━━ ━━━ ━━━    ...
              落  落  抬    落  落  抬    落  落  抬
                   笔  笔         笔         笔
```

> "`i % 3 == 0`——当 i 是 3、6、9、12... 时，条件成立——抬笔！走一段空的距离再落笔——形成了虚线中间的间隔。"

**更进阶——用 % 2 画斑马线（黑白交替）**：

```python
# 进阶：用 % 2 交替颜色（斑马线效果）
t.pensize(5)
for i in range(1, 11):
    if i % 2 == 0:
        t.color("red")       # 偶数 → 红色
    else:
        t.color("black")     # 奇数 → 黑色
    t.forward(40)
    t.right(36)
```

**引导话术**：
> "`%` 不光能取余数——它还是个"计数器开关"！每 3 次触发一次——`i % 3 == 0`——就是每隔两次做一次特殊操作。这是编程里**定时操作**的标准写法！"

---

## 阶段五：小测 + 收尾（55-60 分钟）

### 5.1 小测三问（55-57 分钟）

**投影问题**：

```
┌─────────────────────────────────────────┐
│         📝 小测（全班口答）               │
│                                          │
│  ①  10 // 3  =  ?                       │
│  ②  10 % 3   =  ?                       │
│  ③  2 ** 3   =  ?                       │
└─────────────────────────────────────────┘
```

**答案**：
- ① **3**（整除，10÷3=3 余 1，取整数部分 3）
- ② **1**（取余数，10÷3=3 余 1）
- ③ **8**（2 的 3 次方 = 2×2×2 = 8）

**追问**（能力排查）：
- "`/` 和 `//` 有什么区别？" → "`/` 得小数，`//` 得整数"
- "`//` 和 `%` 是什么关系？" → "`(a//b)*b + a%b = a`——互补！"
- "优先级口诀是什么？" → "括号 > 幂 > 乘除 > 加减"

**易错点确认**：
> "注意！`**` 是幂运算——`2**3=8`，不是 `2*3=6`。两个乘号是乘方，一个乘号是乘法！"

### 5.2 全班齐读——核心金句（57-59 分钟）

全体起立，老师领读一句，全班跟读一句（拍手打节奏）：

```
① // 整除去小数，% 取余数，** 指数爆炸！
② 括号 > 幂 > 乘除 > 加减——优先级不搞混！
③ 10 // 3 = 3，10 % 3 = 1，2 ** 3 = 8！
④ n % 2 == 0 → 偶数，n % 2 == 1 → 奇数！
⑤ (a // b) * b + (a % b) == a —— 整除和取余配成对！
```

**灵魂收尾三问**：

> **一问**："`10 / 3` 和 `10 // 3` 和 `10 % 3`——三兄弟分别等于多少？"
> → **"3.333..., 3, 1！"**

> **二问**："优先级最高的两个是什么？"
> → **"括号第一，幂 ** 第二！"**

> **三问**（快速点名 3 人，每人 3 秒内答对即过关）：
> - "`2 ** 3 = ?`" → "**8！**"
> - "`7 // 2 = ?`" → "**3！**"
> - "`7 % 2 = ?`" → "**1！**（奇数！）"

**过渡下一节**（59-60 分钟）：

> "今天你们学会了 Python 的全部算术运算符——`+` `-` `*` `/` `//` `%` `**`——7 种！还有优先级：括号 > 幂 > 乘除 > 加减。`
>
> `//` 整除和 `%` 取余是编程特有的——数学课上没有这两个符号。`**` 指数爆炸让数字飞速增长——用在 turtle 里能画出爆炸螺旋！`
>
> "下一节——我们学**赋值运算符**：`+=` `-=` `*=` `/=` `//=` `%=` `**=`——把今天学的七种算符和赋值结合，让代码更简洁！下课！"

**最后检查**：每人保存了代码 ✓ / 关掉了电脑 ✓

---

## 板书设计

```
┌──────────────────────────────────────────────────────────────┐
│        ➕ 第13节：算术运算符 + - * / // % **                   │
│              GESP #12                                         │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌─ 七种运算符 ─────────────────────────────────────────┐   │
│  │  +  加法    t.forward(50+50) → forward(100)           │   │
│  │  -  减法    t.right(360-180) → right(180) 掉头        │   │
│  │  *  乘法    边长 * 3 → 三倍放大                      │   │
│  │  /  除法    360 / 边数 → 转的角度                    │   │
│  │  // 整除    100 // 3 = 33（去小数）                   │   │
│  │  %  取余    100 % 3 = 1（还剩多少）                   │   │
│  │  ** 幂      2 ** 10 = 1024（指数爆炸！）              │   │
│  └────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌─ 优先级金字塔 ──────────────────────────────────────┐   │
│  │               ( )  ← 最高                            │   │
│  │               **                                     │   │
│  │            * / // %                                  │   │
│  │               + -  ← 最低                            │   │
│  │                                                       │   │
│  │  口诀：括号 > 幂 > 乘除 > 加减                       │   │
│  └────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌─ 关键对比 ──────────────────────────────────────────┐   │
│  │  10 / 3  = 3.3333333333333335                       │   │
│  │  10 // 3 = 3                                        │   │
│  │  10 % 3  = 1                                        │   │
│  │                                                       │   │
│  │  验证：(10//3)*3 + (10%3) = 3×3+1 = 10 ✅           │   │
│  └────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌─ 实操三部曲 ───────────────────────────────────────┐   │
│  │ ⭐   ① 计算 100//7 和 100%7                        │   │
│  │ ⭐⭐  ② 用 ** 画爆炸螺旋                            │   │
│  │ ⭐⭐⭐ ③ 用 % 画虚线（每3笔抬笔）                    │   │
│  └────────────────────────────────────────────────────┘   │
│                                                              │
│  📝 小测：10//3=? 10%3=? 2**3=?                            │
│  → 3, 1, 8                                                  │
│                                                              │
│  记忆钩子："//整除去小数%取余数**指数爆炸"                    │
│            "括号>幂>乘除>加减"                                │
└──────────────────────────────────────────────────────────────┘
```

---

## 易错点

| 易错点 | 错误表现 | 根因 | 课堂对策 |
|--------|---------|------|---------|
| `//` 写成 `/` | `10//3` 写成 `10/3`，得 3.333 不是 3 | 混淆整除和普通除法 | 口诀"// 整除去小数"+ 板书对比：`10/3=3.333` vs `10//3=3` |
| `**` 混淆为 `*` | `2**3` 当作 `2*3=6` | 没分清乘法和幂 | "一个乘号是乘法，两个乘号是幂（次方）——指数爆炸！" |
| `%` 理解为百分比 | `10%3` 以为"10的百分之三是0.3" | 数学课%是百分比 | "Python 里 % 不是百分比——是取余数！10颗糖分给3人剩1颗" |
| 优先级错误 | `2+3*4` 算成 20（从左到右）而不是 14 | 不知道先乘后加 | 优先级金字塔 + 齐读口诀"括号>幂>乘除>加减" |
| 整除向下取整方向（负数） | 课上不讲负数情况 | 避免超纲 | 课上只处理正数整除，GESP 一级也只考正数 |
| `//` 和 `%` 的关系 | 不知道 `(a//b)*b + a%b == a` | 没建立互补关系 | 实物分糖果验证："14×7+2=100 → 验证通过！" |
| `i % 3 == 0` 判断条件写反 | 抬笔和落笔写反了 | 逻辑取反混淆 | "i%3==0 时抬笔——其余时间落笔" 用板书画推演表 |
| `**` 在 turtle 中数值增长过快 | `i**2` 到第10圈是100，`2**i` 到第10圈是1024——跑出屏幕 | 没预估指数增长速度 | "** 增长很快——先用 i**2 试试，再用 2**i 感受指数爆炸" |

---

## GESP 衔接

本关完整覆盖 GESP 一级考点 **#12 算术运算符**，通过"七种运算符逐一精讲 → / // % 三种除法对比 → ** 指数爆炸 → 优先级金字塔 → 三种上机实操"逐层递进，孩子经历了从"认识运算符"到"用运算符控制 turtle 画图"再到"综合应用"的三级认知跃迁。

**本关结束后孩子应能回答**：

1. Python 有哪七种算术运算符？（答：`+` `-` `*` `/` `//` `%` `**`）
2. `/` `//` `%` 有什么区别？（答：`/` 得小数，`//` 得整数，`%` 得余数）
3. `2 ** 3` 等于多少？（答：8——2×2×2=8）
4. 运算优先级口诀是什么？（答：括号 > 幂 > 乘除 > 加减）
5. 如何判断一个数是奇数还是偶数？（答：`n % 2 == 0` 偶数，`n % 2 == 1` 奇数）
6. `(a // b) * b + (a % b)` 等于什么？（答：等于 a——整除和取余互补）

**下一节预告**：赋值运算符——`+=` `-=` `*=` `/=` `//=` `%=` `**=`，把今天学的七种算符和赋值结合，一步到位！

---

## 教员备忘

- **本关最关键 15 分钟**：10-25 分钟的七种运算符精讲。每种算符都要有"板书定义 + Python 代码 + turtle 场景 + 身体锚点"四个要素。节奏要快，每种算符 2-3 分钟，不要在一个算符上花太久。
- **最易混淆点**：`/` `//` `%` 三者的区别。实物分糖果演示（10 颗糖分给 3 人）最直观——每人 3 颗剩 1 颗，对应 `//=3` `%=1`。务必让每个孩子亲眼看到。
- **三层实操的时间分配**：实操①（5 分钟）- 实操②（5 分钟）- 实操③（5 分钟）。如果时间紧张，实操③可以简化——只要求用 `% 2 == 0` 判断奇偶画出斑马线效果，不要求画完整虚线。
- **能力分层**：完成全部三关的孩子进入"自由探索"——改步长、改指数、改角度、加颜色。未完成实操③的孩子可以课后继续或下一节课再补。
- **投影准备**：提前在投影上打开 `第13节_算术运算.py`，模式 1（/、//、% 对比）和模式 2（优先级演示）预先框选好。
- **** 指数运算的数值增长很快**：实操②如果孩子把 `i**2` 改成 `2**i`，要注意限制 i 的范围（`range(1, 8)` 最多到 128，`range(1, 11)` 到 1024 容易跑出屏幕）。提醒孩子"指数爆炸"不是开玩笑的。

---

## 文件清单

```
04_小乌龟的记忆变量/第13节_算术运算/
├── 第13节_算术运算.py              ← 核心上机文件（本关）
├── 教案_第13节_算术运算.md          ← 本文件
├── 课堂练习册_第13节_算术运算.md    ← 课堂练习
├── 课后练习卡_第13节_算术运算.md    ← 课后作业
└── （后续节次文件...）
```