内容正文:
高中信息技术(人教中图版)—— 第二章程序与算法实现复习和巩固
一、知识点填空题
1. 算法是为解决一类特定问题而采取的______、______的步骤,从广义上讲,算法描述了问题求解的______和______。
1. 计算机领域中,算法是精心设计的______序列,描述了计算机如何将______转化为______的过程。
1. 算法的核心特征包括______、______、______、______、______,其中______指算法必须在有限步骤后终止,______指算法每个步骤含义明确无歧义。
1. 描述算法的常用方法有______、______、______,其中______直观易读、结构清晰,适合初学者使用。
1. 算法的三种基本控制结构是______、______、______,其中______按语句顺序依次执行,______根据条件选择执行不同分支,______在条件成立时重复执行某一语句块。
1. 用计算机解决问题的一般过程包括______、______、______、______、______五个环节。
1. 程序是一组______的计算机指令,程序设计语言经历了______、______、______三个发展阶段,其中______语法接近自然语言,通用性强。
1. Python语言中常见的数据类型有______、______、______、______、______,其中______用于表示整数,______用于表示小数,______用于表示逻辑判断结果。
1. 变量是内存中存放数据的______,Python中变量命名需遵循:可包含______、______、______和______,但不能以______开头,且区分______。
1. 常量指程序运行过程中______的量,变量指程序运行过程中______的量,Python中变量通过______语句创建并赋值。
1. 运算符主要包括______、______、______三类,其中______用于比较两个值的大小,结果为布尔值;______用于逻辑运算,常见的有______、______、______。
1. Python中赋值语句的格式为______,条件语句主要有______和______结构,循环语句主要有______和______语句。
1. 程序调试的常用方法有______和______,其中______通过设置断点跟踪变量取值,观察运行结果。
1. 解析算法的核心是找出问题中______与______之间的关系表达式,通过计算表达式求解;枚举算法的核心是______答案的大致范围,______验证所有可能情况。
1. 递归方法解决问题需满足两个条件:一是______,二是______。
1. Python中函数调用的一般格式为______,内置函数input()用于______,print()用于______。
1. 列表是存放一组数据的______,元素用______括起,各元素以______分隔;字典是______的无序集合,元素由______和______组成,用______括起。
1. 循环嵌套指一个循环结构内包含另一个循环,常用的是______循环,外循环每执行一次,内循环需执行______完整循环。
1. break语句用于______循环,continue语句用于______本次循环并进入下一次循环。
1. 程序设计的核心是______,程序是算法的______实现,______决定了问题解决的效率。
二、选择题
1. 下列关于算法的说法,错误的是( )
A. 算法一般要求有零个或多个输入,必须至少一个输出
B. 算法步骤必须有限
C. 算法的每个步骤必须可行
D. 同一问题只能有一种算法
1. 下列不属于算法描述方法的是( )
A. 自然语言 B. 流程图 C. 伪代码 D. 机器语言
1. 算法的三种基本控制结构不包括( )
A. 顺序结构 B. 选择结构 C. 循环结构 D. 分支循环结构
1. Python语言中,下列变量名合法的是( )
A. 2name B. my_name C. name-2 D. if
1. 下列属于Python浮点型数据的是( )
A. 100 B. 3.14 C. “3.14” D. True
1. 表达式3 + 2 * 4 // 2的结果是( )
A. 7 B. 9 C. 11 D. 5
1. 下列关于条件语句的说法,正确的是( )
A. if语句的条件表达式结果必须为布尔值
B. else语句可以单独使用
C. elif语句不能与if语句配合使用
D. 条件语句中冒号可省略
1. 循环语句for i in range(5, 0, -1)的循环次数是( )
A. 4次 B. 5次 C. 6次 D. 3次
1. 下列属于解析算法应用的是( )
A. 查找1000以内的素数 B. 鸡兔同笼问题求解
C. 自由落体位移计算 D. 票据模糊数字推断
1. 关于程序调试,下列说法错误的是( )
A. 可通过print()函数输出变量值调试
B. 断点调试可跟踪变量取值
C. 调试的目的是发现并改正错误
D. 程序运行无报错即说明无逻辑错误
1. Python中,下列表达式结果为True的是( )
A. 3 > 5 or 2 < 4 B. 3 > 5 and 2 < 4
C. not (3 > 2) D. 3 == 5
1. 下列关于列表和字典的说法,正确的是( )
A. 列表和字典均为有序集合 B. 列表通过键访问元素
C. 字典通过索引访问元素 D. 字典元素由键和值组成
1. 下列程序段的运行结果是( )
num = 0
for i in range(1, 6):
if i == 3:
continue
num += 1
print(num)
A. 3 B. 4 C. 5 D. 2
1. 用计算机解决问题的正确流程是( ) ①编程调试 ②分析问题 ③提出问题 ④设计方案 ⑤解决问题
A. ③②④①⑤ B. ③④②①⑤ C. ②③④①⑤ D. ③②①④⑤
1. 下列属于枚举算法特点的是( )
A. 依赖数学表达式 B. 运算量可能较大
C. 无需验证条件 D. 效率高于所有算法
1. Python中,函数range(3, 10, 2)生成的序列是( )
A. [3,5,7,9] B. [3,5,7,9,10] C. [3,4,5,6,7,8,9] D. [3,6,9]
1. 下列关于递归算法的说法,正确的是( )
A. 递归无需终止条件
B. 递归可将复杂问题简化为小规模问题
C. 递归效率一定高于迭代
D. 所有问题都适合用递归解决
1. 表达式”Python” + “3.9”的结果是( )
A. “Python3.9” B. “Python+3.9” C. 报错 D. “Python 3.9”
1. 下列程序段用于计算1~10的累加和,正确的是( )
A. sum = 0
for i in range (1, 11):
sum += i
print (sum)
B. sum = 0
for i in range (10):
sum += i
print (sum)
C. sum = 0
i = 1
while i < 10:
sum += i
i += 1
print (sum)
D. sum = 0
i = 1
while i <= 10:
sum += i
print (sum)
1. 下列关于程序设计语言的说法,正确的是( )
A. 机器语言可直接被计算机执行 B. 汇编语言语法接近自然语言
C. 高级语言需要翻译为机器语言才能执行 D. Python属于汇编语言
三、简答题
1. 简述算法的五大特征及含义。
1. 简述用计算机解决问题的一般过程。
1. 区别解析算法和枚举算法的适用场景及优缺点。
1. 简述Python语言中for循环和while循环的异同。
四、程序分析题
1. 阅读下列Python程序,回答问题:
import math
a = int(input("请输入a的值:"))
b = int(input("请输入b的值:"))
c = int(input("请输入c的值:"))
delta = b * b - 4 * a * c
if delta > 0:
x1 = (-b + math.sqrt(delta)) / (2 * a)
x2 = (-b - math.sqrt(delta)) / (2 * a)
print(f"方程有两个不同实根:x1={x1:.2f}, x2={x2:.2f}")
elif delta == 0:
x = -b / (2 * a)
print(f"方程有一个实根:x={x:.2f}")
else:
print("方程无实根")
(1)该程序采用的算法类型是什么?
(2)该程序解决的问题是什么?
(3)若输入a=1、b=5、c=6,程序运行结果是什么?
1. 阅读下列Python程序,回答问题:
import math
num = 0
for i in range(100, 200):
flag = True
for j in range(2, int(math.sqrt(i)) + 1):
if i % j == 0:
flag = False
break
if flag:
print(i, end=" ")
num += 1
print(f"
100~200之间的素数共有{num}个")
(1)该程序采用的算法类型是什么?
(2)程序中flag变量的作用是什么?
(3)程序的运行结果是什么?
五、编程应用题
1. 编写Python程序,实现“自助式人行过街红绿灯”模拟功能:初始状态为红灯亮,按下按钮后,红灯开始15秒倒计时,倒计时结束后绿灯亮,绿灯持续20秒后自动切换回红灯(要求使用turtle模块绘制红绿灯,time模块控制时长)。
1. 编写Python程序,求任意两个正整数的最大公约数,要求使用欧几里得算法(辗转相除法),直至用户输入“q”或“Q”退出程序。
1
学科网(北京)股份有限公司
$
2026届高考信息技术专题复习-程序与算法实现
一、知识点填空题
1. 确定;有限;方法;过程
1. 运算;输入;输出
1. 有输入;有输出;有穷性;可行性;确定性;有穷性;确定性
1. 自然语言;流程图;伪代码;流程图
1. 顺序结构;选择结构;循环结构;顺序结构;选择结构;循环结构
1. 提出问题;分析问题;设计方案;编程调试;解决问题
1. 可执行;机器语言;汇编语言;高级语言;高级语言
1. 整型(int);浮点型(float);字符串型(str);布尔型(bool);列表(list);整型;浮点型;布尔型
1. 存储单元;字母;汉字;数字;下划线;数字;大小写
1. 值不能改变;值可以改变;赋值
1. 算术运算符;关系运算符;逻辑运算符;关系运算符;逻辑运算符;not;and;or
1. 变量名 = 表达式;单分支;双分支(多分支);while;for
1. 打印变量值调试;断点调试;断点调试
1. 前提条件;结果;界定;逐一
1. 复杂问题可分解为同类小规模问题;有明确的递归终止条件
1. 函数名(参数);接收键盘输入;在屏幕输出内容
1. 序列;中括号[];逗号;键值对;键;值;花括号{}
1. 二重;一个
1. 终止;终止
1. 算法设计;具体;算法
二、选择题
1. 答案:D
解析:同一问题可设计多种算法,不同算法效率可能不同,D错误;A、B、C均为算法的基本要求。
1. 答案:D
解析:机器语言是程序设计语言,并非算法描述方法,A、B、C均为常用的算法描述方法。
1. 答案:D
解析:算法的三种基本控制结构为顺序、选择、循环,分支循环结构是组合结构,不属于基本结构。
1. 答案:B
解析:Python变量命名规则:可包含字母、汉字、数字、下划线,不能以数字开头,不能使用关键字;A以数字开头,C含非法字符“-”,D是关键字,故选B。
1. 答案:B
解析:A是整型,C是字符串型,D是布尔型,B是浮点型。
1. 答案:A
解析:运算符优先级:算术运算符(先乘除后加减,//为整除),3 + (2*4)//2 = 3 + 4 = 7。
1. 答案:A
解析:else语句必须与if语句配合使用,B错误;elif语句用于多分支,需与if配合,C错误;条件语句中冒号不可省略,D错误。
1. 答案:B
解析:range(5,0,-1)生成序列[5,4,3,2,1],共5次循环。
1. 答案:C
解析:自由落体位移计算依赖物理公式,属于解析算法;A、B、D均属于枚举算法应用。
1. 答案:D
解析:程序运行无报错可能存在逻辑错误(如结果不符合预期),D错误;A、B、C均为程序调试的正确说法。
1. 答案:A
解析:A选项中2<4为True,or运算只要一个为True则结果为True;B选项and运算需两个均为True,结果为False;C选项not (3>2) = not True = False,故C错,3不等于5,故D为False。
1. 答案:D
解析:列表有序,字典无序,A错误;列表通过索引访问,B错误;字典通过键访问,C错误;D正确。
1. 答案:B
解析:i=1、2、4、5时执行num +=1,i=3时跳过,num最终为4。
1. 答案:A
解析:用计算机解决问题的流程为:提出问题→分析问题→设计方案→编程调试→解决问题,故选A。
1. 答案:B
解析:枚举算法需逐一验证所有可能情况,运算量可能较大,A是解析算法特点,C、D错误。
1. 答案:A
解析:range(3,10,2)生成从3开始、步长为2、小于10的序列,即[3,5,7,9]。
1. 答案:B
解析:递归必须有终止条件,A错误;递归效率不一定高于迭代,C错误;并非所有问题适合递归,D错误;B正确描述了递归的核心思想。
1. 答案:A
解析:Python中“+”可用于字符串连接,结果为”Python3.9”。
1. 答案:A
解析:B选项range(10)生成0~9,累加和为45,错误;C选项while i<10,缺少i=10,累加和为45,错误;D选项缺少i +=1,陷入死循环,错误;A正确计算1~10累加和为55。
1. 答案:A
解析:机器语言是二进制代码,可直接被计算机执行,A正确;汇编语言用助记符,语法不接近自然语言,B错误;高级语言需编译或解释为机器语言,C错误;Python属于高级语言,D错误。
三、简答题
1. 答案:
· 有输入:算法一般要求有0个或多个输入,描述运算对象的初始情况;
· 有输出:算法有1个或多个输出,反映输入数据加工后的结果;
· 有穷性:算法必须在执行有限个步骤后终止,不能无限循环;
· 可行性:算法的每个步骤都是可执行的,可分解为计算机基本操作;
· 确定性:算法的每个步骤含义明确,无歧义,不会导致多种解释。
1. 答案:
· 提出问题:明确需要解决的具体问题;
· 分析问题:调查收集相关资料,明确问题的目标、条件和相关规则,抽象问题本质;
· 设计方案:将问题分解为若干功能模块,设计算法(如用流程图描述);
· 编程调试:用程序设计语言编写程序,调试运行,发现并改正错误;
· 解决问题:验证程序运行结果,确保满足问题需求,最终解决问题。
1. 答案:
· 解析算法: 适用场景:问题可抽象为数学模型,能找到前提条件与结果的关系表达式; 优点:运算效率高,步骤简洁; 缺点:依赖数学知识,部分问题难以建立表达式。
· 枚举算法: 适用场景:答案范围明确,可逐一验证所有可能情况; 优点:逻辑简单,易于实现; 缺点:运算量可能较大,效率较低,需优化枚举范围。
1. 答案:
· 相同点:均用于实现循环结构,重复执行某一语句块;
· 不同点:
· for循环:适合确定循环次数的场景,通过序列(如range()、列表)控制循环次数;
· while循环:适合不确定循环次数的场景,通过条件表达式控制循环,条件成立则继续循环;
· for循环无需手动维护循环变量,while循环需手动更新循环变量避免死循环。
四、程序分析题
1. 答案: (1)解析算法(3分); (2)求解一元二次方程ax²+bx+c=0的实根(3分); (3)输入a=1、b=5、c=6时,delta=25-24=1>0,x1=(-5+1)/2=-2.00,x2=(-5-1)/2=-3.00,程序输出:“方程有两个不同实根:x1=-2.00, x2=-3.00”(4分)。
1. 答案: (1)枚举算法(3分); (2)标记当前数字是否为素数,flag=True表示是素数,flag=False表示不是素数(3分); (3)输出100~200之间的所有素数,共21个(4分)。
五、编程应用题
1. 答案:
import turtle
import time
# 初始化绘图环境
t = turtle.Turtle()
t.hideturtle()
t.screen.delay(0)
# 绘制红灯(初始状态)
def draw_red_light():
t.penup()
t.goto(0, 0)
t.color("red", "red")
t.begin_fill()
t.circle(30)
t.end_fill()
# 绘制绿灯
def draw_green_light():
t.penup()
t.goto(0, 0)
t.color("green", "green")
t.begin_fill()
t.circle(30)
t.end_fill()
# 绘制倒计时文字
def draw_countdown(num):
t.penup()
t.goto(0, -50)
t.color("black")
t.write(num, font=("黑体", 20, "normal"))
time.sleep(1)
t.clear()
# 主程序逻辑
draw_red_light()
print("红灯亮,禁止通行,按下回车键模拟按下过街按钮...")
input() # 模拟按下按钮
# 红灯倒计时15秒
for i in range(15, 0, -1):
t.clear()
draw_red_light()
draw_countdown(i)
# 绿灯亮20秒
t.clear()
draw_green_light()
print("绿灯亮,准许通行,持续20秒...")
time.sleep(20)
# 切换回红灯
t.clear()
draw_red_light()
print("红灯亮,禁止通行...")
turtle.done()
1. 答案:
import math
def gcd(m, n):
# 欧几里得算法(辗转相除法)
while n != 0:
r = m % n
m = n
n = r
return m
while True:
input_str = input("请输入两个正整数(用空格分隔),输入q/Q退出:")
if input_str.upper() == "Q":
print("程序退出!")
break
try:
m, n = map(int, input_str.split())
if m <= 0 or n <= 0:
print("请输入正整数!")
continue
result = gcd(m, n)
print(f"{m}和{n}的最大公约数是:{result}")
except:
print("输入格式错误,请重新输入!")
顺序结构例子
实例1:简单数值计算(基础)
功能:计算两个数的和、差、积,依次输出结果
# 定义两个初始数值(顺序结构第一步:数据初始化)
a = 15
b = 4
# 依次计算和、差、积(顺序结构第二步:数据处理)
sum_result = a + b
sub_result = a - b
mul_result = a * b
# 依次输出计算结果(顺序结构第三步:结果输出)
print("两数之和:", sum_result)
print("两数之差:", sub_result)
print("两数之积:", mul_result)
执行步骤与输出结果:
1. 先给变量a赋值15,变量b赋值4;
2. 计算a+b得到19,赋值给sum_result;
3. 计算a-b得到11,赋值给sub_result;
4. 计算a*b得到60,赋值给mul_result;
5. 按顺序打印三行结果:
两数之和: 19
两数之差: 11
两数之积: 60
实例2:单位换算(实用场景)
功能:将输入的厘米数转换为米和千米,依次输出
# 第一步:输入原始数据(固定值,模拟用户输入)
cm = 25600 # 25600厘米
# 第二步:依次执行单位换算(1米=100厘米,1千米=100000厘米)
m = cm / 100
km = cm / 100000
# 第三步:按顺序输出换算结果
print(f"{cm} 厘米 = {m} 米")
print(f"{cm} 厘米 = {km} 千米")
输出结果:
25600 厘米 = 256.0 米
25600 厘米 = 0.256 千米
实例3:字符串拼接与格式化(综合)
功能:拼接个人信息,按固定格式输出
# 第一步:定义多个字符串变量
name = "张三"
grade = "高三(1)班"
score = 95 # 信息技术成绩
# 第二步:拼接信息(顺序执行字符串处理)
info1 = "姓名:" + name + ",班级:" + grade
info2 = f"信息技术成绩:{score}分,等级:{'优秀' if score >= 90 else '良好'}"
# 第三步:依次输出拼接结果
print(info1)
print(info2)
输出结果:
姓名:张三,班级:高三(1)班
信息技术成绩:95分,等级:优秀
实例4:几何公式计算(结合数学)
功能:计算圆的周长和面积,依次输出(π取3.14)
# 第一步:定义圆的半径
radius = 5
# 第二步:按公式依次计算周长和面积
pi = 3.14
circumference = 2 * pi * radius # 周长公式:2πr
area = pi * (radius **2) # 面积公式:πr²
# 第三步:输出结果(保留1位小数)
print(f"圆的半径:{radius} cm")
print(f"圆的周长:{circumference:.1f} cm")
print(f"圆的面积:{area:.1f} cm²")
输出结果:
圆的半径:5 cm
圆的周长:31.4 cm
圆的面积:78.5 cm²
总结
1. 顺序结构的核心是代码逐行执行,先执行的语句会影响后执行的语句(比如先定义变量,后使用变量);
1. 所有实例都遵循“初始化数据 → 处理数据 → 输出结果”的顺序逻辑,这是顺序结构最典型的应用模式;
1. 输出结果完全由代码执行顺序决定,没有任何“跳过”或“重复”的逻辑,这是区分顺序结构与分支/循环结构的关键。
选择结构例子
实例1:数值判断(单分支 + 双分支)
功能:计算两数运算结果,并根据结果判断是否为正数
# 初始化数据
a = 15
b = 4
# 计算差值(顺序执行)
sub_result = a - b
# 选择结构:判断差值是否为正数(双分支 if-else)
if sub_result > 0:
print(f"两数之差 {sub_result} 是正数")
else:
print(f"两数之差 {sub_result} 不是正数")
# 选择结构:判断乘积是否大于100(单分支 if)
mul_result = a * b
if mul_result > 100:
print(f"两数之积 {mul_result} 大于100")
执行逻辑与输出结果:
1. 先计算sub_result = 11,满足>0,执行if分支;
2. 再计算mul_result = 60,不满足>100,跳过if分支; 输出:
两数之差 11 是正数
实例2:单位换算+范围判断(多分支 if-elif-else)
功能:将厘米换算后,根据长度范围分类输出描述
# 初始化数据
cm = 25600 # 25600厘米
km = cm / 100000 # 换算为千米
# 选择结构:多条件分支判断长度范围
if km >= 1:
print(f"{cm} 厘米 = {km} 千米,属于'千米级'长度")
elif km >= 0.1:
print(f"{cm} 厘米 = {km} 千米,属于'百米级'长度")
else:
print(f"{cm} 厘米 = {km} 千米,属于'米级'长度")
执行逻辑与输出结果:
1. 先换算km = 0.256;
2. 判断0.256 >= 1?不满足 → 进入下一个elif;
3. 判断0.256 >= 0.1?满足 → 执行该分支; 输出:
25600 厘米 = 0.256 千米,属于'百米级'长度
实例3:成绩等级判定(嵌套选择结构)
功能:根据成绩判断等级,且区分文理科班级的评价标准
# 初始化数据
name = "张三"
grade = "高三(1)班" # 假设1班是理科,2班是文科
score = 88 # 信息技术成绩
# 选择结构:嵌套分支(先判断班级,再判断成绩)
if "理科" in grade or "1班" in grade:
# 理科班评分标准:90+优秀,80-89良好,<80合格
if score >= 90:
level = "优秀"
elif score >= 80:
level = "良好"
else:
level = "合格"
else:
# 文科班评分标准:85+优秀,75-84良好,<75合格
if score >= 85:
level = "优秀"
elif score >= 75:
level = "良好"
else:
level = "合格"
# 输出结果
print(f"{name}({grade})信息技术成绩:{score}分,等级:{level}")
执行逻辑与输出结果:
1. 先判断grade包含“1班” → 进入理科班分支;
2. 再判断88 >= 90?不满足 → 进入elif88 >=80?满足 → 赋值level = 良好; 输出:
张三(高三(1)班)信息技术成绩:88分,等级:良好
实例4:几何图形判断+计算(条件筛选)
功能:先判断半径合法性,再计算圆的周长/面积;非法则提示错误
# 初始化数据
radius = -5 # 故意设置为负数,测试选择结构
pi = 3.14
# 选择结构:先判断半径是否合法
if radius > 0:
# 合法则计算并输出
circumference = 2 * pi * radius
area = pi * (radius **2)
print(f"圆的半径合法({radius} cm)")
print(f"周长:{circumference:.1f} cm,面积:{area:.1f} cm²")
else:
# 非法则输出错误提示
print(f"错误:圆的半径 {radius} cm 不合法(半径必须大于0)")
执行逻辑与输出结果:
1. 判断radius = -5 > 0?不满足 → 执行else分支; 输出:
错误:圆的半径 -5 cm 不合法(半径必须大于0)
总结
1. 选择结构的核心是条件判断(if/elif/else),程序会根据条件真假“选择”执行某一段代码,而非全部执行;
1. 常见形式包括:单分支(仅if)、双分支(if-else)、多分支(if-elif-else)、嵌套分支(分支里套分支);
1. 条件判断的结果(True/False)决定了最终的输出,这是选择结构与顺序结构最核心的区别(顺序结构输出固定,选择结构输出随条件变化)。
循环结构例子
实例1:数值累加计算(while循环)
功能:用while循环计算1到10的累加和,并输出每一步的计算过程
# 初始化变量
i = 1 # 循环计数器
total = 0 # 累加和
# while循环:当i<=10时,重复执行循环体
while i <= 10:
total += i # 等价于 total = total + i
print(f"累加第{i}个数:当前和 = {total}")
i += 1 # 计数器自增(必须写,否则死循环)
# 循环结束后输出最终结果
print("="*20)
print(f"1到10的累加和:{total}")
执行逻辑与输出结果:
1. 初始i=1,total=0;
2. 每次循环先累加i到total,再打印过程,最后i+1;
3. 当i=11时,不满足i<=10,循环终止; 输出:
累加第1个数:当前和 = 1
累加第2个数:当前和 = 3
累加第3个数:当前和 = 6
累加第4个数:当前和 = 10
累加第5个数:当前和 = 15
累加第6个数:当前和 = 21
累加第7个数:当前和 = 28
累加第8个数:当前和 = 36
累加第9个数:当前和 = 45
累加第10个数:当前和 = 55
====================
1到10的累加和:55
实例2:批量单位换算(for循环 + 列表)
功能:用for循环批量处理多个厘米数值的单位换算,输出每个数值的换算结果
# 定义需要换算的厘米列表
cm_list = [1000, 25600, 50000, 100000]
# for循环:遍历列表中的每个数值,依次换算
for cm in cm_list:
km = cm / 100000
# 结合选择结构,给每个结果加描述
if km >= 1:
desc = "千米级"
elif km >= 0.1:
desc = "百米级"
else:
desc = "米级"
print(f"{cm} 厘米 = {km} 千米({desc})")
执行逻辑与输出结果:
1. for循环依次取出cm_list中的每个值赋给cm;
2. 对每个cm执行换算和条件判断,然后输出;
3. 列表遍历完成后,循环结束; 输出:
1000 厘米 = 0.01 千米(米级)
25600 厘米 = 0.256 千米(百米级)
50000 厘米 = 0.5 千米(百米级)
100000 厘米 = 1.0 千米(千米级)
实例3:成绩等级批量判定(for循环 + 字典)
功能:用for循环批量处理多个学生的成绩,判定等级并输出
# 定义学生成绩字典(姓名:成绩)
students = {
"张三": 95,
"李四": 88,
"王五": 72,
"赵六": 65
}
# for循环:遍历每个学生的姓名和成绩
print("学生信息技术成绩等级表:")
print("-"*30)
for name, score in students.items():
# 条件判断等级
if score >= 90:
level = "优秀"
elif score >= 80:
level = "良好"
elif score >= 70:
level = "合格"
else:
level = "待提升"
# 格式化输出
print(f"{name:6s} | 成绩:{score:3d} | 等级:{level}")
执行逻辑与输出结果:
1. items()方法取出字典中每个键值对(姓名、成绩);
2. 对每个学生的成绩执行等级判断,然后输出; 输出:
学生信息技术成绩等级表:
------------------------------
张三 | 成绩: 95 | 等级:优秀
李四 | 成绩: 88 | 等级:良好
王五 | 成绩: 72 | 等级:合格
赵六 | 成绩: 65 | 等级:待提升
实例4:圆的批量计算 + 循环中断(for + break)
功能:遍历多个半径值,计算圆的面积,遇到非法半径则终止循环
# 定义半径列表(包含合法/非法值)
radius_list = [3, 5, 8, -2, 10]
pi = 3.14
print("圆的面积计算(遇到非法半径终止):")
print("-"*30)
for radius in radius_list:
# 先判断半径是否合法,非法则中断循环
if radius <= 0:
print(f"检测到非法半径:{radius},终止计算!")
break # 立即跳出循环,不再执行后续内容
# 合法则计算面积
area = pi * (radius **2)
print(f"半径 {radius} cm → 面积 {area:.1f} cm²")
执行逻辑与输出结果:
1. 依次遍历3、5、8,均合法,计算并输出面积;
2. 遍历到-2时,满足radius<=0,执行break,循环立即终止(10不会被处理); 输出:
圆的面积计算(遇到非法半径终止):
------------------------------
半径 3 cm → 面积 28.3 cm²
半径 5 cm → 面积 78.5 cm²
半径 8 cm → 面积 201.0 cm²
检测到非法半径:-2,终止计算!
总结
1. 循环结构的核心是重复执行代码块,Python中主要有while(条件循环)和for(遍历循环)两种形式;
2. while循环需注意设置计数器自增(如i+=1),否则会陷入死循环;for循环常用于遍历列表、字典等可迭代对象;
3. break可强制中断循环,是循环控制的常用手段;循环结构常与选择结构结合(如条件判断+循环),这也是高考编程题的高频考点。
1
学科网(北京)股份有限公司
$