语句
如果说表达式是程序的“计算单元”，那么语句就是程序的“行动指令”。语句告诉Python解释器应该执行什么操作，以什么顺序执行，在什么条件下执行。
通过组合不同类型的语句，我们可以构建出功能复杂、逻辑清晰的程序。在这一节课中，我们将学习Python中最重要的语句类型，掌握控制程序流程的核心技能。
语句的基本概念与分类
在Python中，语句是构成程序的基本执行单位。每个语句都代表着一个完整的操作或指令，Python解释器会按照语句出现的顺序依次执行它们。
不同于表达式总是会产生一个值，语句的主要作用是执行某种操作或改变程序的状态。
Python的语句可以分为简单语句和复合语句两大类。简单语句通常占用一行，执行单一的操作，比如赋值语句x = 5或表达式语句print("Hello")。
复合语句则由多个部分组成，通常包含一个或多个语句块，比如条件语句和循环语句。
理解语句的执行顺序是编程的基础。在默认情况下，Python按照从上到下的顺序执行语句，这被称为顺序执行。
然而，通过使用控制语句，我们可以改变这种默认的执行流程，实现条件执行、重复执行等更复杂的程序逻辑。
让我们通过一个简单的例子来感受语句的作用：
# 这是一个包含多种语句的简单程序 name = "小明" # 赋值语句 age = 18 # 赋值语句 print ( f "姓名： { name } " ) # 表达式语句（函数调用）
# 条件语句 if age >= 18 : print ( "已成年" ) else :
print ( "未成年" )
# 循环语句
count = 0
while count < 3 :
print ( f "这是第 { count + 1} 次循环" )
count += 1
在这个例子中，我们看到了几种不同类型的语句：赋值语句建立了变量与值的关系，表达式语句执行了输出操作，条件语句根据年龄判断是否成年，循环语句重复执行了三次打印操作。
赋值语句的深入理解 赋值语句是Python中最基础也是最重要的语句类型之一。它不仅仅是简单地将值存储到变量中，更是建立了标识符与对象之间的绑定关系。
基本赋值操作 最简单的赋值语句使用等号=将右侧的值赋给左侧的变量。这个过程可以理解为给一个值贴上一个标签，让我们以后可以通过这个标签来引用这个值。
# 基本赋值示例 student_name = "张小华" student_age = 20 student_score = 85.5
print ( f "学生信息： { student_name } ，年龄 { student_age } 岁，成绩 { student_score } 分" )
# 变量的重新赋值 student_score = 90.0 print ( f "更新后的成绩： { student_score } 分" ) 在赋值过程中，Python会先计算右侧表达式的值，然后将这个值与左侧的变量名建立关联。这意味着右侧可以是任意复杂的表达式。
多重赋值与链式赋值 Python提供了几种特殊的赋值形式，让我们能够更高效地处理多个变量的赋值操作。
# 多重赋值（元组解包） name, age, city = "李明" , 25 , "北京" print ( f " { name } ， { age } 岁，来自 { city } " )
# 相同值的多重赋值 x = y = z = 0 print ( f "x= { x } , y= { y 多重赋值特别适合用于初始化多个相关变量，或者在需要交换变量值的场景中。这种语法让代码更加简洁和易读。
增强赋值运算符 增强赋值运算符将赋值操作与算术运算结合起来，提供了更简洁的语法来更新变量的值。
# 增强赋值运算符示例 score = 80 print ( f "初始分数： { score } " )
# 加分 score += 10 # 相当于 score = score + 10 print ( f "加分后： { score } " )
# 扣分 score -= 5 # 相当于 score = score - 5 print ( f "扣分后： { score } " 增强赋值运算符不仅让代码更简洁，在某些情况下还能提高执行效率，特别是对于可变对象的操作。
解包赋值的高级用法 Python的解包赋值功能非常强大，可以处理各种复杂的数据结构。
# 星号表达式在解包中的使用 numbers = [ 1 , 2 , 3 , 4 , 5 , 6 ] first, * middle, last = numbers print ( f "第一个： { first } " ) print ( f "中间部分： { middle } " ) print ( f "最后一个：
条件语句与程序分支 条件语句是程序中实现逻辑判断和分支控制的核心工具。通过条件语句，我们可以让程序根据不同的情况执行不同的操作，这使得程序具备了"智能"决策的能力。
if语句的基本结构 if语句是最基本的条件语句，它根据一个条件表达式的真假来决定是否执行特定的代码块。
# 基本的if语句 temperature = 35
if temperature > 30 : print ( "今天很热，记得多喝水！" ) print ( "建议穿轻薄的衣服" )
# 条件判断的不同情况 age = 17 if age >= 18 : print ( "可以观看成人电影" )
# 复杂条件的判断 score = 85 attendance = 0.95
在if语句中，条件表达式可以是任何能够产生真值或假值的表达式。Python会将表达式的结果转换为布尔值来进行判断。
if-else语句的二分逻辑 if-else语句提供了二选一的逻辑分支，当条件为真时执行一个代码块，当条件为假时执行另一个代码块。
# 简单的if-else结构 weather = "雨天"
if weather == "晴天" : print ( "太好了！可以去公园散步" ) activity = "户外运动" else : print ( "下雨了，还是在家读书吧" ) activity = "室内阅读"
print ( f "今天的活动安排： { activity } " )
# 数值判断的if-else number = int
elif语句的多分支逻辑 当需要处理多个条件时，elif语句提供了优雅的多分支解决方案，避免了嵌套的复杂性。
# 成绩等级判断 exam_score = 87
if exam_score >= 90 : grade = "A" comment = "优秀！继续保持这种学习状态" elif exam_score >= 80 : grade = "B" comment = "良好，还有提升空间" elif exam_score >= 70 : grade = "C" comment = "中等，需要更加努力" elif
逻辑分流器
循环语句与重复控制 循环语句允许我们重复执行某段代码，这是编程中处理重复任务的核心工具。Python提供了两种主要的循环结构：while循环和for循环，它们各有特点和适用场景。
while循环的条件控制 while循环基于条件重复执行代码块，只要条件为真就会继续执行，直到条件变为假为止。这种循环特别适合于不确定循环次数的情况。
# 基本的while循环 count = 1 while count <= 5 : print ( f "这是第 { count } 次循环" ) count += 1
print ( "循环结束" )
# 累加计算 total = 0 number = 1 while number <= 100 : total += while循环的关键在于确保循环条件最终会变为假，否则会产生无限循环。在循环体内通常需要包含能够改变条件变量的语句。
for循环的序列遍历 for循环专门用于遍历序列（如列表、字符串、范围等），它会自动处理循环变量的更新，让代码更加简洁和安全。
# 遍历列表 fruits = [ "苹果" , "香蕉" , "橙子" , "葡萄" ] print ( "今天的水果清单：" ) for fruit in fruits: print ( f "- { fruit } " )
# 遍历字符串 message = "Hello" print ( "字符串中的每个字符：" ) for char in message:
带索引的循环遍历 有时我们不仅需要访问序列中的元素，还需要知道元素的位置。Python提供了几种方法来同时获取索引和值。
# 使用enumerate()获取索引和值 students = [ "小明" , "小红" , "小刚" , "小丽" ] print ( "学生名单：" ) for index, student in enumerate (students): print ( f " { index + 1} . { student } " )
# 使用enumerate()的起始参数 print ( "从编号5开始的名单：" ) for
嵌套循环的应用 嵌套循环是指在一个循环内部包含另一个循环，这种结构在处理二维数据或复杂的组合问题时非常有用。
# 打印图案 print ( "星号图案：" ) for row in range ( 5 ): for col in range (row + 1 ): print ( "*" , end = "" ) print () # 每行结束后换行
# 九九乘法表 print ( " \n 完整的九九乘法表：" ) for i in
循环时光机
控制语句与流程管理 在循环执行过程中，有时我们需要根据特定条件提前结束循环或跳过某些迭代。Python提供了几个控制语句来精确管理程序的执行流程。
break语句的循环终止 break语句用于立即终止当前循环，跳出循环体继续执行后续代码。它就像是循环的"紧急停车"按钮。
# 在while循环中使用break attempts = 0 max_attempts = 3
while True : password = input ( "请输入密码：" ) attempts += 1 if password == "secret123" : print ( "密码正确，登录成功！" ) break elif attempts >= max_attempts: print ( "密码错误次数过多，系统锁定" )
continue语句的跳过控制 continue语句用于跳过当前迭代的剩余部分，直接开始下一次循环。它就像是说"这次就算了，直接看下一个"。
# 跳过偶数，只处理奇数 print ( "1到20之间的奇数：" ) for number in range ( 1 , 21 ): if number % 2 == 0 : continue # 跳过偶数 print ( f " { number } 是奇数" )
# 处理学生成绩，跳过无效分数 scores = [ 85 , - 1 ,
pass语句的占位符 pass语句是一个空操作，它什么也不做，主要用作语法上的占位符。当语法要求有语句但程序不需要执行任何操作时，可以使用pass。
# 条件语句中的pass age = 20 if age < 18 : pass # 暂时不处理未成年情况 elif age >= 65 : print ( "享受老年人优惠" ) else : print ( "正常价格" )
# 循环中的pass numbers = [ 1 , 2 , 3 , 4 , 5 ]
循环的else子句 Python循环语句有一个独特的特性：它们可以有else子句。循环的else子句在循环正常结束时执行，但如果循环被break中断，则不会执行。
# for循环的else子句 target_number = 7 numbers = [ 1 , 3 , 5 , 9 , 11 ]
for number in numbers: if number == target_number: print ( f "找到目标数字： { target_number } " ) break else : print ( f
异常处理语句 在程序运行过程中，可能会遇到各种错误情况，比如文件不存在、网络连接失败、用户输入无效数据等。Python提供了异常处理机制来优雅地处理这些错误情况，避免程序崩溃。
try-except语句的基本用法 try-except语句允许我们捕获和处理特定的错误，而不是让程序直接崩溃。
# 基本的异常处理 print ( "除法计算器" ) try : dividend = float ( input ( "请输入被除数：" )) divisor = float ( input ( "请输入除数：" )) result = dividend / divisor print ( f "结果： { dividend } ÷ { divisor } = { result
多种异常的处理 一个try语句可以有多个except子句来处理不同类型的异常，这样可以针对不同的错误情况提供相应的处理方式。
# 文件读取的异常处理 filename = input ( "请输入要读取的文件名：" )
try : with open (filename, 'r' , encoding = 'utf-8' ) as file : content = file .read() lines = content.split( ' \n ' ) print ( f "文件包含 {len (lines) } 行内容" )
else和finally子句 try语句除了可以有多个except子句外，还可以包含else和finally子句，用于实现更细致的异常处理流程：
else子句：如果try代码块没有抛出任何异常，else子句中的代码会被执行。通常用于那些只有在没有异常时才需要执行的操作，比如依赖于try块成功结果的后续处理。finally子句：无论try块中是否发生异常，finally子句中的代码都会被执行。常用于资源清理、关闭文件、断开网络连接等场景，确保程序的善后处理总能执行。 通过合理使用else和finally，可以让异常处理结构更加清晰和健壮。
# 使用else子句 print ( "安全的数学运算" ) try : x = float ( input ( "请输入第一个数：" )) y = float ( input ( "请输入第二个数：" )) operation = input ( "请选择运算（+, -, *, /）：" ) if operation == '+' : result = x + y
导入语句与模块使用 随着程序变得复杂，我们需要使用Python提供的各种内置模块，或者将代码分割成多个文件来更好地组织程序结构。导入语句让我们能够使用其他模块中的功能。
import语句的基本用法 import语句用于导入模块，使我们能够使用模块中定义的变量、函数和类。
# 导入整个模块 import math
# 使用数学模块的功能 radius = 5 area = math.pi * radius ** 2 circumference = 2 * math.pi * radius
print ( f "半径为 { radius } 的圆：" ) print ( f "面积： { area :.2f } " )
from-import语句的选择性导入 当我们只需要模块中的特定功能时，可以使用from-import语句来选择性地导入。
# 从模块中导入特定功能 from math import pi, sqrt, pow
# 直接使用导入的名称，不需要模块前缀 circle_radius = 3 area = pi * pow (radius, 2 ) diameter = 2 * radius diagonal = sqrt( 2 ) * radius
print ( f "正方形内接圆（半径 { circle_radius } ）：" ) print
习题 A. 只有条件为真时才执行
B. 无论条件真假都执行
C. 条件为假时执行
D. 条件未定义时执行
A. while循环
B. for循环
C. 两者都可以
D. 两者都不行
A. 跳过当前循环的剩余部分
B. 终止整个循环
C. 重新开始循环
D. 暂停程序执行
A. 循环被break中断时执行
B. 循环正常结束时执行
C. 循环开始时执行
D. 每次循环都执行
A. pass
B. break
C. continue
D. else
编写一个程序，根据分数判断等级：90分以上为A，80-89分为B，70-79分为C，60-69分为D，60分以下为F。
score = 85
# 根据分数给出等级 if score >= 90 : grade = "A" elif score >= 80 : grade = "B" elif score >= 70 : grade = "C" elif score >= 60 : grade = "D" else : grade 编写一个程序，使用while循环打印1到5的数字。
count = 1 while count <= 5 : print ( f "Count: { count } " ) count += 1 # 这里需要增加count的值，否则会形成无限循环 输出结果：
Count: 1
Count: 2
Count: 3
Count: 4
Count: 5
说明： 在while循环中，必须要有改变循环条件的语句（如count += 1），否则循环条件永远不会变为假，就会形成无限循环。
编写一个程序，读取用户输入的数字，计算10除以这个数字的结果，并处理可能的错误。
try : number = int ( input ( "请输入一个数字：" )) result = 10 / number print ( f "结果： { result } " ) except ZeroDivisionError : print ( "不能除以零！" ) except ValueError : print ( "请输入有效数字！" ) 运行示例：
输入5：
编写一个简单的菜单程序，使用while循环显示菜单，使用if-elif-else处理用户选择。
while True : print ( " \n === 简单菜单 ===" ) print ( "1. 选项一" ) print ( "2. 选项二" ) print ( "3. 选项三" ) print ( "4. 退出" ) choice = input ( "请选择（1-4）：" ) if choice == "1" : print
# 不同类型的赋值
temperature = 25 # 整数
humidity = 68.5 # 浮点数
is_sunny = True # 布尔值
weather_desc = "晴朗" # 字符串
}
, z=
{
z
}
"
)
# 交换变量值
a = 10
b = 20
print ( f "交换前：a= { a } , b= { b } " )
a, b = b, a
print ( f "交换后：a= { a } , b= { b } " )
# 列表解包赋值
scores = [ 88 , 92 , 76 ]
math_score, english_score, science_score = scores
print ( f "数学： { math_score } ，英语： { english_score } ，科学： { science_score } " )
)
# 乘法增强赋值
multiplier = 2
multiplier *= 3 # 相当于 multiplier = multiplier * 3
print ( f "乘法结果： { multiplier } " )
# 字符串的增强赋值
message = "Hello"
message += ", World!" # 字符串连接
print ( f "连接后的字符串： { message } " )
# 列表的增强赋值
numbers = [ 1 , 2 , 3 ]
numbers += [ 4 , 5 ] # 列表扩展
print ( f "扩展后的列表： { numbers } " )
{
last
}
"
)
# 忽略不需要的值
data = ( "张三" , 25 , "程序员" , "北京" , "单身" )
name, age, * _, status = data
print ( f "姓名： { name } ，年龄： { age } ，状态： { status } " )
# 嵌套结构的解包
student_info = [( "小明" , 20 ), ( "小红" , 19 ), ( "小刚" , 21 )]
for name, age in student_info:
print ( f " { name } 今年 { age } 岁" )
# 字典项的解包
person = { "name" : "王小二" , "age" : 28 , "job" : "教师" }
for key, value in person.items():
print ( f " { key } : { value } " )
if score >= 80 and attendance >= 0.9 :
print ( "恭喜！您获得了优秀学员证书" )
print ( "可以参加下一阶段的高级课程" )
(
input
(
"请输入一个整数："
))
if number % 2 == 0 :
print ( f " { number } 是偶数" )
print ( "偶数可以被2整除" )
else :
print ( f " { number } 是奇数" )
print ( "奇数除以2会有余数" )
# 年龄段判断
birth_year = 2000
current_year = 2024
age = current_year - birth_year
if age < 18 :
print ( "您是未成年人" )
print ( "请在成年人陪同下使用某些服务" )
else :
print ( "您已成年" )
print ( "可以独立承担法律责任" )
exam_score
>=
60
:
grade = "D"
comment = "及格，但需要加强基础"
else :
grade = "F"
comment = "不及格，建议重新学习"
print ( f "您的成绩等级是： { grade } " )
print ( f "评语： { comment } " )
# 季节判断
month = 8
if month in [ 12 , 1 , 2 ]:
season = "冬季"
clothing = "厚外套和围巾"
elif month in [ 3 , 4 , 5 ]:
season = "春季"
clothing = "轻薄外套"
elif month in [ 6 , 7 , 8 ]:
season = "夏季"
clothing = "短袖和凉鞋"
elif month in [ 9 , 10 , 11 ]:
season = "秋季"
clothing = "长袖和薄外套"
else :
season = "无效月份"
clothing = "请输入正确的月份"
print ( f "第 { month } 个月是 { season } " )
print ( f "建议穿着： { clothing } " )
number
number += 1
print ( f "1到100的和是： { total } " )
# 用户输入验证
password = ""
while password != "python123" :
password = input ( "请输入密码：" )
if password != "python123" :
print ( "密码错误，请重新输入" )
else :
print ( "密码正确，登录成功！" )
# 模拟银行取款
balance = 1000 # 账户余额
while True :
print ( f "当前余额： { balance } 元" )
amount = float ( input ( "请输入取款金额（输入0退出）：" ))
if amount == 0 :
print ( "感谢使用，再见！" )
break
elif amount > balance:
print ( "余额不足，请重新输入" )
else :
balance -= amount
print ( f "取款成功，余额： { balance } 元" )
print ( f "字符： { char } " )
# 使用range()生成数字序列
print ( "九九乘法表的一部分：" )
for i in range ( 1 , 6 ):
for j in range ( 1 , i + 1 ):
print ( f " { j } × { i } = { i * j } " , end = " " )
print () # 换行
# 计算平均分
scores = [ 85 , 92 , 78 , 96 , 88 , 73 , 89 ]
total_score = 0
for score in scores:
total_score += score
average = total_score / len (scores)
print ( f "平均分： { average :.2f } " )
# 查找最大值
numbers = [ 45 , 23 , 67 , 89 , 12 , 56 , 34 ]
max_number = numbers[ 0 ] # 假设第一个数是最大的
for number in numbers:
if number > max_number:
max_number = number
print ( f "最大值是： { max_number } " )
index, student
in
enumerate
(students,
start
=
5
):
print ( f " { index } . { student } " )
# 同时遍历多个列表
names = [ "张三" , "李四" , "王五" ]
ages = [ 25 , 30 , 28 ]
cities = [ "北京" , "上海" , "广州" ]
print ( "员工信息：" )
for name, age, city in zip (names, ages, cities):
print ( f " { name } ， { age } 岁，来自 { city } " )
# 处理不等长列表
subjects = [ "数学" , "英语" , "物理" , "化学" ]
scores = [ 95 , 87 , 92 ] # 故意少一个分数
print ( "成绩单：" )
for i in range ( len (subjects)):
if i < len (scores):
print ( f " { subjects[i] } ： { scores[i] } 分" )
else :
print ( f " { subjects[i] } ：未考试" )
range
(
1
,
10
):
for j in range ( 1 , i + 1 ):
result = i * j
print ( f " { j } × { i } = { result :2d } " , end = " " )
print ()
# 二维列表的处理
matrix = [
[ 1 , 2 , 3 ],
[ 4 , 5 , 6 ],
[ 7 , 8 , 9 ]
]
print ( " \n 矩阵内容：" )
for row in matrix:
for element in row:
print ( f " { element :3d } " , end = " " )
print ()
# 查找二维列表中的最大值
max_value = matrix[ 0 ][ 0 ]
max_position = ( 0 , 0 )
for i in range ( len (matrix)):
for j in range ( len (matrix[i])):
if matrix[i][j] > max_value:
max_value = matrix[i][j]
max_position = (i, j)
print ( f " \n 最大值是 { max_value } ，位置在( { max_position[ 0 ] } , { max_position[ 1 ] } )" )
break
else :
print ( f "密码错误，还有 { max_attempts - attempts } 次机会" )
print ( "程序继续执行..." )
# 在for循环中使用break
numbers = [ 12 , 25 , 8 , 19 , 30 , 7 , 42 ]
target = 19
print ( f "在列表中查找数字 { target } ：" )
for i, number in enumerate (numbers):
print ( f "检查第 { i + 1} 个数字： { number } " )
if number == target:
print ( f "找到了！ { target } 在第 { i + 1} 个位置" )
break
else :
print ( f "没有找到 { target } " )
# 嵌套循环中的break
print ( " \n 寻找第一个能被7整除的两位数：" )
for tens in range ( 1 , 10 ):
for units in range ( 0 , 10 ):
number = tens * 10 + units
if number % 7 == 0 :
print ( f "找到了： { number } " )
break
else :
continue # 内层循环正常结束，继续外层循环
break # 如果内层循环被break，也跳出外层循环
print ( "查找结束" )
92
,
78
,
150
,
88
,
0
,
95
]
valid_scores = []
total = 0
count = 0
print ( "处理成绩数据：" )
for score in scores:
if score < 0 or score > 100 :
print ( f "无效分数 { score } ，跳过处理" )
continue
print ( f "有效分数： { score } " )
valid_scores.append(score)
total += score
count += 1
if count > 0 :
average = total / count
print ( f "平均分： { average :.2f } " )
else :
print ( "没有有效分数" )
# 过滤特定条件的数据
products = [
{ "name" : "手机" , "price" : 2999 , "stock" : 10 },
{ "name" : "电脑" , "price" : 5999 , "stock" : 0 },
{ "name" : "平板" , "price" : 1999 , "stock" : 5 },
{ "name" : "耳机" , "price" : 299 , "stock" : 0 },
{ "name" : "充电器" , "price" : 99 , "stock" : 20 }
]
print ( " \n 有库存的商品：" )
for product in products:
if product[ "stock" ] == 0 :
continue # 跳过无库存商品
print ( f "商品： { product[ 'name' ] } ，价格： { product[ 'price' ] } 元，库存： { product[ 'stock' ] } 件" )
for number in numbers:
if number % 2 == 0 :
pass # 偶数暂时不处理
else :
print ( f " { number } 是奇数" )
# 异常处理中的pass（后面会详细学习）
try :
result = 10 / 0
except ZeroDivisionError :
pass # 忽略除零错误
print ( "程序继续执行" )
# 作为代码开发的占位符
user_input = input ( "请选择操作（1-添加，2-删除，3-修改）：" )
if user_input == "1" :
print ( "添加功能" )
# TODO : 实现添加功能
pass
elif user_input == "2" :
print ( "删除功能" )
# TODO : 实现删除功能
pass
elif user_input == "3" :
print ( "修改功能" )
# TODO : 实现修改功能
pass
else :
print ( "无效选择" )
"没有找到目标数字：
{
target_number
}
"
)
# while循环的else子句
attempts = 0
max_attempts = 3
password = ""
while attempts < max_attempts:
password = input ( "请输入密码：" )
attempts += 1
if password == "python123" :
print ( "密码正确！" )
break
else :
print ( f "密码错误，还有 { max_attempts - attempts } 次机会" )
else :
print ( "密码错误次数过多，账户被锁定" )
# 实际应用：检查质数
test_numbers = [ 17 , 25 , 29 , 33 , 37 ]
for num in test_numbers:
print ( f "检查数字 { num } ：" , end = "" )
# 判断是否为质数
if num < 2 :
print ( "不是质数（小于2）" )
else :
is_prime = True
for i in range ( 2 , int (num ** 0.5 ) + 1 ):
if num % i == 0 :
is_prime = False
break
if is_prime:
print ( "是质数" )
else :
print ( "不是质数" )
}
"
)
except ZeroDivisionError :
print ( "错误：除数不能为零！" )
except ValueError :
print ( "错误：请输入有效的数字！" )
print ( "程序继续运行..." )
# 处理列表索引错误
students = [ "小明" , "小红" , "小刚" ]
try :
index = int ( input ( "请输入学生编号（1-3）：" ))
student = students[index - 1 ] # 转换为0开始的索引
print ( f "选中的学生： { student } " )
except IndexError :
print ( "错误：学生编号超出范围！" )
except ValueError :
print ( "错误：请输入有效的数字！" )
# 处理字典键错误
student_scores = {
"小明" : 85 ,
"小红" : 92 ,
"小刚" : 78
}
try :
name = input ( "请输入学生姓名：" )
score = student_scores[name]
print ( f " { name } 的成绩是： { score } 分" )
except KeyError :
print ( f "错误：找不到学生 { name } 的成绩记录！" )
print ( "前5行内容：" )
for i, line in enumerate (lines[: 5 ]):
print ( f " { i + 1} : { line } " )
except FileNotFoundError :
print ( f "错误：找不到文件' { filename } '" )
print ( "请检查文件名和路径是否正确" )
except PermissionError :
print ( f "错误：没有权限读取文件' { filename } '" )
except UnicodeDecodeError :
print ( f "错误：文件' { filename } '编码格式不正确" )
except Exception as e:
print ( f "读取文件时发生未知错误： { e } " )
# 数据转换的异常处理
data_list = [ "123" , "45.6" , "abc" , "789" , "12.34.56" ]
valid_numbers = []
for item in data_list:
try :
# 尝试转换为浮点数
number = float (item)
valid_numbers.append(number)
print ( f "成功转换： { item } -> { number } " )
except ValueError :
print ( f "转换失败：' { item } '不是有效数字" )
print ( f "有效数字列表： { valid_numbers } " )
if valid_numbers:
print ( f "平均值： {sum (valid_numbers) / len (valid_numbers) :.2f } " )
elif
operation
==
'-'
:
result = x - y
elif operation == '*' :
result = x * y
elif operation == '/' :
if y == 0 :
raise ZeroDivisionError ( "除数不能为零" )
result = x / y
else :
raise ValueError ( "无效的运算符" )
except ValueError as e:
print ( f "输入错误： { e } " )
except ZeroDivisionError as e:
print ( f "运算错误： { e } " )
else :
# 只有没有异常时才执行
print ( f "运算结果： { x } { operation } { y } = { result } " )
finally :
# 无论是否有异常都会执行
print ( "感谢使用计算器！" )
# 文件处理的资源管理例子
filename = "numbers.txt"
file_handle = None
numbers = []
try :
print ( f "尝试打开文件： { filename } " )
file_handle = open (filename, 'r' )
data = file_handle.read()
print ( f "成功读取 {len (data) } 个字符" )
# 处理数据
for line in data.split( ' \n ' ):
if line.strip(): # 跳过空行
try :
number = float (line.strip())
numbers.append(number)
except ValueError :
print ( f "跳过无效数据： { line.strip() } " )
print ( f "成功处理 {len (numbers) } 个数字" )
except FileNotFoundError :
print ( "文件不存在" )
except PermissionError :
print ( "没有权限访问文件" )
except ValueError as e:
print ( f "数据格式错误： { e } " )
finally :
# 确保文件被关闭
if file_handle:
file_handle.close()
print ( "文件已关闭" )
print ( f "处理结果： { numbers } " )
print
(
f
"周长：
{
circumference
:.2f
}
"
)
# 使用数学函数
angle_degrees = 45
angle_radians = math.radians(angle_degrees)
sin_value = math.sin(angle_radians)
cos_value = math.cos(angle_radians)
print ( f " \n{ angle_degrees } 度角的三角函数值：" )
print ( f "正弦值： { sin_value :.4f } " )
print ( f "余弦值： { cos_value :.4f } " )
# 导入随机数模块
import random
# 生成随机数
random_int = random.randint( 1 , 100 )
random_float = random.random()
random_choice = random.choice([ '红' , '黄' , '蓝' , '绿' ])
print ( f " \n 随机数生成：" )
print ( f "1-100之间的随机整数： { random_int } " )
print ( f "0-1之间的随机小数： { random_float :.4f } " )
print ( f "随机选择的颜色： { random_choice } " )
# 模拟掷骰子
print ( " \n 掷骰子游戏：" )
for i in range ( 5 ):
dice = random.randint( 1 , 6 )
print ( f "第 { i + 1} 次掷骰子： { dice } " )
(
f
"圆的面积：
{
area
:.2f
}
"
)
print ( f "圆的直径： { diameter } " )
print ( f "正方形对角线： { diagonal :.2f } " )
# 从random模块导入常用功能
from random import randint, choice, shuffle
# 创建一个简单的抽奖程序
participants = [ "小明" , "小红" , "小刚" , "小丽" , "小华" ]
prizes = [ "一等奖" , "二等奖" , "三等奖" ]
print ( " \n 抽奖开始！" )
print ( f "参与者： { participants } " )
# 打乱参与者顺序
shuffle(participants)
print ( f "打乱后的顺序： { participants } " )
# 抽取获奖者
winners = participants[: len (prizes)]
for i, prize in enumerate (prizes):
print ( f " { prize } ： { winners[i] } " )
# 从datetime模块导入日期时间功能
from datetime import date, datetime
today = date.today()
now = datetime.now()
print ( f " \n 今天是： { today } " )
print ( f "现在时间： { now.strftime( '%Y年%m月 %d 日 %H:%M:%S' ) } " )
# 计算年龄
birth_year = 2000
current_year = today.year
age = current_year - birth_year
print ( f "出生于 { birth_year } 年的人今年 { age } 岁" )
=
"F"
print ( f "分数： { score } 分，等级： { grade } " )
ZeroDivisionError：当除数为0时抛出ValueError：当输入的不是有效数字时抛出 (
"您选择了选项一"
)
elif choice == "2" :
print ( "您选择了选项二" )
elif choice == "3" :
print ( "您选择了选项三" )
elif choice == "4" :
print ( "再见！" )
break # 退出循环
else :
print ( "无效输入，请重新选择！" )
=== 简单菜单 === 1. 选项一 2. 选项二 3. 选项三 4. 退出 请选择（1-4）：1 您选择了选项一
=== 简单菜单 === 1. 选项一 2. 选项二 3. 选项三 4. 退出 请选择（1-4）：4 再见！ 语句 | 自在学
