单元1 · Python开发环境与基础入门
Python 安装与交互模式、print 输出、注释、缩进、标识符与命名规范
- 解释器与运行方式：安装 Python 后，在终端输入 python 进入交互模式，或把代码保存为 .py 文件后用 python 文件名.py 运行。
- 第一个程序：print() 是最常用的输出函数，可一次输出多个值，默认以空格分隔。
- 注释：单行注释以 # 开头；多行说明可用连续 # 或三引号字符串包裹，解释器会忽略注释。
- 缩进与代码块：Python 用缩进（建议 4 个空格）表示代码块，同一代码块缩进必须一致。
- 标识符与命名规范：由字母、数字、下划线组成且不能以数字开头；变量用小写下划线命名，如 max_value。
实训1.1 Hello Python 程序（含注释）
编写第一个 Python 程序，在控制台输出 "Hello, Python!" 和一句欢迎语，并在代码中演示单行注释与多行注释的写法。
直接使用 print() 函数输出文本；Python 中单行注释用 # 开头，多行注释习惯用连续多个 # 或引号字符串包裹说明文字，解释器会忽略注释内容。
# 实训1.1：Hello Python 程序（含注释）
# 单行注释：输出问候语
print("Hello, Python!")
# 多行说明：下面使用连续 # 书写多行注释
# 再输出一行欢迎语
print("欢迎学习 Python 程序设计基础！")实训1.2 输出个人信息
定义变量保存自己的姓名、年龄、爱好，并在控制台分行打印输出，要求信息完整、排版美观。
Python 是动态类型语言，变量无需声明类型直接赋值；用字符串保存姓名与爱好、整数保存年龄，用字符串拼接或逗号分隔方式输出。
# 实训1.2：输出个人信息
name = "小明"
age = 18
hobby = "编程"
print("姓名：" + name)
print("年龄：" + str(age))
print("爱好：" + hobby)实训1.3 变量交换与类型查看
定义两个整数变量，交换它们的值并输出交换前后结果；再定义一个浮点变量，用 type() 查看它与整数的类型。
交换两个变量可以用临时变量 temp 中转；type() 是内置函数，可查看变量的数据类型。
# 实训1.3：变量交换与类型查看
a = 10
b = 20
print("交换前：a =", a, "b =", b)
temp = a
a = b
b = temp
print("交换后：a =", a, "b =", b)
x = 3.14
print("x 的值：", x, "类型：", type(x))
print("a 的值：", a, "类型：", type(a))单元2 · 变量、数据类型与运算符
动态类型、int/float/str/bool、算术/比较/逻辑运算符、类型转换、复合赋值
- 动态类型：变量不需要声明类型，赋什么值就是什么类型，可用 type() 查看。
- 常用数据类型：int 整数、float 浮点数、str 字符串、bool 布尔值（True/False）。
- 算术运算符：+ - * /（浮点除） //（整除） %（取余） **（幂），注意 / 与 // 的区别。
- 比较与逻辑：> < >= <= == != 返回布尔值；and / or / not 组合多个条件。
- 类型转换：int() 转整数、float() 转浮点、str() 转字符串，转换失败会抛异常。
实训2.1 整数运算：整除、取余、幂
给定两个整数 17 和 5，分别输出它们的和、差、积、商、整除结果、取余结果和幂运算结果。
Python 中 / 是浮点除法，// 是整除，% 是取余，** 是幂运算，直接用 print 输出即可。
# 实训2.1：整数运算演示
a = 17
b = 5
print("和：", a + b)
print("差：", a - b)
print("积：", a * b)
print("商：", a / b)
print("整除：", a // b)
print("取余：", a % b)
print("幂：", a ** b)实训2.2 计算圆的周长与面积
已知圆的半径 r = 7.5，圆周率取 3.14159，计算并输出圆的周长和面积。
周长公式 C = 2πr，面积公式 S = πr²；本题不依赖 math 库，直接用浮点数计算。
# 实训2.2：计算圆的周长与面积
r = 7.5
pi = 3.14159
circumference = 2 * pi * r
area = pi * r * r
print("半径：", r)
print("周长：", circumference)
print("面积：", area)实训2.3 摄氏温度转华氏温度
已知摄氏温度 c = 36.5，按公式 F = C × 9 ÷ 5 + 32 转换为华氏温度并输出。
公式直接翻译为 Python 表达式，注意运算符优先级：先乘除后加减。
# 实训2.3：摄氏温度转华氏温度
c = 36.5
f = c * 9 / 5 + 32
print("摄氏温度：", c)
print("华氏温度：", f)实训2.4 比较与逻辑运算判断
定义变量 age = 25、score = 88，分别判断：是否成年、成绩是否优秀（≥90）、两个条件是否同时满足、是否至少满足一个，并输出取反结果。
比较运算返回布尔值 True/False；逻辑运算 and 表示同时满足，or 表示至少一个满足，not 表示取反。
# 实训2.4：比较与逻辑运算
age = 25
score = 88
print("是否成年：", age >= 18)
print("成绩是否优秀：", score >= 90)
print("成年且成绩优秀：", age >= 18 and score >= 90)
print("成年或成绩优秀：", age >= 18 or score >= 90)
print("取反（未成年的相反）：", not age >= 18)单元3 · 流程控制：分支结构
if / elif / else 多分支、条件表达式、嵌套分支、布尔判断
- if 语句：条件成立时执行缩进代码块，条件用比较或逻辑表达式表示。
- elif / else：elif 用于多分支判断，else 兜底；分支按从上到下顺序匹配。
- 嵌套分支：分支代码块内可再写 if 语句，用于更复杂的条件组合。
- 缩进即结构：Python 没有花括号，代码块完全依赖缩进，同一层级缩进必须一致。
实训3.1 判断奇偶与正负
给定整数 n = -7，先判断它是正数、负数还是零，再判断它是奇数还是偶数。
用 if / elif / else 实现多分支；判断奇偶用 n % 2 == 0。
# 实训3.1：判断奇偶与正负
n = -7
if n > 0:
print("正数")
elif n < 0:
print("负数")
else:
print("零")
if n % 2 == 0:
print("偶数")
else:
print("奇数")实训3.2 成绩评级（多分支）
给定成绩 score = 85，按规则评级：≥90 优秀、≥80 良好、≥70 中等、≥60 及格、其余不及格，并输出成绩与等级。
使用 if / elif / else 从高到低逐级判断，注意分支顺序不能颠倒。
# 实训3.2：成绩评级
score = 85
if score >= 90:
grade = "优秀"
elif score >= 80:
grade = "良好"
elif score >= 70:
grade = "中等"
elif score >= 60:
grade = "及格"
else:
grade = "不及格"
print("成绩：", score, "等级：", grade)实训3.3 判断平年 / 闰年
判断 year = 2024 是否为闰年：能被 400 整除，或能被 4 整除但不能被 100 整除。
闰年规则用逻辑表达式组合：year % 400 == 0 or (year % 4 == 0 and year % 100 != 0)。
# 实训3.3：判断闰年
year = 2024
if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0):
print(year, "是闰年")
else:
print(year, "不是闰年")实训3.4 三个数从小到大排序
给定三个数 a = 30、b = 12、c = 25，不借助排序函数，用分支结构将它们从小到大排序输出。
两两比较并交换：先保证 a 最小，再保证 b 小于 c，即可完成排序。
# 实训3.4：三个数从小到大排序（分支交换法）
a = 30
b = 12
c = 25
if a > b:
temp = a
a = b
b = temp
if a > c:
temp = a
a = c
c = temp
if b > c:
temp = b
b = c
c = temp
print("排序结果：", a, b, c)单元4 · 循环结构
for-in-range、while、break / continue、循环嵌套、累加累乘
- for-in-range：range(n) 生成 0~n-1，range(a, b) 生成 a~b-1，是 Python 最常用的循环。
- while 循环：条件为真时反复执行，适合不确定次数的循环；注意更新循环变量避免死循环。
- break / continue：break 立即结束整个循环，continue 跳过本次进入下一次。
- 循环嵌套：外层循环控制行、内层循环控制列，是打印图形、乘法表的常用套路。
实训4.1 1~100 累加和与偶数和
使用 while 循环计算 1 到 100 的所有整数之和，以及其中所有偶数之和，并分别输出。
用变量 i 从 1 递增到 100，循环体内累加 total；用 i % 2 == 0 判断偶数并累加 even_total。
# 实训4.1：1~100 累加和与偶数和
total = 0
even_total = 0
i = 1
while i <= 100:
total = total + i
if i % 2 == 0:
even_total = even_total + i
i = i + 1
print("1~100 的和：", total)
print("1~100 偶数和：", even_total)实训4.2 九九乘法表
使用双重 for 循环输出 9×9 乘法表，每一行打印从 1 乘到当前行号的算式。
外层循环 i 表示行，内层循环 j 从 1 到 i；把一行算式拼成字符串后一次性输出，避免换行问题。
# 实训4.2：九九乘法表
for i in range(1, 10):
line = ""
for j in range(1, i + 1):
line = line + str(j) + "x" + str(i) + "=" + str(i * j) + " "
print(line)实训4.3 统计水仙花数
找出 100 到 999 之间所有的水仙花数（各位数字的立方和等于该数本身），输出这些数并统计个数。
用 n // 100 取百位，(n // 10) % 10 取十位，n % 10 取个位；满足 a³+b³+c³==n 即为水仙花数。
# 实训4.3：统计水仙花数
count = 0
result = ""
for n in range(100, 1000):
a = n // 100
b = (n // 10) % 10
c = n % 10
if a ** 3 + b ** 3 + c ** 3 == n:
result = result + str(n) + " "
count = count + 1
print("水仙花数：", result)
print("共", count, "个")实训4.4 输出 1~100 之间的质数
输出 2 到 100 之间的所有质数。质数指大于 1 且只能被 1 和自身整除的整数。
对每个数 n，从 2 试除到 √n；若存在因子则不是质数，用 break 提前结束内层循环。
# 实训4.4：输出 1~100 之间的质数
result = ""
for n in range(2, 101):
is_prime = True
i = 2
while i * i <= n:
if n % i == 0:
is_prime = False
break
i = i + 1
if is_prime:
result = result + str(n) + " "
print(result)单元5 · 字符串操作
字符串索引与切片、常用方法（upper/lower/strip/split/join/replace）、遍历与判断
- 索引与切片：字符串按下标访问字符，s[0] 取首字符，s[1:3] 取子串，负索引从尾部计数。
- 大小写与去除空白：upper() / lower() / title() 转换大小写，strip() 去除首尾空白。
- 拆分与拼接：split() 按分隔符拆成列表，join() 把列表拼回字符串。
- 查找与判断：find() 返回子串位置，startswith() / endswith() 判断开头结尾，count() 统计次数。
实训5.1 字符串反转与大小写转换
给定字符串 s = "Hello Python"，输出它的长度、大写形式、小写形式，并将字符串反转后输出。
len() 求长度，upper()/lower() 转换大小写；反转可以用循环从后往前拼接字符实现。
# 实训5.1：字符串反转与大小写转换
s = "Hello Python"
print("原字符串：", s)
print("长度：", len(s))
print("大写：", s.upper())
print("小写：", s.lower())
rev = ""
for ch in s:
rev = ch + rev
print("反转：", rev)实训5.2 统计一句话中的单词数
给定句子 "Python is a powerful programming language"，统计其中单词的个数，并逐行输出每个单词。
用 split() 按空格把句子拆成单词列表，len() 统计个数，for 循环逐个输出。
# 实训5.2：统计一句话中的单词数
sentence = "Python is a powerful programming language"
words = sentence.split()
print("句子：", sentence)
print("单词个数：", len(words))
for w in words:
print(w)实训5.3 回文串判断
判断字符串 s = "level" 是否为回文串（正读和反读相同），输出判断结果。
将字符串转小写去空格后反转，再与原串比较；反转用循环拼接实现。
# 实训5.3：回文串判断
s = "level"
clean = s.strip().lower()
rev = ""
for ch in clean:
rev = ch + rev
if clean == rev:
print(s, "是回文串")
else:
print(s, "不是回文串")实训5.4 姓名格式化与查找替换
给定字符串 name = " alice smith "，先去除首尾空格，再分别输出标题化、全大写形式；另对文本 "I love Python" 进行替换和查找。
strip() 去首尾空格，title() 单词首字母大写，replace() 替换子串，find() 查找子串位置，startswith() 判断开头。
# 实训5.4：姓名格式化与查找替换
name = " alice smith "
name = name.strip()
print("去空格后：", name)
print("标题化：", name.title())
print("全大写：", name.upper())
text = "I love Python"
print("替换后：", text.replace("Python", "coding"))
print("是否以 I 开头：", text.startswith("I"))
print("love 的位置：", text.find("love"))单元6 · 列表（增删改查与遍历）
列表增删改查（append/pop/insert/remove/sort/reverse）、遍历、固定数据组织
- 列表定义：用方括号 [ ] 定义，元素有序、可修改、可重复。
- 常用方法：append() 追加、insert() 插入、pop() 弹出、remove() 删除、sort() 排序、reverse() 逆序。
- 列表遍历：for 直接遍历元素，也可用 while + 下标访问。
- 元组（了解）：元组用圆括号定义、元素不可修改，适合保存固定数据；本教程环境以列表为主，概念可参考教材。
实训6.1 列表的增删改查
定义成绩列表 scores = [78, 92, 85, 60]，依次完成：末尾追加 95、开头插入 55、删除元素 60、修改首个元素为 58，并输出每次操作后的列表。
append() 追加到末尾，insert(0, x) 在开头插入，remove(x) 删除指定元素，索引赋值可修改元素。
# 实训6.1：列表的增删改查
scores = [78, 92, 85, 60]
print("原列表：", scores)
scores.append(95)
print("末尾追加95：", scores)
scores.insert(0, 55)
print("开头插入55：", scores)
scores.remove(60)
print("删除60：", scores)
scores[0] = 58
print("修改首个元素：", scores)
print("长度：", len(scores))实训6.2 列表最值与平均值
给定列表 nums = [12, 45, 78, 3, 99, 23]，输出最大值、最小值、总和和平均值。
max()/min()/sum() 是内置函数；平均值用总和除以长度 len()。
# 实训6.2：列表最值与平均值
nums = [12, 45, 78, 3, 99, 23]
total = 0
for n in nums:
total = total + n
print("列表：", nums)
print("最大值：", max(nums))
print("最小值：", min(nums))
print("总和：", sum(nums))
print("平均值：", total / len(nums))实训6.3 列表去重（保留顺序）
给定列表 nums = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]，去除重复元素并保持原顺序输出。
遍历原列表，用 in 判断元素是否已存在于新列表，不在才追加，即可去重且保持顺序。
# 实训6.3：列表去重（保留原顺序）
nums = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
result = []
for n in nums:
if n not in result:
result.append(n)
print("原列表：", nums)
print("去重后：", result)实训6.4 列表排序与逆序
给定列表 nums = [5, 2, 8, 1, 9, 3]，先升序排序输出，再逆序输出，最后用 sorted() 演示返回新列表。
列表的 sort() 原地升序排序，reverse() 原地逆序；sorted() 返回排序后的新列表。
# 实训6.4：列表排序与逆序
nums = [5, 2, 8, 1, 9, 3]
print("原列表：", nums)
nums.sort()
print("升序：", nums)
nums.reverse()
print("逆序：", nums)
print("sorted 新列表：", sorted([3, 1, 2]))实训6.5 坐标与颜色列表
定义坐标列表 point = [3, 4] 和颜色列表 colors = ["red", "green", "blue"]，输出坐标分量、列表长度，并遍历颜色列表。
列表用方括号定义，元素有序可修改；按下标访问元素，len() 求长度，for 循环逐个遍历。
# 实训6.5：坐标与颜色列表
point = [3, 4]
print("坐标：", point)
print("x =", point[0], "y =", point[1])
print("长度：", len(point))
colors = ["red", "green", "blue"]
for c in colors:
print(c)单元7 · 字典与集合
字典增删改查（get/pop/keys/in）、遍历、词频统计、集合运算（union/intersection/difference）
- 字典定义：用花括号 { } 定义键值对，键唯一且不可变，按键取值效率高。
- 增删改查：直接赋值新增或修改，get() 安全取值，pop() 删除，in 判断键是否存在。
- 字典遍历：for 遍历得到键，再通过 [键] 取值；len() 统计键值对个数。
- 集合：元素不重复且无序；union() 并集、intersection() 交集、difference() 差集。
实训7.1 学生成绩字典
定义成绩字典 scores = {"小明": 88, "小红": 95, "小刚": 76}，依次完成：新增小丽 92、修改小红为 98、删除小刚，并输出全部姓名与成绩。
字典按键存取值；直接赋值可新增或修改，pop() 按键删除，in 判断键是否存在，for 遍历得到键。
# 实训7.1：学生成绩字典
scores = {"小明": 88, "小红": 95, "小刚": 76}
print("原字典：", scores)
scores["小丽"] = 92
print("新增小丽：", scores)
scores["小红"] = 98
print("修改小红：", scores)
scores.pop("小刚")
print("删除小刚：", scores)
print("小明的成绩：", scores.get("小明"))
print("是否存在小刚：", "小刚" in scores)
for name in scores.keys():
print(name, "→", scores[name])实训7.2 单词词频统计
给定文本 "apple banana apple orange banana apple"，统计每个单词出现的次数并输出统计结果。
用 split() 拆出单词列表；遍历时若单词已在字典中则计数加 1，否则初始化为 1。
# 实训7.2：单词词频统计
text = "apple banana apple orange banana apple"
words = text.split()
count = {}
for w in words:
if w in count:
count[w] = count[w] + 1
else:
count[w] = 1
print("统计结果：", count)实训7.3 集合运算
给定集合 a = {1, 2, 3, 4, 5} 和 b = {4, 5, 6, 7, 8}，输出并集、交集、差集 A-B，并向 a 添加元素 9 后输出。
集合元素不重复、无序；union() 并集、intersection() 交集、difference() 差集，add() 添加元素，in 判断成员。
# 实训7.3：集合运算
a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}
print("A：", a)
print("B：", b)
print("并集：", a.union(b))
print("交集：", a.intersection(b))
print("差集 A-B：", a.difference(b))
a.add(9)
print("添加9后：", a)
print("4 是否在 A 中：", 4 in a)实训7.4 通讯录管理
维护通讯录字典 contacts = {"张三": "13800001111", "李四": "13900002222"}，新增联系人王五，查找张三电话，并输出联系人数与全部联系人。
字典综合应用：新增用赋值，查找用 get() 提供默认值，len() 统计条数，for 遍历输出。
# 实训7.4：通讯录管理
contacts = {"张三": "13800001111", "李四": "13900002222"}
contacts["王五"] = "13700003333"
print("新增王五：", contacts.get("王五"))
print("查找张三：", contacts.get("张三", "未找到"))
print("联系人数量：", len(contacts))
for name in contacts.keys():
print(name, "→", contacts[name])单元8 · 函数基础
def 定义、参数与返回值、默认参数、函数调用、多函数协作
- 函数定义：def 函数名(参数): 定义函数，缩进块是函数体，return 返回结果。
- 参数与返回值：调用时按位置传参；没有 return 的函数返回 None。
- 默认参数：def f(a, b=10) 中 b 有默认值，调用时可省略；默认参数必须放在末尾。
- 函数复用：把重复逻辑封装成函数，代码更清晰、便于维护与测试。
实训8.1 定义求和与问候函数
定义一个两数相加的函数 add(a, b) 和一个无参问候函数 say_hello()，分别调用并输出结果。
def 关键字定义函数，return 返回计算结果；无返回值的函数默认返回 None。
# 实训8.1：定义求和与问候函数
def add(a, b):
return a + b
def say_hello():
print("你好，Python 函数！")
say_hello()
print("3 + 5 =", add(3, 5))
print("10 + 20 =", add(10, 20))实训8.2 默认参数
定义问候函数 greet(name, greeting="你好")，第一次只传姓名调用，第二次传入姓名与问候语调用。
默认参数写在形参列表末尾，调用时不传该参数则使用默认值。
# 实训8.2：默认参数
def greet(name, greeting="你好"):
print(greeting + "，" + name + "！")
greet("小明")
greet("小红", "早上好")实训8.3 封装判断质数函数
定义函数 is_prime(n) 判断一个数是否为质数，并输出 2 到 19 之间的所有质数。
质数判断：小于 2 不是质数；从 2 试除到 √n，找到因子立即返回 False，否则返回 True。
# 实训8.3：封装判断质数函数
def is_prime(n):
if n < 2:
return False
i = 2
while i * i <= n:
if n % i == 0:
return False
i = i + 1
return True
for n in range(2, 20):
if is_prime(n):
print(n, "是质数")实训8.4 简易计算器函数
定义函数 calc(x, y, op) 根据运算符 op 返回两数的加、减、乘、除结果，并多次调用验证。
函数体内用 if / elif 判断运算符，返回对应计算结果；未知运算符返回提示信息。
# 实训8.4：简易计算器
def calc(x, y, op):
if op == "+":
return x + y
elif op == "-":
return x - y
elif op == "*":
return x * y
elif op == "/":
return x / y
else:
return "未知运算符"
print("5 + 3 =", calc(5, 3, "+"))
print("5 - 3 =", calc(5, 3, "-"))
print("5 * 3 =", calc(5, 3, "*"))
print("5 / 3 =", calc(5, 3, "/"))单元9 · 函数进阶：递归与作用域
递归思想（阶乘、斐波那契）、函数返回列表、局部变量与全局变量
- 递归：函数调用自身即为递归，必须设置终止条件，否则会无限递归。
- 递归思想：把大问题拆成同构的小问题，典型如阶乘、斐波那契。
- 返回复杂数据：函数可以返回列表、字典等任何对象，供调用方继续处理。
- 作用域：函数内赋值的变量是局部变量，与全局变量互不影响。
实训9.1 递归求阶乘
用递归实现阶乘函数 factorial(n)，输出 5! 和 10! 的结果。
递归需要终止条件：n ≤ 1 时返回 1；否则返回 n × factorial(n-1)。
# 实训9.1：递归求阶乘
def factorial(n):
if n <= 1:
return 1
return n * factorial(n - 1)
print("5! =", factorial(5))
print("10! =", factorial(10))实训9.2 斐波那契数列（递归）
用递归实现斐波那契函数 fib(n)（f(0)=0, f(1)=1, f(n)=f(n-1)+f(n-2)），输出前 10 项。
递归终止条件为 n ≤ 1 时返回 n；注意递归深度不宜过大。
# 实训9.2：斐波那契数列（递归）
def fib(n):
if n <= 1:
return n
return fib(n - 1) + fib(n - 2)
result = ""
for i in range(10):
result = result + str(fib(i)) + " "
print("前 10 项：", result)实训9.3 函数返回列表
定义函数 make_square_list(n) 返回 1 到 n 的平方组成的列表，并输出 1 到 6 的平方列表。
函数内创建空列表，用 while 循环逐个追加 i*i，最后 return 返回列表。
# 实训9.3：函数返回列表
def make_square_list(n):
result = []
i = 1
while i <= n:
result.append(i * i)
i = i + 1
return result
squares = make_square_list(6)
print("1~6 的平方：", squares)实训9.4 变量作用域演示
定义全局变量 total = 0 和函数 add_score(x)，函数内使用局部变量累加并返回；观察全局 total 是否变化。
函数内赋值的变量默认是局部变量，不影响同名全局变量；理解局部作用域与全局作用域的区别。
# 实训9.4：变量作用域演示
total = 0
def add_score(x):
local_total = x + 100
return local_total
print("函数返回值：", add_score(5))
print("全局 total 不变：", total)单元10 · 异常处理
try / except 捕获异常、类型转换异常、索引越界、除零错误、异常后的流程
- 异常处理：try 块放可能出错的代码，except 捕获异常并处理，程序不会崩溃。
- 常见异常场景：除数为 0、类型转换失败、索引越界、键不存在等都会抛异常。
- 异常后流程：try / except 之后的语句会继续执行，保证程序流程不中断。
实训10.1 捕获除零异常
定义 safe_div(a, b) 完成除法，当除数为 0 时捕获异常并返回提示 "除数不能为零"，否则返回商。
把可能出错的除法放进 try 块，用 except 捕获异常返回提示，程序不会中断。
# 实训10.1：捕获除零异常
def safe_div(a, b):
try:
return a / b
except:
return "除数不能为零"
print(safe_div(10, 2))
print(safe_div(10, 0))实训10.2 类型转换异常处理
定义 parse_num(s) 尝试把字符串转换为整数，转换失败时捕获异常并返回 "无法转换"。
int(s) 遇到非数字字符串会抛出异常，用 try / except 包裹即可安全处理。
# 实训10.2：类型转换异常处理
def parse_num(s):
try:
n = int(s)
return n
except:
return "无法转换"
print(parse_num("123"))
print(parse_num("abc"))实训10.3 列表索引越界处理
定义 get_item(lst, idx) 安全访问列表元素，索引越界时捕获异常返回 "索引越界"。
lst[idx] 在索引超出范围时抛异常；用 try / except 包裹访问逻辑。
# 实训10.3：列表索引越界处理
nums = [10, 20, 30]
def get_item(lst, idx):
try:
return lst[idx]
except:
return "索引越界"
print(get_item(nums, 1))
print(get_item(nums, 5))实训10.4 异常后的流程控制
定义 demo(x) 计算 100 整除 x 并输出结果，除数为 0 时捕获异常输出错误提示，无论是否出错都输出 "本次调用结束"。
try 块执行正常逻辑，except 处理错误，try / except 之后继续执行后续语句，保证流程不中断。
# 实训10.4：异常后的流程控制
def demo(x):
try:
r = 100 // x
print("计算结果：", r)
except:
print("发生错误：除数不能为零")
print("本次调用结束")
demo(4)
demo(0)单元11 · 常用内置函数与综合运用
len/sum/max/min/abs/pow/type/sorted 等内置函数、遍历技巧、综合统计
- 常用内置函数：len() / sum() / max() / min() / abs() / pow() / type() / sorted() 直接可用。
- sorted 排序：返回排序后的新列表，不修改原列表；配合反转可得到降序。
- 遍历技巧：while + 下标可手动控制序号，适合需要编号的输出场景。
实训11.1 sorted 排序综合
给定数字列表 [34, 12, 89, 5, 67] 和姓名列表 ["Tom", "alice", "Bob"]，分别输出排序结果。
sorted() 返回新列表，默认升序；对字符串按字符编码排序，注意大小写影响。
# 实训11.1：sorted 排序综合
nums = [34, 12, 89, 5, 67]
print("原列表：", nums)
asc = sorted(nums)
print("升序：", asc)
desc = []
for x in asc:
desc.insert(0, x)
print("降序：", desc)
names = ["Tom", "alice", "Bob"]
print("姓名排序：", sorted(names))实训11.2 带序号遍历输出
给定学科列表 subjects = ["Python", "Java", "Go", "SQL"]，按"序号. 学科名"的格式逐行输出。
用 while 循环配合下标访问列表元素，手动计算序号，避免依赖高级解包语法。
# 实训11.2：带序号遍历输出
subjects = ["Python", "Java", "Go", "SQL"]
i = 0
while i < len(subjects):
print(str(i + 1) + ". " + subjects[i])
i = i + 1实训11.3 内置函数大综合
给定列表 nums = [3, -7, 9, -2, 6]，输出绝对值、最大值、最小值、总和、幂运算结果与列表长度。
abs() 取绝对值、max()/min()/sum() 统计、pow() 幂运算、len() 求长度，全部是内置函数。
# 实训11.3：内置函数大综合
nums = [3, -7, 9, -2, 6]
print("绝对值：", abs(-5))
print("最大值：", max(nums))
print("最小值：", min(nums))
print("总和：", sum(nums))
print("幂：", pow(2, 10))
print("长度：", len(nums))实训11.4 字符串字符统计
给定文本 "hello world hello"，统计每个非空格字符出现的次数并输出统计字典。
遍历字符串中的每个字符，跳过空格；用字典记录每个字符的累计次数。
# 实训11.4：字符串字符统计
text = "hello world hello"
count = {}
for ch in text:
if ch == " ":
continue
if ch in count:
count[ch] = count[ch] + 1
else:
count[ch] = 1
print("字符统计：", count)单元12 · 综合项目实训
列表与字典嵌套、函数封装、综合业务流程
- 数据组织：用列表存多条记录、字典存单条记录的字段，嵌套结构表达真实业务。
- 函数封装：把输出、统计等逻辑封装成函数，主流程只负责调用，结构清晰。
- 综合调试：先跑通小数据再扩展；善用 print 输出中间结果定位问题。
实训12.1 学生成绩管理系统
用列表存储学生信息（每个学生是含姓名和成绩的字典），实现：遍历输出全部学生成绩、计算班级平均分。
列表元素为字典，通过 [索引]["键"] 访问数据；函数封装输出与统计逻辑，结构清晰。
# 实训12.1：学生成绩管理系统
students = [{"name": "小明", "score": 88}, {"name": "小红", "score": 95}, {"name": "小刚", "score": 72}]
def print_all():
print("===== 学生成绩表 =====")
for s in students:
print(s["name"], "→", s["score"])
def get_avg():
total = 0
for s in students:
total = total + s["score"]
return total / len(students)
print_all()
print("平均分：", get_avg())实训12.2 图书库存统计
用列表保存图书信息（书名、库存），统计图书总数与库存总量，并找出库存不足 10 本的图书。
遍历图书列表累加库存；用条件判断筛选库存不足的图书，存入新列表输出。
# 实训12.2：图书库存统计
books = [{"title": "Python入门", "stock": 12}, {"title": "Java核心", "stock": 5}, {"title": "算法图解", "stock": 20}]
total = 0
low = []
for b in books:
total = total + b["stock"]
if b["stock"] < 10:
low.append(b["title"])
print("图书总数：", len(books))
print("库存总量：", total)
print("库存不足：", low)实训12.3 猜数字小游戏（模拟输入版）
预设目标数字 42，用列表模拟多轮猜测输入，每轮提示"猜大了 / 猜小了"，猜中时输出恭喜信息并结束。
用预置猜测序列模拟玩家输入，while 循环逐轮处理，if / elif / else 给出反馈，break 结束游戏。
# 实训12.3：猜数字小游戏（模拟输入版）
target = 42
guess_list = [50, 30, 42]
i = 0
while i < len(guess_list):
guess = guess_list[i]
i = i + 1
if guess > target:
print(guess, "→ 猜大了")
elif guess < target:
print(guess, "→ 猜小了")
else:
print("恭喜！答案就是", target)
break
print("游戏结束")