~/陈老师

courses/python

Python 编程入门 · 5 年级及以上

过渡课程 Python 5 年级+

课程简介

Python 是语法最接近自然语言的代码语言，是孩子从图形化编程过渡到真实代码的完美桥梁。本课程不是"讲一遍概念就过"，而是每个知识点都配代码示例、运行结果与动手练习，让孩子真正看懂每一行代码在做什么。

课程按 环境搭建 → 变量类型 → 分支循环 → 字符串列表 → 函数模块 → 项目实战 六章递进，共 16 次课。每章都从孩子熟悉的 Scratch 概念切入，指出"这个积木就是这段代码"，再用真实程序巩固。学完就能独立写出计算器、猜数字、海龟画图等完整小项目。

适合对象

  • 5 年级及以上，零基础或学过图形化编程。
  • 会用键盘输入、能正确书写英文单词即可。
  • 未来想进入信息学竞赛体系，先打牢编程感觉。

课程大纲

syllabus.sh
第1章  环境搭建：安装 Python 与第一个程序
第2章  变量与数据类型：盒子、数字与文字
第3章  条件判断与循环：让程序学会思考
第4章  字符串与列表：批量处理数据
第5章  函数与模块：把程序拆成积木
第6章  海龟画图与小项目实战

课程内容

↑ 目录第 1 章 环境搭建：安装 Python 与第一个程序

本章目标：装好 Python 与编辑器，认识交互式与脚本式两种运行方式，会写并运行第一个程序。

1.1 安装 Python：这一步别漏勾选

去官网 python.org 下载安装包。安装界面出现时，务必勾选最下方的 "Add Python to PATH"，否则之后在命令行输入 python 会提示"找不到命令"。装完在命令行输入下面两条命令验证：

check.sh
python --version
python -V

能显示出版本号（例如 Python 3.12.x）就说明装好了。版本号只要是大版本 3 就没问题。

1.2 选择编辑器：Thonny 还是 VS Code

写代码需要一个"记事本加强版"。推荐两个：

  • Thonny：专门为初学者设计，界面简单，还带一个"看变量"面板，能直观看到每个变量当前的值——非常适合第一学期。
  • VS Code：装 Python 插件后更接近专业开发环境，语法高亮、自动补全更强，适合适应打字后再换。

两门都可以，重要的是学会保存文件：文件后缀一定是 .py，文件名用英文（比如 hello.py），存放路径别带中文，否则容易出现编码问题。

1.3 两种运行方式：交互式与脚本式

Python 有"一问一答"和"整本执行"两种模式，第一节课两种都要体验：

  • 交互式：在命令行敲 python 回车，进入 >>> 提示符，输一行立即执行一行。适合验证一个表达式。
  • 脚本式：把代码存成 .py 文件，整体运行。真正的程序都用这种方式。
交互式示例
>>> print("你好")
你好
>>> 3 + 5
8
>>>

1.4 第一个程序：print 输出

print() 是"把内容显示在屏幕上"的指令，和 Scratch 里的「说」积木一一对应。括号里放什么就打印什么，还可以一次打印多个，中间用逗号隔开：

hello.py
# 我的第一个程序
print("Hello, Python!")
print("我是陈老师的学生")
print("姓名：", "小明", "年级：", 5)
运行结果
Hello, Python!
我是陈老师的学生
姓名： 小明 年级： 5

1.5 字符串、引号与注释

被引号包起来的内容叫字符串（英文叫 string，简称 str），单引号双引号都可以，但必须是英文引号。中文字符可以直接写，只要用的是英文引号包住。字符串里想显示引号本身，可以用反斜杠转义：

string.py
print('单引号也可以')
print("他说：\"你好\"")
print("换行\n下一行")
print('''多行
文本用三个引号''')
运行结果
单引号也可以
他说："你好"
换行
下一行
多行
文本用三个引号

\n 表示换行，\" 表示引号本身，这类带反斜杠的写法叫转义字符。三个引号 '''...''' 可以包住多行文本。

