资源简介

(共31张PPT)
UNIT 1 · LESSON 04 · 算法的实现
浙教版 小学信息科技 · 六年级上册 · 第一单元 算法的实现
用程序设计语言描述算法
流程图说清怎么做，程序让计算机真的去做
主讲教师：×××
学校：×××小学
上一课画好的流程图，计算机还看不懂。
本课导航
CONTENTS
本课导航
流程图说清怎么做，
程序让计算机去做。
01
承接：流程图写好了
02
计算机语言：人和机器的话
03
认识四类基础语句
04
算一算：流程图变成程序
05
写一写：三角形周长
06
练一练，理一理
小浙提示
先看这一课要走的六站，心里有个数。
02
03
本课学习目标
第一单元 算法的实现 · 第 4 课
01
知道把算法写成程序，计算机才能按算法一步一步执行。
02
知道 Python 是高级语言，IDLE 的两个窗口各有什么用。
03
能读懂赋值、分支、循环、输出这几类基础语句。
04
能把流程图里的每一步写成对应的程序语句。
两条要记牢：= 是把值存进变量，== 才是判断相等。
小浙提示
读一遍目标，重点看“把流程图写成程序语句”。
03
04
流程图写好了，计算机还看不懂
第一部分 · 从上一课接到本课
上一课用流程图把算法写清楚了；可是计算机不认识流程图。
tu ← 0
tu < 36
ji ← 35 tu
脚数 = 94
输出 ji、tu
tu ← tu + 1
1
上一课
流程图六步，一步不差，别人照着就能做。
2
可是
计算机看不懂流程图，它只认计算机语言写成的指令。
3
本课
把流程图一行一行翻译成程序，让计算机真的算一遍。
小浙提示
上一课画给人看，这一课写给计算机做。
04
05
计算机语言：人和机器的话
知识建构 · 计算机语言
计算机语言，是人和计算机交流用的语言；用计算机语言写成的指令，就是程序。
机器语言
一串 0 和 1
计算机直接就能执行，人却很难读、很难写。
高级语言
接近人的写法
Python、C 都是高级语言，写起来清楚好读。
1
同一件事
让计算机在屏幕上显示一句问候语。
2
两种写法
C：printf("你好！");　　Python：print("你好！")
同一个算法，可以用不同的计算机语言写出来。
小浙提示
同一个算法，可以用不同的计算机语言写出来。
05
06
程序的运行环境：IDLE
知识建构 · 认识 IDLE
写好程序，还要有能写、能运行的地方。Python 自带一个集成开发环境：IDLE。
窗口 01
IDLE Shell
打开就能用。可以直接输入一句代码，回车就出结果；程序运行的结果也显示在这里。
窗口 02
程序编辑器
用来写完整的一段程序，可以保存成文件，再一次性运行。
两个窗口分工不同：一个负责“试一句、看结果”，一个负责“写一段、存下来”。
先试着运行一句话，再动手写完整的程序。
小浙提示
Shell 试一句，程序编辑器写一段。
06
07
认识语句（一）：赋值语句
知识建构 · 赋值
先要把数据存进变量——这在程序里叫赋值语句。
赋值语句
tu = 0
1
读作
把 0 存进变量 tu。
2
对应流程图
流程图里的 tu ← 0，在程序里写成 tu = 0。
3
再看一句
tu = tu + 1：先算出右边的 tu + 1，再把它存回 tu。
= 不是“等于”，是“把右边的值存到左边”。
小浙提示
= 不是“等于”，是把右边的值存到左边。
07
08
认识语句（二）：循环语句与分支语句
知识建构 · 循环与分支
让一段程序反复做，或者让它自己选一条路走——靠循环和分支。
循环语句 · 对应流程图第 02 步
while tu < 36:
分支语句 · 对应流程图第 04 步
if ji * 2 + tu * 4 == 94:
1
循环
while 后面写判断条件，条件成立就一遍一遍做循环体。
2
分支
if 后面写判断条件，条件成立才做它下面那几行。
冒号下面缩进的那几行，就是它们各自要管的事。
小浙提示
冒号下面缩进的行，才是它们管的事。
08
09
认识语句（三）：输出语句
知识建构 · 输出
算出来的结果要让计算机“说出来”——用 print() 输出。
输出语句 · 对应流程图第 05 步
print(ji, "只鸡，", tu, "只兔。")
1
多个对象
用英文逗号隔开，print 会把它们依次显示出来。
2
文字要加引号
文字放在英文引号里，输出时照原样显示。
3
变量不加引号
这样输出的才是变量里存着的值。
加引号的照原样显示，不加引号的显示变量里的值。
小浙提示
加引号的照原样显示，不加引号显示变量的值。
09
10
小知识：符号和缩进
难点提示 · 最容易出错的地方
程序出错，十有八九不是算法想错了，而是符号写错了。
01
冒号
while、if 那一行的末尾，要有英文冒号 :。
02
等于
= 是把值存进变量，== 才是判断两边相等。
03
缩进
循环体、分支体要往右缩进，计算机靠它认层次。
04
标点
逗号、引号、括号，一律用英文半角。
记一句话：程序里的符号，全部用英文半角输入法敲出来。
小浙提示
程序里的符号，一律用英文半角敲出来。
10
11
流程图一步一步变成程序
核心页 · 对照着写
流程图的每一步
写成 Python 程序
01　tu ← 0
tu = 0
02　tu < 36
while tu < 36:
03　ji ← 35 tu
　　ji = 35 - tu
04　脚数 = 94
　　if ji * 2 + tu * 4 == 94:
05　输出 ji、tu
　　　　print(ji, "只鸡，", tu, "只兔。")
06　tu ← tu + 1
　　tu = tu + 1
对着看，一行一行写。缩进的地方要看清：循环体缩一次，分支体再缩一次。
小浙提示
一行对一行读，注意每行缩进了几次。
11
12
走一遍程序：屏幕上会出现什么
核心页 · 运行结果
把六行程序敲进去，回车运行一下。
屏幕上出现：23 只鸡， 12 只兔。
鸡兔同笼 · 枚举算法的程序
tu = 0
while tu < 36:
ji = 35 - tu
if ji * 2 + tu * 4 == 94:
print(ji, "只鸡，", tu, "只兔。")
tu = tu + 1
小浙提示
我们试了 13 次，程序一口气就做完了。
12
13
活动一：把流程图翻译成程序
学生活动 · 任务单活动一
不看书，对着左边这一步，把右边的程序语句写出来。
流程图的每一步
我写的程序语句
01　tu ← 0
02　tu < 36
03　ji ← 35 tu
04　脚数 = 94
05　输出 ji、tu
06　tu ← tu + 1
小浙提示
写完同桌互查，再对照上一页核对。
13
14
活动二：改一改数字
学生活动 · 任务单活动二
换成 30 个头、88 只脚，程序里哪几处要跟着改？
要改的地方
怎么改
为什么
循环条件
tu < 36 改成 tu < 31
共有 30 个头，最多试到 30
鸡的只数
ji = 35 - tu 改成 ji = 30 - tu
另一个量也要跟着改
判断条件
== 94 改成 == 88
脚数的条件跟着改
改完运行一遍：屏幕上是 16 只鸡、14 只兔，就说明改对了。
改一个数字，要顺着一路改到底，别漏了条件。
小浙提示
改一个数字，要顺着一路改到底。
14
15
换一题：三角形周长
试一试 · 换一道题
教材的练习：算一算边长为 3、4、5 厘米的三角形，周长是多少。
对象
三条边
用变量 a、b、c 表示三条边的长度。
数量
3、4、5
题目给定的三个长度，单位是厘米。
关系
周长 = 三边之和
把三条边加起来，就是周长。
1
先存
把三条边分别存进 a、b、c。
2
再算再显示
算出 a + b + c，把结果和单位一起显示出来。
小浙提示
先想清楚对象、数量、关系，再动手写。
15
16
写一写：三角形周长的程序
试一试 · 写成程序
把刚才的思路，一句一句写成程序。
三角形周长 · 四行程序
a = 3
b = 4
c = 5
print("周长是", a + b + c, "厘米")
屏幕上出现：周长是 12 厘米
结果里的 12 是计算机算出来的，不是我们写死的。
小浙提示
结果是计算机算出来的，不是写死的。
16
17
活动三：找错改错
学生活动 · 任务单活动三
下面这段程序有四处错，先自己找，再把改法写在右边。
小明写的程序
While tu < 36
ji = 35 - tu
if ji * 2 + tu * 4 = 94:
print(ji, "只鸡，", tu, "只兔。")
tu = tu + 1
处
错在哪儿，应该怎么改
1
2
3
4
找不到也不急：一句一句念出来，念不通的地方就有问题。
小浙提示
一句一句念，念不通的地方就有问题。
17
18
想一想：程序没跑对，怎么办
议一议思维 · 为下一课做铺垫
程序写完，不等于就一定跑得对。
根本不动
屏幕上出现红色的报错信息——多半是符号写错了。
结果不对
程序能运行，数却不对——回流程图查一查。
换个数据
换一组数据再试一次，看结果还对得上题意吗。
发现问题、找到原因、改好程序——这个过程叫调试，下一课专门来练。
报错不可怕，它是计算机在告诉我们哪里没写对。
小浙提示
报错不可怕，它是计算机在说哪里没写对。
18
19
辨一辨
练一练
说法
对 / 错
我的理由
把算法写成程序，计算机才能按算法一步一步执行。
Python 是一种机器语言。
IDLE 的两个窗口都能写完整的程序并保存下来。
程序里的 = 就是判断两边相等。
循环体、分支体要缩进，计算机靠缩进分辨代码的层次。
同一个算法，可以用不同的计算机语言写成程序。
说清理由，比只写一个“对”或“错”更重要。
小浙提示
重点看第 2、3、4 句，理由要写出来。
19
20
议一议：有了流程图，为什么还要写程序
议一议
流程图已经把做法说清楚了，不写程序行不行？
流程图给人看
一步一步读得懂，别人照着也能做。
程序给机器做
计算机看不懂流程图，只认计算机语言写成的指令。
两个都要
先想清楚，再写下来，写完还要跑一跑。
程序是算法的另一种说法——是算法交给计算机去做的那一份。
小浙提示
程序是算法交给计算机去做的那一份。
20
21
练习与小结：再走一遍
第三部分 · 练一练，理一理
01
练习
14 题分三层：基础 1—5、提升 6—10、综合 11—14。
02
讲评
重点讲第 4、5、7、8、13 题，说清为什么。
03
小结
理一理：认语言 → 认语句 → 对着流程图写程序。
做完就讲，讲完就理——这一课才算收口。
小浙提示
拿不准的题，回到“认语言—认语句—写程序”上想。
21
22
随堂练习（一）
基础题　1—5
题号
题目和选项
我的答案
1
把算法转化成计算机能执行的指令，得到的成果叫什么？A 流程图　B 程序　C 表格
2
Python 属于哪一类计算机语言？A 机器语言　B 高级语言　C 自然语言
3
Python 自带的集成开发环境是？A IDLE　B 浏览器　C 画图
4
IDLE 里既显示运行结果、又能直接输入一句代码运行的窗口是？A 程序编辑器　B IDLE Shell　C 资源管理器
5
要写一段完整的、可以保存下来的程序，应该在哪个窗口里写？A IDLE Shell　B 程序编辑器　C 记事本
小浙提示
第 4、5 题分不清两个窗口时，想一想谁负责保存。
22
23
随堂练习（二）
提升题　6—10
题号
题目和选项
我的答案
6
下面哪一句是赋值语句？A tu = 0　B tu == 0　C while tu < 36:
7
流程图里的 ji ← 35 tu 写成 Python 应该是？A ji == 35 - tu　B ji = 35 - tu　C 35 - tu = ji
8
判断“脚数等于 94”，程序里应该写成？A ji*2+tu*4 = 94　B ji*2+tu*4 == 94　C ji*2+tu*4 94
9
循环体、分支体要缩进，是因为？A 看起来整齐　B 计算机靠它分辨这些行属于上面那句话　C 可以少写几个字
10
把程序里的 35 改成 30、94 改成 88，运行后输出的结果是？A 16 只鸡、14 只兔　B 14 只鸡、16 只兔　C 23 只鸡、12 只兔
小浙提示
第 7、8 题别急着选，先把 = 和 == 分清楚。
23
24
随堂练习（三）
综合题　11—14
题号
题目和选项
我的答案
11
判断：把算法写成程序，计算机才能按算法一步一步执行。A 对　B 错
12
判断：Python 是一种机器语言。A 对　B 错
13
判断：程序里的标点可以用中文的，只要意思对就行。A 对　B 错
14
判断：同一个算法可以用不同的计算机语言写成程序。A 对　B 错
小浙提示
判断题也要写清理由。
24
25
参考答案
对一对
题号
1
2
3
4
5
6
7
答案
B
B
A
B
B
A
B
题号
8
9
10
11
12
13
14
答案
B
B
A
A
B
B
A
讲评要点
第 4、5 题：Shell 负责“试一句、看结果”，程序编辑器负责“写一段、存下来”。
第 7、8、13 题：= 是存值、== 才是判断相等；标点一律用英文半角。
活动三的四处错：While 大小写、缺英文冒号、用了 = 判断、tu = tu + 1 缩进太多。
小浙提示
重点讲评第 4、5、7、8、13 题。
25
26
课堂小结
本课回顾
1
承接
上一课用流程图把枚举算法写清楚了。
2
计算机语言
人和计算机交流用的语言；Python 是一种高级语言。
3
运行环境
IDLE：Shell 试一句、看结果，程序编辑器写一段、存下来。
4
基础语句
赋值、分支、循环、输出，四样凑齐就能写程序。
5
关键差别
= 存值，== 判断；while、if 行末要冒号，下属的行要缩进。
流程图说清怎么做，程序让计算机真的去做。
小浙提示
一句话：流程图说清怎么做，程序让计算机真的去做。
26
27
关键概念
记一记
1
计算机语言
人和计算机交流用的语言，如 Python、C。
2
程序
用计算机语言写成的、计算机能按顺序执行的指令。
3
IDLE
Python 自带的集成开发环境，含 Shell 和程序编辑器。
4
赋值与比较
= 把值存进变量；== 判断两边是否相等。
写程序之前先想清楚：存什么、算什么、显示什么。
小浙提示
把这四个词抄进笔记本。
27
28
学习评价
评一评
评价内容
自评
互评
师评
能说出把算法写成程序的作用，知道 Python 是高级语言
☆☆☆
☆☆☆
☆☆☆
能说出 IDLE 两个窗口各有什么用
☆☆☆
☆☆☆
☆☆☆
能读懂赋值、分支、循环、输出这几类基础语句
☆☆☆
☆☆☆
☆☆☆
能把流程图里的每一步写成对应的程序语句
☆☆☆
☆☆☆
☆☆☆
☆☆☆ 能独立完成并说清理由；☆☆ 需要一点提示；☆ 需要同伴帮助。
没到三星的那一项，就是课后的复习重点。
小浙提示
没到三星的，就是复习重点。
28
29
课后作业
分层完成
01
基础（必做）
把“鸡兔同笼”的流程图写成程序，在 IDLE 里运行一遍。
02
提高（选做）
把程序里的 35、94 改成 30、88，运行并核对结果。
03
拓展（选做）
给三角形周长程序再加一条边 d，算出四边形的周长。
04
阅读
读《从“照着做”到“让机器做”》。
作业里的数据要写明“示例”，不出现真实同学的姓名。
小浙提示
数据要标“示例”，不写真实姓名。
29
30
拓展阅读
读一读
从“照着做”到“让机器做”
最早的计算机只认机器语言——一串串 0 和 1，写起来又长又难。
后来人们发明了高级语言，用接近人的写法描述算法，Python 就是其中一种。
同一套算法，用 Python 能写，用 C 也能写，计算机都照着做。
程序写出来还要运行、检查，发现不对就改——好程序是改出来的。
今天我们让计算机把鸡兔同笼算了一遍，下一课看它跑起来之后会发生什么。
读后想一想：还有哪件事，你想请计算机替你做？
小浙提示
读后想一想：哪件事你想请计算机替你做？
30
本课结束　谢谢观看
课后想一想：还有哪件事，你想请计算机替你做？
浙教版 小学信息科技 · 六年级上册《用程序设计语言描述算法》教学设计
第一单元 算法的实现 · 第 4 课 · 1 课时(40 分钟) · 配套课件 31 页
课题 用程序设计语言描述算法 教材版本 浙教版六年级上册
单元 第一单元 算法的实现 课时 1 课时(40 分钟)
执教教师 学校
课型 新授课 授课时间
一、教材分析
《用程序设计语言描述算法》是浙教版小学信息科技六年级上册第一单元“算法的实现”的第四课，上接第 3 课《算法设计》。上一课已经用流程图把鸡兔同笼的枚举算法写成了六步：tu ← 0；tu < 36 ；ji ← 35 tu；脚数 = 94 ；输出 ji、tu；tu ← tu + 1。六步一步不差，别人照着就能做，可是计算机看不懂流程图——它只认用计算机语言写成的指令。本课要做的，就是把这张流程图一行一行翻译成 Python 程序，让计算机真的把这道题算一遍。
教材给出的核心内容是四件事：一是用计算机解决问题，要把算法转化为计算机能执行的指令，也就是程序；二是计算机语言从机器语言发展到高级语言，Python、C 都是高级语言，同一个算法可以用不同的语言实现；三是程序的运行环境——Python 自带的集成开发环境 IDLE 里有两个窗口，IDLE Shell 用来显示运行结果、可以直接输入代码运行，程序编辑器用来写完整的程序并保存；四是认识基础语句，以鸡兔同笼为例认赋值语句、条件循环语句、单分支条件语句和输出语句，并记住小知识里的符号规则（= 是赋值，== 是判断相等；输出用 print()，多个对象用英文逗号分隔，文字放引号里；标点一律英文半角；循环体、分支体要缩进）。教材的“试一试”让学生在 IDLE Shell 里写一段代码，计算并输出边长为 3、4、5 厘米的三角形周长。
二、学情分析
六年级学生已经能看懂流程图，也会用自然语言说清“先做什么、再做什么”，但把“一步一步的做法”换成计算机能执行的指令，是第一次。学生的困难主要有三处：一是分不清 = 和 ==，把判断写成了赋值；二是不理解缩进的作用，把循环体、分支体写成齐头并进，或者缩进过多、跑出了循环体；三是程序一报错就慌，以为是自己“学不会”，不知道报错信息其实是在告诉他哪里没写对。
因此本课的设计要点是“一条线走到底，一张流程图配六行程序”。全课只有两道题：鸡兔同笼照着流程图写，三角形周长自己写一遍；上一课那张流程图的每一步，都能在本课的程序里找到对应的那一行——tu ← 0 变 tu = 0，tu < 36 变 while tu < 36:，ji ← 35 tu 变 ji = 35 - tu，脚数 = 94 变 if ji * 2 + tu * 4 == 94:，输出 ji、tu 变 print(...)，tu ← tu + 1 变 tu = tu + 1。每一站都配一个当堂动笔的活动：翻译一遍、改一改数字、找错改错，学生动笔填一次、上机念一次，语句才留得下来。全课的题目数据、程序与练习情境均为示例，不出现真实的未成年人姓名与照片。
三、教学目标
信息意识
· 知道把算法写成程序，计算机才能按算法一步一步执行，愿意在动手写程序之前先把做法想清楚。
· 知道同一个算法可以用不同的计算机语言实现，知道计算机语言从机器语言发展到了高级语言。
计算思维
· 能说出 IDLE 两个窗口各有什么用，知道程序在哪里写、在哪里运行。
· 能读懂赋值、循环、分支、输出四类基础语句，并说出每一句在程序里做什么。
· 能把流程图里的每一步写成对应的程序语句。
数字化学习与创新
· 能在任务单上把鸡兔同笼的流程图翻译成程序，并在 IDLE 里把程序输进去、运行出来。
· 能把同一段程序换成一组新数据（30 个头、88 只脚）并核对结果，能照着样例自己写出三角形周长的程序。
信息社会责任
· 知道程序里出错是常事，愿意静下心来找原因、改程序，不因为报错就放弃。
· 知道写程序要按计算机能认的规矩来（英文标点、缩进），做事讲规范。
· 活动与作业中的题目数据、程序均为示例，不出现真实同学的姓名与照片。
四、教学重点与难点
教学重点：认识赋值、循环、分支、输出四类基础语句；能把流程图里的每一步写成对应的程序语句。
教学难点：分清 = 与 == 的不同（一个存值、一个判断）；理解缩进表示代码层次，知道哪些行属于循环体或分支体。
五、教学准备
教师：教学课件(31 页)、核心动画(5 分 00 秒，带配音)、“流程图 程序”对照表(自制)、找错改错的程序卡(自制)、学生活动任务单、学习评价表。
学生：活动任务单、笔；有条件的在机房电脑上打开 IDLE 同步操作。
六、教学方法与学法指导
教法：情境教学法、任务驱动法、演示法、对比教学法。以“上一课的流程图计算机看不懂”这一个问题贯穿全课，用一张对照表把六步流程图与六行程序一一对应起来，用一张找错卡把最容易写错的地方摆到台面上。
学法：对照阅读法、填表整理法、动手改错法、讨论辨析法。学生先认语句，再对着流程图写程序，然后改数字、找错误，最后换一道题自己写一遍。
七、教学过程
环节 教师活动 学生活动 设计意图 时间
一、承接与导入 回扣上一课的流程图六步：一步一步读一遍，说明“别人照着就能做”。追问：计算机看得懂这张流程图吗？——看不懂，它只认用计算机语言写成的指令。交代本课的活儿：把这张流程图一行一行翻译成程序。 跟着读一遍流程图的六步；说出本课要解决的问题；知道“给人看的”和“给机器做的”是两件不同的东西。 用上一课的成品开课，学生立刻知道这一课要干什么，不用重新读题、不用重新讲算法。 4 分钟
二、计算机语言与运行环境 讲清三件事：计算机语言是人和计算机交流用的语言，写成的指令就是程序；从机器语言（一串 0 和 1）发展到高级语言（Python、C）；同一件事用 C 和 Python 都能写。再讲 IDLE 的两个窗口：Shell 显示结果、可直接输入代码运行；程序编辑器写完整程序并可保存。 比较两种语言写法的不同；说出两个窗口各负责什么；在自己的电脑上打开 IDLE 指一指这两个窗口。 先让学生知道“程序写在哪、到哪里运行”，后面的语句才有地方试、有地方看结果。 5 分钟
三、认识四类基础语句 以鸡兔同笼的程序为例，一类一类认：赋值语句 tu = 0（把 0 存进变量 tu）；循环语句 while tu < 36:；分支语句 if ji * 2 + tu * 4 == 94:；输出语句 print(ji, "只鸡，", tu, "只兔。")。再集中讲最容易错的地方：= 存值、== 判断；行末要英文冒号；下属的行要缩进；标点一律英文半角。 逐句读代码，说出每一句在做什么；把“= 与 ==”“冒号与缩进”两条抄进任务单；说出 print 里加引号和不加引号的区别。 把“写程序”拆成四类能认、能说的语句，难点集中在一页讲透，不在每页都重复一遍。 6 分钟
四、核心：流程图一步一步变成程序 出示对照表，一行对一行读：tu ← 0 写成 tu = 0；tu < 36 写成 while tu < 36:；ji ← 35 tu 写成 ji = 35 - tu；脚数 = 94 写成 if ji * 2 + tu * 4 == 94:；输出 ji、tu 写成 print(...)；tu ← tu + 1 写成 tu = tu + 1。指出缩进：循环体缩一次，分支体再缩一次。再出示运行结果：23 只鸡， 12 只兔。 对着表一行一行读，说出“这一步对应程序的哪一行”；数一数缩进了几次；看着运行结果回扣上一课“试了 13 次”的过程。 这是全课的核心页：上一课花一整节课画的流程图，在这里变成计算机真的能执行的六行程序，学生第一次体会到“人想清楚、机器去做”。 8 分钟
五、活动一、活动二：翻译与改数字 组织活动一：不看书，把流程图每一步对应的程序语句写出来；巡视时重点看三处——while 那一行的冒号、ji = 35 - tu、判断用的 == 94。再组织活动二：把题目换成 30 个头、88 只脚，带学生找出要改的三处（tu < 31、ji = 30 - tu、== 88），运行后屏幕上应是 16 只鸡、14 只兔。 独立完成翻译，同桌互查后再对照课件核对；找出三处要改的数字，说出“为什么要一路改到底”。 把“听懂”变成“写得出”。改数字这一步让学生明白：程序里的数字不是死记的，它跟题目一一对应。 6 分钟
六、换一题：三角形周长 出示教材的练习：边长为 3、4、5 厘米的三角形，周长是多少？先带学生想清楚对象（三条边 a、b、c）、数量（3、4、5）、关系（周长 = 三边之和），再出示四行程序：a = 3、b = 4、c = 5、print("周长是", a + b + c, "厘米")；运行结果是“周长是 12 厘米”。追问：把 3 改成 6 会怎样？ 先想清楚三件事，再读程序；说出 12 是计算机算出来的，不是写死在程序里的；有条件的在 IDLE Shell 里自己敲一遍。 换一道题自己走一遍，学生才知道“翻译”这件事是可以迁移的；用“改一个数结果就变”点出程序与写死的区别。 5 分钟
七、活动三与议一议 出示小明写的程序，说明有四处错：While 大小写、缺英文冒号、判断用了 = 、tu = tu + 1 缩进过多。给学生方法：一句一句念出来。再议一议：程序写完就一定有正确结果吗？报错、结果不对分别该怎么办？ 先自己找错，再把改法写下来；同桌交流找到几处；说出“报错不可怕，它是计算机在告诉我哪里没写对”。 把最容易错的四处集中起来辨析；同时为下一课“算法的执行（运行与调试）”做铺垫。 3 分钟
八、练习、小结与评价 交代 14 题分三层与讲评重点（第 4、5、7、8、13 题）；对答案后顺着板书理一遍全课路线；核对学习评价表，布置分层作业。 独立完成基础题，提升题与综合题同桌互查；对答案后订正；对照板书复述“认语言—认语句—对着流程图写程序”；完成自评，记下没到三星的那一项。 用练习检验语句是否真的认得了、写得对；整课收口成一句话，学生带走的是方法，不是六行代码。 3 分钟
八、板书设计
用程序设计语言描述算法
承接：上一课的流程图六步，计算机看不懂——它只认计算机语言写成的指令
计算机语言：机器语言（0 和 1）→ 高级语言（Python、C）
运行环境：IDLE ＝ IDLE Shell（试一句、看结果）＋ 程序编辑器（写一段、存下来）
四类基础语句：赋值 tu = 0　│　循环 while tu < 36:　│　分支 if ji * 2 + tu * 4 == 94:　│　输出 print(...)
两条规矩：= 存值，== 判断　│　行末英文冒号，下属的行要缩进
流程图 → 程序：tu←0 → tu = 0；tu<36 → while tu < 36:；ji←35 tu → ji = 35 - tu
运行结果：23 只鸡， 12 只兔　│　换一题：三角形周长 3、4、5 → 12 厘米
一句话：流程图说清怎么做，程序让计算机真的去做。
九、作业设计(分层)
基础题(必做)：把“鸡兔同笼”的流程图写成程序，在 IDLE 里把六行程序输进去、运行一遍，并把屏幕上的运行结果记在任务单上。
提高题(选做)：把程序里的 35、94 改成 30、88，运行并核对结果是不是 16 只鸡、14 只兔，再说说一共要改哪几处。
拓展题(选做)：给三角形周长程序再加一条边 d，算出四边形的周长，并说出程序里要改哪几行。
阅读任务：读《从“照着做”到“让机器做”》，想一想还有哪件事，你想请计算机替你做。
作业要求：数据要标明“示例”，不出现真实同学的姓名；程序里的标点一律用英文半角，循环体、分支体要缩进。
任务单练习参考答案：
题号 1 2 3 4 5 6 7
答案 B B A B B A B
题号 8 9 10 11 12 13 14
答案 B B A A B B A
讲评要点：第 4、5 题考查 IDLE 两个窗口的分工，要让学生说清“谁负责试一句、谁负责存下来”；第 7、8 题考查 = 与 == 的区别，＝是把值存进变量，== 才是判断相等，两者不能互换；第 10 题接活动二，35、94 改成 30、88 以后，循环条件、鸡的只数、判断条件三处都要跟着改；第 13 题考查标点必须用英文半角。活动三的四处错（While 大小写、缺英文冒号、用 = 判断、tu = tu + 1 缩进太多）建议只讲错得多的题，把时间留给学生说理由。
十、学习评价说明
本课采用自评、互评、师评相结合的方式，评价维度包括：能否说出把算法写成程序的作用、知道 Python 是高级语言；能否说出 IDLE 两个窗口各有什么用；能否读懂赋值、分支、循环、输出这几类基础语句；能否把流程图里的每一步写成对应的程序语句。
星级标准：☆☆☆ 能独立完成并说清理由；☆☆ 能完成但需要提示；☆ 需要在老师或同伴帮助下完成。
十一、教学反思
(课后对照以下问题填写)
· 学生能不能说清“流程图给谁看、程序给谁做”？
· 写程序时，有多少学生把 = 当成判断相等、写成了 ji = 94 一类的式子？
· 缩进的问题集中在哪里：漏缩、多缩，还是缩得对不齐？
· 活动一里，while 那一行的英文冒号有多少人漏写？
· 活动二改数字时，有多少学生想到了“三处都要改”？
· 有条件的班级里，学生在 IDLE 里亲手运行过的人占多少？浙教版小学信息科技六年级上册 · 第 4 课
《用程序设计语言描述算法》学习任务单
班级：__________　姓名：__________　日期：__________
本单中的题目数据与程序都是示例数据；请你也只写示例，不出现真实同学的姓名。
认一认 计算机语言与基础语句
先把要认的东西认清楚，再动手写程序。
要认清的 我填
计算机语言是＿＿＿＿＿＿和＿＿＿＿＿＿交流用的语言；写成的指令就是＿＿＿＿＿＿。
IDLE 有两个窗口：＿＿＿＿＿＿负责“试一句、看结果”；＿＿＿＿＿＿负责“写一段、存下来”。
四类基础语句：赋值＿＿＿＿、循环＿＿＿＿、分支＿＿＿＿、输出＿＿＿＿。
两条规矩：＿＿＿ 是把值存进变量，＿＿＿ 才是判断相等；行末要有英文＿＿＿＿，下属的行要＿＿＿＿。
我的疑问：＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿。
活动一 把流程图翻译成程序
上一课的流程图就在左边。不看书，先自己把右边的程序语句写出来；写完再和“对一对”那一列核对。
流程图的每一步 我写的程序语句 对一对
01　tu ← 0 tu = 0
02　tu < 36 while tu < 36:
03　ji ← 35 tu 　　ji = 35 - tu
04　脚数 = 94 　　if ji * 2 + tu * 4 == 94:
05　输出 ji、tu 　　　　print(ji, "只鸡，", tu, "只兔。")
06　tu ← tu + 1 　　tu = tu + 1
我漏掉的地方：＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿。
活动二 改一改数字
题目换成 30 个头、88 只脚。程序里哪几处要跟着改？把改法写在右边；改完运行一遍，把屏幕上的结果记下来。
要改的地方 原来怎么写 改成什么
循环条件 tu < 36
鸡的只数 ji = 35 - tu
判断条件 == 94
运行结果：＿＿＿＿ 只鸡、＿＿＿＿ 只兔。
想一想：为什么改一个数字，要顺着一路改到底？＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿。
活动三 找错改错
下面是小明写的程序，一共四处错。先自己找，再把改法写下来。
While tu < 36　／　　 ji = 35 - tu　／　　if ji * 2 + tu * 4 = 94:　／　　　print(ji, "只鸡，", tu, "只兔。")　／　　　　tu = tu + 1
处 错在哪儿 应该怎么改
1 While tu < 36
2 （这一行末尾少了什么）
3 if ji * 2 + tu * 4 = 94:
4 tu = tu + 1
我的方法：一句一句＿＿＿＿＿＿出来，＿＿＿＿＿＿的地方就有问题。
试一试 三角形周长
边长为 3、4、5 厘米的三角形，周长是多少？先想清楚三件事，再写四行程序；有条件的在 IDLE Shell 里敲一遍。
要写清的 我填
对象（三条边）
数量
关系
我写的程序
运行结果
把程序里的 3 改成 6，再运行一次，结果是：＿＿＿＿＿＿＿＿。
辨一辨 下面说法对不对
先判断对错，再写清理由。理由比结论更重要。
说法 对 / 错 我的理由
把算法写成程序，计算机才能按算法一步一步执行。
Python 是一种机器语言。
IDLE 的两个窗口都能写完整的程序并保存下来。
程序里的 = 就是判断两边相等。
循环体、分支体要缩进，计算机靠缩进分辨代码的层次。
同一个算法，可以用不同的计算机语言写成程序。
练一练 随堂练习
基础题 1—5 全班必做；提升题 6—10、综合题 11—14 同桌互查。
题号 题目 我的答案
1 把算法转化成计算机能执行的指令，得到的成果叫什么？A 流程图　B 程序　C 表格
2 Python 属于哪一类计算机语言？A 机器语言　B 高级语言　C 自然语言
3 Python 自带的集成开发环境是？A IDLE　B 浏览器　C 画图
4 IDLE 里既显示运行结果、又能直接输入一句代码运行的窗口是？A 程序编辑器　B IDLE Shell　C 资源管理器
5 要写一段完整的、可以保存下来的程序，应该在哪个窗口里写？A IDLE Shell　B 程序编辑器　C 记事本
6 下面哪一句是赋值语句？A tu = 0　B tu == 0　C while tu < 36:
7 流程图里的 ji ← 35 tu 写成 Python 应该是？A ji == 35 - tu　B ji = 35 - tu　C 35 - tu = ji
8 判断“脚数等于 94”，程序里应该写成？A ji*2+tu*4 = 94　B ji*2+tu*4 == 94　C 两个都可以
9 循环体、分支体要缩进，是因为？A 看起来整齐　B 计算机靠它分辨这些行属于上面那句话　C 可以少写几个字
10 把程序里的 35 改成 30、94 改成 88，运行后输出的结果是？A 16 只鸡、14 只兔　B 14 只鸡、16 只兔　C 23 只鸡、12 只兔
11 判断：把算法写成程序，计算机才能按算法一步一步执行。A 对　B 错
12 判断：Python 是一种机器语言。A 对　B 错
13 判断：程序里的标点可以用中文的，只要意思对就行。A 对　B 错
14 判断：同一个算法可以用不同的计算机语言写成程序。A 对　B 错
评一评 学习评价
在对应的星级上打钩，三星表示做得很好。
评价内容 自评 互评 师评
我能说出把算法写成程序的作用，知道 Python 是高级语言 ☆☆☆ ☆☆☆ ☆☆☆
我能说出 IDLE 两个窗口各有什么用 ☆☆☆ ☆☆☆ ☆☆☆
我能读懂赋值、分支、循环、输出这几类基础语句 ☆☆☆ ☆☆☆ ☆☆☆
我能把流程图里的每一步写成对应的程序语句 ☆☆☆ ☆☆☆ ☆☆☆
课后作业
1. 基础(必做)：把“鸡兔同笼”的流程图写成程序，在 IDLE 里把六行程序输进去、运行一遍，并把屏幕上的运行结果记在下面。
2. 提高(选做)：把程序里的 35、94 改成 30、88，运行并核对结果，再说说一共要改哪几处。
3. 拓展(选做)：给三角形周长程序再加一条边 d，算出四边形的周长，说出程序里要改哪几行。
4. 阅读：读一读《从“照着做”到“让机器做”》，想一想还有哪件事，你想请计算机替你做。
5. 提醒：数据要标明“示例”，不出现真实同学的姓名；程序里的标点一律英文半角，循环体、分支体要缩进。
我的运行记录 / 记录区：
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿

展开更多......

收起↑