注释是写给"看代码的人"看的说明，以 # 开头，程序运行时完全忽略它。给代码写注释是好习惯，帮助自己回头看懂逻辑。

最容易踩的三个坑：① 用了中文引号 "你好" 会报错；② 忘了配对引号；③ 注释行没写 #，导致整行报错。遇到报错先看行号，报错信息里指哪一行，就检查哪一行。

1.6 认识缩进

Python 用缩进表示代码的层级关系（这一点和 Scratch 用"嵌进去"表示层级完全一样）。同一层代码缩进必须一致，通常用 4 个空格。缩进错误时 Python 会直接报 IndentationError。

错误示例
print("第一行")
  print("缩进不一致，这里会报错")
第一课先不做复杂的东西，只让孩子完成三件事：能运行程序、能看懂报错、能记住"缩进要对齐"。这三件事比多写十行代码更重要。

基础练习：用三行 print 输出你的姓名、年级和爱好。

挑战练习：用 \n 和转义字符，在一行 print 里输出三行自我介绍。提示：把 \n 写进字符串中间即可。

↑ 目录第 2 章 变量与数据类型：盒子、数字与文字

本章目标：理解"变量是装数据的盒子"，掌握四种基本类型，会用 input() 读取输入并做运算。

2.1 变量：给数据起个名字

变量就是"给数据起个名字存起来"，可以想象成贴了标签的盒子：

box 示意图
┌─────────────┐
│   年龄       │ ← 标签（变量名）
├─────────────┤
│     10      │ ← 存的值
└─────────────┘

用等号 = 把值放进盒子（这叫赋值）。盒子里的值随时可以换。变量名用字母、数字、下划线组成，但不能以数字开头，也不能用 Python 的保留字（如 if、for）。

variable.py
age = 10            # 把 10 放进"age"盒子
name = "小明"        # 把字符串放进"name"盒子
age = age + 1       # 先取出 age 的值 +1，再放回去
print(name, "今年", age, "岁")
运行结果
小明 今年 11 岁

2.2 四种基本类型：int / float / str / bool

盒子里的数据有类型之分，Python 里最基本的四种：

types.py
# 整数 int：没有小数点
a = 100
# 小数 float：带小数点
b = 3.14
# 字符串 str：被引号包住
c = "Hello"
# 布尔 bool：只有 True / False
d = True

print(type(a))   # <class 'int'>
print(type(b))   # <class 'float'>
print(type(c))   # <class 'str'>
print(type(d))   # <class 'bool'>

type() 能查看变量的类型。为什么类型重要？因为不同类型能做的操作不同：数字能加减乘除，字符串能拼接，布尔能参与条件判断。

2.3 算术运算符：不只是加减乘除

除了常见的 + - * /，Python 还有三个竞赛里特别常用的运算符：

operators.py
print(7 + 2)    # 加     → 9
print(7 - 2)    # 减     → 5
print(7 * 2)    # 乘     → 14
print(7 / 2)    # 除     → 3.5
print(7 // 2)   # 整除取商 → 3
print(7 % 2)    # 取余数  → 1
print(2 ** 3)   # 乘方   → 8
运行结果
9
5
14
3.5
3
1
8
/ 的结果永远是小数，哪怕整除：7 / 2 得 3.5，而 7 // 2 得 3。想"除完还取整"，用 //。取余数 % 常用来判断奇偶（n % 2 == 0 是偶数）和拆分数字。

2.4 input()：让程序听用户的话

input() 会在屏幕上显示提示文字，等待用户输入，回车后把输入的内容作为字符串返回。注意：无论输入的是不是数字，input() 返回的都是字符串，想做数学运算必须先转换。

input.py
name = input("你的名字：")
age = input("你的年龄：")
print(name, type(age))     # age 是字符串

# 想当数字用，必须 int() 转换
age2 = int(input("再输一次年龄："))
print("10年后", age2 + 10, "岁")
运行结果
你的名字：小明
你的年龄：10
小明 <class 'str'>
再输一次年龄：10
10年后 20 岁

类型转换还有 float()（转小数）、str()（转字符串）、int()（转整数）。

2.5 字符串拼接与 f-string

字符串可以用 + 拼接，但不能直接和数字相加。想把数字拼进字符串，最方便的是 f-string：在字符串前加 f，用花括号 {} 装变量。

fstring.py
name = "小红"
score = 98

# 错误写法：字符串 + 数字
# print("分数：" + score)   # 会报错

# 正确写法 1：str() 转换
print("分数：" + str(score))

# 正确写法 2：f-string（推荐）
print(f"{name} 考了 {score} 分")
print(f"{name} 明年 {score + 1} 分")   # 花括号里还能写算式
运行结果
分数：98
小红 考了 98 分
小红 明年 99 分

基础练习：写一个"年龄计算器"：输入名字和年龄，输出"XX 10 年后 XX 岁"。

挑战练习：输入一个两位数，用 // 和 % 拆出十位和个位，再输出它们的和。提示：n // 10 是十位，n % 10 是个位。

↑ 目录第 3 章 条件判断与循环：让程序学会思考

本章目标：掌握 if/elif/else 分支与 for/while 循环，会用 break、continue 控制流程，完成猜数字、累加求和等经典练习。

3.1 比较运算符：程序判断的依据

判断的前提是比较。Python 的比较运算符如下，比较的结果是布尔值 True 或 False：

compare.py
print(10 > 5)    # True   大于
print(10 < 5)    # False  小于
print(10 >= 10)  # True   大于等于
print(10 == 10)  # True   相等（注意是两个等号！）
print(10 != 5)   # True   不相等
判断相等用两个等号 ==，赋值才用 =。写 if age = 10 是赋值，程序逻辑就错了。

3.2 if / elif / else：让程序做选择

if 满足条件执行一段，elif 是"否则如果"，else 是"都不满足时兜底"。程序从上往下，命中第一个满足的条件就执行，后面不再看：

ifelse.py
score = int(input("你的分数："))

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")
运行示例（输入 75）
你的分数：75
及格

注意"命中第一个就停"：输入 95 时，第一个条件 score >= 90 满足，直接输出"优秀"，后面的 elif 不再执行。这就是为什么条件要从高到低排列。

3.3 逻辑运算符 and / or / not

一个条件不够用时，用逻辑运算符合并：and（并且，两边都真才真）、or（或者，一边真就真）、not（取反）。

logic.py
age = 12
height = 145

# and：两个条件都满足
if age >= 10 and height >= 140:
    print("可以玩过山车")

# or：满足其中一个即可
if age < 8 or height < 120:
    print("需要大人陪同")

# not：条件不满足时
if not (age < 6):
    print("已满 6 岁")

3.4 for 循环：重复"知道次数"的事

for 循环对应 Scratch 的「重复 N 次」。核心是 range()：range(1, 101) 生成 1 到 100（含头不含尾，包左不包右）。

forloop.py
# 打印 0~4
for i in range(5):
    print(i, end=" ")   # end=" " 表示不换行，用空格分隔
print()

# 打印 1~10
for i in range(1, 11):
    print(i, end=" ")
print()

# 从 10 数到 1，步长 -1
for i in range(10, 0, -1):
    print(i, end=" ")
运行结果
0 1 2 3 4
1 2 3 4 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1

经典练习：累加求和。可以用一个变量当"累加器"，循环里每次把当前数加进去：

sum.py
total = 0                    # 累加器，从 0 开始
for i in range(1, 101):      # i 取 1,2,...,100
    total = total + i        # 累加
print("1+2+...+100 =", total)
运行结果
1+2+...+100 = 5050
range(1, 101) 包左不包右，所以要写到 101 才能包含 100。累加器变量一定要在循环前初始化，否则会报"变量未定义"。累加过程可以简写成 total += i，意思是 total = total + i。

3.5 while 循环：直到条件不成立

while 对应 Scratch 的「重复执行直到」。只要条件成立就一直循环，所以循环体里一定要改变条件涉及的变量，否则会死循环。

whileloop.py
n = 1
while n <= 5:          # 条件成立就一直循环
    print(n, end=" ")
    n = n + 1          # 关键：改变 n，否则死循环
print("结束")
运行结果
1 2 3 4 5 结束
最常见的 bug 是忘记更新循环变量，程序永远转圈，只能按 Ctrl+C 中断。做 while 之前，先在纸上写下：①条件是什么 ②循环体里哪个变量会变 ③它最终会不会让条件不成立。

3.6 break 与 continue：控制循环的节奏

break 立刻跳出整个循环；continue 跳过本次剩余代码，进入下一轮。

break_continue.py
# break：i 到 5 就停
for i in range(1, 11):
    if i == 5:
        break
    print(i, end=" ")
print()   # → 1 2 3 4

# continue：跳过 3，其余照常
for i in range(1, 6):
    if i == 3:
        continue
    print(i, end=" ")
print()   # → 1 2 4 5
运行结果
1 2 3 4
1 2 4 5

3.7 循环嵌套：循环套循环

循环里面再写循环，外层每走一步，内层完整跑一遍。打印九九乘法表是经典练习：

nested.py
for i in range(1, 10):        # 外层：行
    for j in range(1, i + 1): # 内层：列，随行增加
        print(f"{j}x{i}={i*j}", end="  ")
    print()                   # 换行
运行结果
1x1=1
1x2=2  2x2=4
1x3=3  2x3=6  3x3=9
1x4=4  2x4=8  3x4=12  4x4=16
1x5=5  2x5=10  3x5=15  4x5=20  5x5=25

理解嵌套的关键：内层循环整体是外层循环的一条语句，外层每循环一次，内层从头到尾执行一遍。

基础练习：用循环找出 1 到 100 之间所有能被 3 整除的数并打印。

挑战练习：用 while 和 break 做"猜数字"：程序想一个 1~100 的数，用户一直猜，猜对就退出。提示：random.randint(1, 100) 生成随机数，while True + break 实现"猜对退出"。

↑ 目录第 4 章 字符串与列表：批量处理数据

本章目标：掌握字符串的索引、切片与常用方法，学会列表的增删改查与遍历，初步接触"批量处理数据"。

4.1 字符串的索引与切片

字符串是一串字符，可以像排队的人一样给每个位置编号。编号从 0 开始：

index 示意图
字符：  H   e   l   l   o
编号：  0   1   2   3   4
负数： -5  -4  -3  -2  -1
slice.py
s = "Hello Python"

print(s[0])      # 第 1 个字符 → H
print(s[6])      # 第 7 个字符 → P
print(s[-1])     # 最后 1 个   → n
print(s[0:5])    # 切片 0~4   → Hello
print(s[6:])     # 从 6 到末尾 → Python
print(s[::-1])   # 反转        → nohtyP olleH
运行结果
H
P
n
Hello
Python
nohtyP olleH

切片 s[开始:结束] 和 range 一样含头不含尾。s[::-1] 中第三个参数 -1 表示步长为负（从右往左），实现反转。

下标越界会报 IndexError: string index out of range。访问前先用 len(s) 看长度，记住"最后一个合法下标 = 长度 - 1"。

4.2 字符串的常用方法

字符串自带很多"功能函数"（方法）。注意：字符串是不可变的，这些方法都返回新字符串，不改原字符串。

string_methods.py
s = "  Hello Python  "

print(s.strip())          # 去掉首尾空格 → "Hello Python"
print(s.upper())          # 全部大写
print(s.lower())          # 全部小写
print(s.split(" "))       # 按空格拆成列表
print(s.replace("Python", "世界"))
print(s.count("o"))       # 统计 o 出现次数
print(s.startswith("  ")) # 是否以...开头 → True
运行结果
Hello Python
  HELLO PYTHON
  hello python
['', '', 'Hello', 'Python', '', '']
  Hello 世界
3
True

4.3 列表：能装多个数据的盒子

列表（list）用方括号 [] 包住一串数据，中间逗号分隔。它像一个带编号的抽屉柜，每个抽屉一个数据，编号从 0 开始：

list 示意图
[ 88 | 92 | 75 | 96 ]
  0    1    2    3
list_ops.py
scores = [88, 92, 75, 96]

scores.append(100)          # 末尾加 → [88,92,75,96,100]
scores.insert(0, 60)        # 插到开头 → [60,88,...]
scores.remove(75)           # 删掉值 75
scores.pop()                # 删掉最后一个
scores[0] = 100             # 修改第 1 个
print(scores)               # → [100, 88, 92, 96]

print(len(scores))          # 长度 → 4
print(scores.index(92))     # 92 在第几个 → 2
运行结果
[100, 88, 92, 96]
4
2
列表和字符串最大的区别：列表可变，字符串不可变。scores[0] = 100 合法，但字符串 s[0] = "X" 会报错。

4.4 遍历列表与统计函数

用 for 遍历列表，逐个处理每个元素。Python 还提供一批统计函数：

list_loop.py
scores = [88, 92, 75, 96]

for s in scores:
    print("成绩", s)

print("最高分", max(scores))
print("最低分", min(scores))
print("平均分", sum(scores) / len(scores))

# 排序：sorted() 返回新列表
print(sorted(scores))
print(sorted(scores, reverse=True))
运行结果
成绩 88
成绩 92
成绩 75
成绩 96
最高分 96
最低分 75
平均分 87.75
[75, 88, 92, 96]
[96, 92, 88, 75]

4.5 列表推导式：一行生成列表

想快速生成一个列表，可以用列表推导式，它把"循环 + 收集"压缩成一行（进阶内容，学有余力的孩子看）：

comprehension.py
# 1~10 的平方
squares = [i * i for i in range(1, 11)]
print(squares)

# 只保留偶数
evens = [i for i in range(1, 21) if i % 2 == 0]
print(evens)

# 对列表每个元素处理
nums = [1, 2, 3]
doubled = [x * 2 for x in nums]
print(doubled)
运行结果
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
[2, 4, 6]

基础练习：输入 5 个同学的身高存入列表，输出最高、最矮和平均身高。

挑战练习：输入一句话，统计每个字符出现的次数。提示：用 for 遍历字符串，用字典 {} 记录"字符 → 次数"，遇到新字符初始化成 1，遇到已有的加 1。

↑ 目录第 5 章 函数与模块：把程序拆成积木

本章目标：学会用 def 定义函数、传参、返回值，理解"函数就是自己的积木"，并会用 import 引入模块。

5.1 为什么需要函数

程序写到一定规模，会发现"同一段逻辑要反复用"。比如算面积、掷骰子、判断闰年。如果每次都要重抄一遍，代码又长又容易出错。函数把一段代码打包起来起个名字，想用就调用一次——这正是 Scratch 里「自制积木」的对应物。

5.2 定义与调用：def / return

用 def 定义函数，函数体必须缩进。return 把结果"交还"给调用方：

def.py
def greet():
    print("你好！")
    print("欢迎学习 Python")

def add(a, b):          # a、b 是参数
    return a + b        # 返回值

greet()                 # 调用无参函数
print(add(3, 5))        # 调用并打印返回值
result = add(10, 20)    # 把返回值存进变量
print(result)
运行结果
你好！
欢迎学习 Python
8
30

5.3 参数：函数的输入

参数让同一个函数能处理不同数据。还可以给参数设置默认值，调用时不传就用默认值：

params.py
def roll(dice=6):            # 默认 6 面骰子
    import random
    return random.randint(1, dice)

print(roll())          # 6 面 → 1~6
print(roll(20))        # 20 面 → 1~20

def repeat_word(word, times=3):
    return word * times

print(repeat_word("哈"))       # 哈哈
print(repeat_word("啊", 5))    # 啊啊啊啊啊
运行结果
3
17
哈哈
啊啊啊啊啊

"哈" * 3 会把字符串重复 3 遍，这是字符串运算里的小技巧。

5.4 返回值与 None

没有 return 的函数返回 None（表示"什么都没有"）。print 和 return 是两回事：print 只是显示，return 才把值交还给调用方。

return_none.py
def show(x):
    print("我打印了", x)      # 只是显示

def calc(x):
    return x * 2             # 真正返回

a = show(5)
b = calc(5)
print("show 返回:", a)   # None
print("calc 返回:", b)   # 10
运行结果
我打印了 5
show 返回: None
calc 返回: 10

5.5 import：用别人写好的模块

模块就是"别人打包好的函数库"，用 import 引入。最常用的有 random（随机）、math（数学）、time（时间）。

module.py
import random
import math

print(random.randint(1, 100))   # 1~100 随机整数
print(random.random())          # 0~1 之间的小数
print(random.choice(["石头", "剪刀", "布"]))  # 随机取一个

print(math.sqrt(81))    # 平方根 → 9.0
print(math.pi)          # 圆周率
print(math.floor(3.7))  # 向下取整 → 3
print(math.ceil(3.2))   # 向上取整 → 4
运行示例
57
0.482937
剪刀
9.0
3.141592653589793
3
4
import 要写在文件顶部，并且函数里用到的模块最好也放在文件开头统一导入。函数命名避免用内置词（如别叫 list、sum），否则会"盖掉"内置功能导致莫名报错。

5.6 实战：闰年判断函数

闰年规则：被 4 整除但不能被 100 整除，或者被 400 整除。把它写成一个函数，逻辑很清晰：

leap.py
def is_leap(year):
    if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
        return True
    else:
        return False

for y in [2000, 1900, 2024, 2025]:
    print(y, "闰年?" , is_leap(y))
运行结果
2000 闰年? True
1900 闰年? False
2024 闰年? True
2025 闰年? False

基础练习：写一个求平均数的函数 average(lst)，传入成绩列表返回平均值。

挑战练习：写一个"抽奖"程序：全班名单放进列表，用函数随机抽出一名同学。提示：random.choice(名单) 可以直接随机取一个。

↑ 目录第 6 章 海龟画图与小项目实战

本章目标：用 turtle 库画图巩固语法，综合所学完成两个小项目，走通"设计 → 编码 → 测试"全流程。

本章是实战结课章，以综合项目（计算器、猜数字、海龟组合画等）代替常规练习——把前五章语法放进真实项目里综合运用，做完一个就收获一个能展示的作品。

6.1 turtle 基础：让海龟在屏幕上画画

turtle 是 Python 自带的画图库：屏幕上一只"小海龟"，你指挥它前进、转向、抬笔落笔，它爬过的轨迹就是画。这比纯文字输出更有成就感，也是把循环和角度用看得见的方式练一遍。

turtle_basic.py
import turtle

t = turtle.Turtle()
t.speed(5)          # 速度 1~10
t.color("blue")     # 画笔颜色
t.forward(100)      # 前进 100 像素
t.right(90)         # 右转 90 度
t.forward(100)
t.penup()           # 抬笔（移动不留痕迹）
t.goto(-150, 0)     # 直接飞到指定坐标
t.pendown()         # 落笔
t.color("red")
t.circle(50)        # 画圆，半径 50

turtle.done()       # 保持窗口不关闭

6.2 用循环画多边形

画一个正方形要 4 条边、每次转 90 度。想画任意多边形？正 n 边形每次转 360/n 度，用 for 循环一步到位：

polygon.py
import turtle

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

n = 6               # 六边形
length = 80
angle = 360 / n     # 每次转的角度

for i in range(n):
    t.forward(length)
    t.right(angle)

# 画五角星：转 144 度
t.penup()
t.goto(-150, 0)
t.pendown()
for i in range(5):
    t.forward(120)
    t.right(144)

turtle.done()
五角星转的角度是 144 度，不是 360/5=72。72 度画的是五边形，144 度才让海龟画完五角星后回到起点。画之前先在纸上画草图，数清楚每次转多少度。

6.3 颜色与填充

用 begin_fill() 和 end_fill() 可以给图形填色，组合图形就能画出彩色的图案：

fill.py
import turtle

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

colors = ["red", "orange", "yellow", "green", "blue", "purple"]
t.penup()
t.goto(-150, 0)
t.pendown()

# 彩色圆环
for c in colors:
    t.color(c)
    t.begin_fill()
    t.circle(30)
    t.end_fill()
    t.penup()
    t.forward(55)
    t.pendown()

turtle.done()

6.4 综合项目一：猜数字游戏

把随机数、while、分支、break、计数器全用上。先写设计步骤再写代码：

guess.py
import random

target = random.randint(1, 100)   # 电脑想的数
count = 0                         # 猜的次数
print("我想好了一个 1~100 的数，来猜吧！")

while True:
    guess = int(input("你猜："))
    count = count + 1
    if guess > target:
        print("大了，再小一点")
    elif guess < target:
        print("小了，再大一点")
    else:
        print(f"恭喜！你用了 {count} 次猜对")
        break
运行示例
我想好了一个 1~100 的数，来猜吧！
你猜：50
小了，再大一点
你猜：75
大了，再小一点
你猜：63
恭喜！你用了 3 次猜对

这个项目能玩的点：① 统计次数看谁猜得快；② 加一个"超过 10 次没猜对就失败"的判定；③ 提示"再猜大一点"而不是"小了"，锻炼逻辑表达。

6.5 综合项目二：简易计算器

把输入、类型转换、分支、循环、错误处理全串起来。要求：能连续算多次，输入 0 退出，除数为 0 要有提示：

calculator.py
print("简易计算器，输入 0 退出")

while True:
    line = input("算式（如 3 + 5）：")
    if line == "0":
        print("再见！")
        break

    parts = line.split()         # "3 + 5" → ["3", "+", "5"]
    if len(parts) != 3:
        print("格式不对，用空格分隔，如：3 + 5")
        continue

    a = float(parts[0])
    op = parts[1]
    b = float(parts[2])

    if op == "+":
        print("结果：", a + b)
    elif op == "-":
        print("结果：", a - b)
    elif op == "*":
        print("结果：", a * b)
    elif op == "/":
        if b == 0:
            print("除数不能为 0！")
        else:
            print("结果：", a / b)
    else:
        print("不认识的运算符")
运行示例
简易计算器，输入 0 退出
算式（如 3 + 5）：3 + 5
结果： 8.0
算式（如 3 + 5）：10 / 0
除数不能为 0！
算式（如 3 + 5）：0
再见！

这个项目教给孩子"防御式编程"：不要假设用户一定按规矩输入，要对"格式不对""除数为 0"这些情况做处理。这是区分"会写代码"和"会写好代码"的分水岭。

6.6 综合项目三：海龟组合画

把本章学到的循环、颜色、填充综合起来，画一个组合图形（例如太阳和它的光芒）：

sun.py
import turtle

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

# 太阳本体
t.color("orange", "yellow")
t.begin_fill()
t.circle(60)
t.end_fill()

# 12 条光芒，绕一圈
for i in range(12):
    t.penup()
    t.goto(0, 0)
    t.setheading(i * 30)     # 每次转 30 度
    t.forward(75)
    t.pendown()
    t.forward(25)

turtle.done()
小项目评价标准：功能完整、输入有提示、错误有处理。结课展示时，让孩子讲清楚"这个程序有几个部分、每部分负责什么、遇到 bug 是怎么改的"——讲得清楚，说明真懂了。

学制安排

schedule.sh
班型      小班教学（8~12 人）
周期      16 次课 / 学期
频次      每周 1 次
时长      每次 90 分钟
结课      完成 2 个完整小项目

16 次课与 6 章的对应安排如下，每节课都能运行一个程序：

16-week-calendar.txt
第1周    第1章 装环境（PATH/编辑器/交互式 vs 脚本式）
第2周    第1章 第一个程序（print/字符串/注释/缩进）
第3周    第2章 变量与类型（盒子模型/type/int/float/str/bool）
第4周    第2章 运算与输入（运算符/input/类型转换/f-string）
第5周    第3章 分支（比较运算符/if/elif/else/逻辑运算）
第6周    第3章 for 循环（range/累加求和/打印序列）
第7周    第3章 while 循环（更新变量/break/continue）
第8周    第3章 循环嵌套（九九乘法表/找规律）
第9周    第4章 字符串（索引/切片/常用方法）
第10周   第4章 列表（增删改查/遍历/统计函数）
第11周   第4章 进阶（列表推导式/字典初体验）
第12周   第5章 函数（def/参数/返回值/None）
第13周   第5章 模块（random/math/import 实战）
第14周   第6章 海龟画图（基础命令/多边形/填充）
第15周   第6章 综合项目（猜数字 + 简易计算器打磨）
第16周   期末展示会（作品讲解 + 现场运行演示）

Python 与 Scratch 对照表

学过 Scratch 的孩子，可以对照下面这张表快速理解：积木是图形化的代码，代码是文字化的积木。每学一个新语法，都先问一句"这对应 Scratch 的哪个积木"。

scratch-vs-python.md
Scratch 积木                        Python 代码
──────────────────────────────────────────────────────
当绿旗被点击                          程序从上往下执行
说 [你好] (2) 秒                     print("你好")
将 [年龄] 设为 (10)                  age = 10
将 [年龄] 增加 (1)                   age += 1
重复 (10) 次                         for i in range(10):
重复执行直到 <猜中>                  while True: … break
如果 <得分 > 60> 那么… 否则…        if 得分 > 60: … else: …
随机数 1 到 100                      random.randint(1, 100)
建立一个变量 [得分]                   score = 0
我的积木（自制积木）                   def 函数名():
将 [s] 加入 [名单 v]                 list.append(s)
等待 (1) 秒                          time.sleep(1)
教孩子迁移的关键句："你已经在 Scratch 里学过这些东西了，现在只是换一种写法。" 概念没变，变的只是表达方式——孩子会因此少走很多弯路。
试读体验：欢迎先看看 代码编程入门导读，了解孩子从图形化到代码的过渡方法。

常见问题

  • 没学过 Scratch 能直接学吗？ 可以。只要会基本键盘操作就能跟上，前两章会把基础概念完整讲一遍。
  • Python 和 C++ 哪个更适合竞赛？ 竞赛主语言是 C++。走这条路一般有两种选择：① 从 Python 过渡（适合低年级、零基础，先把"手敲代码、调试、逻辑"练扎实，再转 C++）；② 直接学 C++（适合已有 Scratch 基础、年级较高、确定走竞赛的孩子）。两者都能到终点，差别只是节奏。拿不准就联系我做次免费测评。
  • 学完本课程转 C++ 会快吗？ 会快很多。Python 阶段建立起来的变量、循环、分支、函数、调试习惯在 C++ 里全部复用，转语言通常只需要适应语法，2~4 周即可上手。
  • 孩子需要每天练习吗？ 建议每周固定 2~3 次、每次 30 分钟。课后练习发送到邮箱 lackychen@foxmail.com，老师逐题批改并给出改进建议。
  • 代码报错看不懂怎么办？ 上课会教"读报错三步法"：先看报错行号、再读最后一行错误类型、回到代码对应行检查。这是独立调试的基本功。
  • 学完本课程能做什么？ 能独立编写计算器、猜数字、海龟画图等完整程序，并具备了转入竞赛基础课程的资格。
./apply --python 查看 C++ 课程 →

$ cat ~/learning-path.txt

图形化启蒙→Python→C++→CSP-J/S→NOIP·一对一规划（任意阶段可叠加）