学 Python 有一个很典型的焦虑期:前几章学变量、字符串、条件、循环,跟着教程能写出猜数字、九九乘法表、简易计算器,觉得自己已经入门了。到了 Masterclass 这一类长课的 Part 5,课程突然开始密集地讲函数、列表推导、lambda、文件读写、异常处理,题目的复杂度也明显跳了一级。很多人就停在这个位置,不是学不会,而是不知道该把这些东西往哪里用。
如果你正在学《Learn Python Programming Masterclass》系列,到了 Part 5 感觉有点跟不上了,这不是状态问题,而是课程在从“认识语法”切换到“组织代码”。这篇文章不会照着目录帮你把每个函数背一遍,而是围绕 Part 阶段最常见的知识边界展开:函数抽象、常用内置函数和推导式、文件读写、异常处理,以及如何用它们组合出真正能处理数据的脚本。
先说结论:Part 5 教的东西,从语言语法上看并不多,但它真正改变的是你写代码的方式。学完这一阶段,你的代码不再是一段从上到下平铺的句子,而是一组可以被复用、被理解、被维护的“积木”。本文会把每个知识点的难点、坑点和实际应用场景都拆开来讲,并配有完整可运行的示例代码。
1. 这篇文章真正要解决的问题
先别急着看函数定义和代码示例,我们先把“为什么要学 Part 5”这件事说清楚。对于绝大多数学习者,Python 入门课程的第 5 部分通常处在这样一个位置:基础语法已经讲完,面向对象还没开始,但课程希望你先拥有“结构化编程”的能力。
什么是结构化编程能力?用大白话说,就是:
- 把重复出现的代码抽出来,变成函数。
- 把一条条处理数据的逻辑,用更简洁的表达式写出来。
- 让程序在出错时不直接崩溃,而是能给出提示或优雅退出。
- 能读写外部文件,而不只是依赖用户在终端输入。
在之前的章节里,你写的代码可能是这样的:一个脚本从头写到尾,变量、循环、print 混在一起,程序能跑,但稍微改一个需求,整段逻辑就要重写。到了 Part 5,课程开始迫使你换一种写法:先定义工具函数,再调用这些函数完成具体任务。
这个转变如果只靠“看课程视频”,很难真正建立起来。因为它不是记住某个语法,而是思维习惯的改变。所以这篇文章的定位,就是帮你把 Part 5 最常见的几个主题,放到真实编写场景里重新理解。
你读完本文之后,应该能做到三件事:
- 能自己写一个带参数、带返回值、有默认参数的函数,并说清楚它解决的是哪一类“重复逻辑”问题。
- 能熟练用列表推导式、内置函数和 lambda 完成常见的数据筛选、排序、转换,而不是把所有数据处理都写成三层 for 循环。
- 能完成一个“读文件 -> 处理数据 -> 写回结果”的完整小任务,并且对乱码、文件不存在、数据格式错误这类问题有基本排查思路。
这一段的最后还要做一个判断:不要把 Part 5 的目标理解为“多学几个知识点”。它的核心训练是一种能力,一种让你从“会 Python 语法”过渡到“会用 Python 组织一个小程序”的能力。学这一部分,慢一点反而扎实。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 基础概念与核心原理
在进入代码之前,先厘清几个 Part 阶段特别容易混淆的概念。有些术语单词都认识,但组合到一起就不知道怎么回事了。
2.1 函数:不只是一段代码,而是一个“输入-处理-输出”盒子
函数(Function)是最容易被低估的 Python 特性。初学者最常见的理解是“函数就是一段可以反复调用的代码”,这个理解没有错,但它没有强调关键点:函数最重要的价值是隔离复杂度。
对于一个函数,你在外部只关心它的输入和输出,不需要每次调用都去读它的内部实现。这就像你使用一个订餐小程序:你关心的是你提交了什么信息和最终拿到什么结果,而不关心餐厅后厨到底怎么运转。
在 Python 中,函数通过 def 关键字定义,通过 return 返回值。看起来很简单,但 Part 阶段真正训练的是“如何把一个任务拆解成多个函数的组合”,而不是会写单个函数。
2.2 列表推导式:把“建一个列表”写得更直白
列表推导式(List Comprehension)是很多新人刚开始不愿意用的写法,因为觉得它“看起来不像是正经代码”。但实际上,它的语义非常清晰:根据一个规则,生成一个新的列表。
例如,要从一个列表中筛选出所有大于 0 的数字,用传统循环写需要三到四行;用列表推导式,一行就能表达完整逻辑。理解它之后,你会突然发现很多数据处理代码都变短了,而且更容易读。
2.3 lambda:没有名字的小函数
lambda 在 Part 阶段出现频率很高,因为排序、筛选时经常需要一个“临时判断规则”。它不是非要不可,但它能让你在调用 sorted() 或 filter() 时少写一个单独的函数定义。
很多教程把 lambda 讲得神乎其神,实际上它就是一个单行表达式,限制是只能写一个表达式,不能写多条语句。把它理解为“快速定义一个临时函数”的写法即可,不需要在初学阶段强行构造复杂例子。
2.4 文件读写与异常处理:程序与真实世界打交道的入口
程序不可能永远只处理内存里的数据。文件读写让程序能够持久化数据,异常处理让程序在遇到意外时不会直接崩溃。这两个概念在 Part 阶段经常会连着一起学,因为最常见的异常就来自文件操作。
下表可以帮你快速区分这几个核心概念的角色差异:
| 概念 | 核心作用 | 适合解决的场景 | 典型误区 |
|---|---|---|---|
| 函数 | 抽象重复逻辑 | 同一段计算被多次使用 | 把外部变量随意传入传出,导致函数不独立 |
| 列表推导式 | 快速构建新列表 | 过滤、转换序列数据 | 强行嵌套推导式,导致可读性暴跌 |
| lambda | 定义单行临时函数 | 排序键、简单筛选条件 | 在 lambda 中写复杂逻辑,难以调试 |
| 文件读写 | 持久化数据交换 | 日志、配置、CSV 数据处理 | 忘记指定编码,中文乱码 |
| 异常处理 | 控制错误流程 | 输入不可靠、文件不存在、格式错误 | 捕获所有异常但什么都不做 |
这个阶段最容易犯的错误,是把每种语法当成“新知识点”孤立记忆。实际上,它们经常组合在一起使用:函数内部调用文件读取,用列表推导式处理数据,再用 lambda 作为排序规则,最后在函数外部用异常处理包裹整个流程。
3. 环境准备与前置条件
在开始写代码之前,先确认环境可运行。后面所有示例都基于 Python 3,推荐使用 3.8 及以上版本。不同小版本之间的基础语法没有明显差异,但如果你正在学新版本课程,建议直接使用 3.10 或更高版本,可以避免一些变量注解、内置语法的小坑。
3.1 检查 Python 版本
在终端或命令行中执行:
bash复制python --version
如果输出的是 Python 3.8 以上,直接往下走即可。如果你同时装了 Python 2 和 Python 3,建议统一使用 python3 命令:
bash复制python3 --version
3.2 准备一个项目目录
不建议把练习文件随手丢在桌面或下载目录里,从 Part 5 开始,你应该有“一个项目一个目录”的习惯。比如建一个 python_masterclass_part5 目录,用来存放本文所有代码。
bash复制mkdir python_masterclass_part5
cd python_masterclass_part5
后续代码都建议写在这个目录下,方便统一运行和检查输出。
3.3 验证 import 基础模块
之后示例会用到 csv 模块和 statistics 模块,这两个都是 Python 标准库,不需要额外安装。可以提前验证一下环境是否正常:
bash复制python -c "import csv; import statistics; print('std lib ok')"
看到 std lib ok 就说明环境没问题。
4. 函数:把重复逻辑抽象成“工具”
这一节我们从函数开始,因为它是 Part 阶段最重要的组织单位。这里不打算逐条罗列函数的所有规则,而是带你走一遍“发现问题 -> 定义函数 -> 改进参数 -> 验证输出”的完整过程。
4.1 一个典型的重复代码场景
假设你要计算三个不同人的 BMI 指数。如果你还没有函数的概念,可能会这样写:
python复制# 文件路径:no_function.py
name = "Alice"
height = 1.65
weight = 58
bmi = weight / (height ** 2)
print(f"{name}: {bmi:.1f}")
name = "Bob"
height = 1.80
weight = 75
bmi = weight / (height ** 2)
print(f"{name}: {bmi:.1f}")
这个代码能工作,但如果要算 100 个人,就要复制 100 遍。更麻烦的是,如果 BMI 公式后面需要改成新的多因素计算,你就要去修改每一处复制出来的代码,极易漏改。
函数解决的就是这个问题:把“给定身高体重,输出 BMI”这个过程独立出来,之后只需要传参数调用。
4.2 重构为函数版本
python复制# 文件路径:bmi_function.py
def calculate_bmi(height, weight):
return weight / (height ** 2)
def print_bmi_report(name, height, weight):
bmi = calculate_bmi(height, weight)
if bmi < 18.5:
category = "偏瘦"
elif bmi < 24:
category = "正常"
else:
category = "偏胖"
print(f"{name}: BMI={bmi:.1f},{category}")
print_bmi_report("Alice", 1.65, 58)
print_bmi_report("Bob", 1.80, 75)
这个版本看起来行数没少多少,但结构发生了本质变化:
calculate_bmi只负责计算,不负责输出。print_bmi_report负责把计算和展示组合起来。- 如果后续需要改成访问数据库,只需要替换
print_bmi_report内部的实现,不需要动计算逻辑。
每个函数各司其职,这正是 Part 阶段最重要的训练目标。
4.3 默认参数与多个返回值
函数的高级一点的内容,包括默认参数和返回多个值。默认参数的意义,是让调用方在绝大部分情况下不用传入所有参数;返回多个值,则是 Python 元组(tuple)的一种应用。
python复制# 文件路径:score_tool.py
def parse_record(line):
parts = line.split(",")
name = parts[0]
score = int(parts[1])
return name, score
def add_bonus(score, bonus=5):
return score + bonus
name, score = parse_record("Alice,80")
print(f"{name} 原始分数: {score}, 加分后: {add_bonus(score)}")
这里真正容易踩坑的地方是默认参数的求值时机。默认值只在函数定义时计算一次,如果默认值是可变对象(比如列表、字典),多次调用之间会共享状态,导致结果出乎意料。
python复制# 错误示范:可变默认参数
def add_item(item, container=[]):
container.append(item)
return container
print(add_item("a"))
print(add_item("b"))
运行后会得到 ['a'] 和 ['a', 'b'],而不是各自独立的列表。正确的方案是使用 None 作为默认值,在函数内部创建新列表。
python复制# 正确示范
def add_item(item, container=None):
if container is None:
container = []
container.append(item)
return container
这一段如果你想练习,建议把课后所有的“重复代码”题目都尝试用函数重构一遍。不要满足于“能跑”,而是要观察:把逻辑抽成函数之后,主流程的阅读难度是不是下降了。
5. 列表推导式、内置函数与 lambda:让数据处理短一半
进入 Part 阶段的中段,你会大量处理列表、字典、元组这样的数据集合。这一节我们用三个层次的写法对比,来看清楚推导式和内置函数的价值。
5.1 传统循环写法
假设有一个学生成绩列表,需要把低于 60 分的成绩列出来:
python复制scores = [77, 42, 89, 55, 98, 61]
fail_scores = []
for s in scores:
if s < 60:
fail_scores.append(s)
print(fail_scores)
这段代码逻辑清晰,但略显啰嗦:先建空列表,再 append,再返回值。实际上,这整段逻辑可以压缩成一个表达式。
5.2 列表推导式写法
python复制scores = [77, 42, 89, 55, 98, 61]
fail_scores = [s for s in scores if s < 60]
print(fail_scores)
这一行代码的含义是:从 scores 中取每个元素赋给 s,在满足 s < 60 时把 s 放入新列表。它不更快,但可读性和表达力更强。尤其当你的逻辑是“根据一个序列生成另一个序列”时,推导式几乎总是最优选择。
再看一个转换场景:把一个字符串列表统一转成大写。
python复制fruits = ["apple", "banana", "cherry"]
upper_fruits = [f.upper() for f in fruits]
print(upper_fruits)
5.3 sorted 与 lambda 结合使用
排序是数据处理里最常见的操作。Python 的 sorted() 支持 key 参数,用来指定排序规则。lambda 就是在这里经常出场。
假设有一个字典列表,每个字典记录一个人的名字和年龄:
python复制people = [
{"name": "Alice", "age": 25},
{"name": "Bob", "age": 19},
{"name": "Cathy", "age": 30},
]
people_by_age = sorted(people, key=lambda person: person["age"])
for p in people_by_age:
print(f"{p['name']}: {p['age']}")
lambda 的作用,是告诉 sorted():“请用每个人字典里的 age 字段作为比较依据”。如果没有 lambda,你需要先定义一个完整的函数:
python复制def get_age(person):
return person["age"]
people_by_age = sorted(people, key=get_age)
两种写法都正确。lambda 省去了函数定义名字和稍显多余的换行,适合这种“只用一次”的排序场景。
5.4 常用内置函数速查
Part 阶段你还会频繁碰到一组内置函数,建议把它们当成“数据处理工具箱”来记:
| 函数 | 作用 | 典型用法 |
|---|---|---|
len() |
求长度 | len(scores) |
max() / min() |
求最大最小值 | max(scores) |
sum() |
求和 | sum(scores) |
sorted() |
排序,返回新列表 | sorted(scores, reverse=True) |
enumerate() |
同时获取索引和值 | for i, s in enumerate(scores) |
zip() |
并行打包多个列表 | list(zip(names, scores)) |
filter() |
按条件筛选 | list(filter(lambda x: x > 60, scores)) |
map() |
批量转换 | list(map(str.upper, fruits)) |
这里有一个使用建议:不要一看到内置函数就全部背下来。更有效的做法是先理解 len、max、sum、sorted、enumerate 这几个,因为它们几乎在每道综合练习题里都会出现。等到你处理真实文件数据,需要把名字列表和成绩列表对齐时,zip 自然就记住了。
6. 文件读写:让程序处理真实世界的数据
如果 Part 5 前面部分学的是“内存中的数据处理”,从文件读写开始,就进入“持久化数据”的领域了。很多初学者对这个主题的重视程度不够,导致后续无论学 pandas 还是写爬虫,都卡在“把数据读进来”这一步。
6.1 使用 with 语句读取文本文件
python复制# 文件路径:read_scores.py
with open("scores.txt", "r", encoding="utf-8") as f:
lines = f.readlines()
for line in lines:
print(line.strip())
关键点有两个。
第一,with 语句会自动管理文件资源,在离开代码块后自动关闭文件,不需要手动调用 f.close()。如果你用旧式写法 f = open(...),很容易忘记关闭,导致资源占用和后续写入异常。
第二,encoding="utf-8" 一定要养成习惯。如果不指定编码,Windows 系统下 Python 默认可能使用本地编码(如 gbk),读取包含中文的 UTF-8 文件时就会出现乱码或编码错误。
6.2 处理简单的 CSV 格式数据
CSV 是最常见的文本数据格式之一。下面这个例子演示手动解析简单的逗号分隔文本:
python复制# 文件路径:process_csv.py
students = []
with open("students.csv", "r", encoding="utf-8") as f:
for line in f:
line = line.strip()
if not line:
continue
parts = line.split(",")
students.append({
"name": parts[0],
"score": int(parts[1])
})
print(students)
假设 students.csv 的内容是:
text复制Alice,88
Bob,72
Cathy,55
运行后会得到一个包含三个字典的列表。这个结构非常关键,因为之后无论你是要做平均值计算、排序还是写入新文件,都会依赖这种“列表套字典”的组织方式。
6.3 把处理结果写回文件
写入文件时,最需要注意的是换行符。write() 不会自动加换行,你需要显式在字符串末尾写 \n,或者使用 print(..., file=f)。
python复制# 文件路径:write_results.py
results = ["Alice: 88", "Bob: 72", "Cathy: 55"]
with open("results.txt", "w", encoding="utf-8") as f:
for item in results:
f.write(item + "\n")
with open("results.txt", "r", encoding="utf-8") as f:
content = f.read()
print(content)
这段代码先写入三行,再读出来打印。如果输出是三行独立的名字和分数,说明文件读写流程已经通了。
6.4 从 CSV 到 DataFrame 的路标
不少同学学到这里时会问:为什么要手动 split,不是有 pandas 的 read_csv 吗?
答案是:Part 5 阶段教你手动处理文件,目的不是让你以后一直用 split,而是让你理解底层的数据格式边界在哪里。如果你以后学 pandas,用 pd.read_csv() 读完 DataFrame,遇到清洗、筛选、排序时,底层操作的对象依然是“行”和“列”的逻辑,只是封装得更高级了。热搜词里频繁出现 DataFrame、numpy、matplotlib,这些是后续课程的范畴,但不影响现在把基本功打牢。
7. 异常处理:程序不崩的最后一层防线
程序出现错误不可怕,可怕的是错误发生后,程序直接中断,用户不知道发生了什么,日志里也没有任何有效信息。异常处理让程序在出错时能够“接住”问题,并给出一段可读的提示。
7.1 最简单的 try-except 结构
python复制# 文件路径:safe_divide.py
def safe_divide(a, b):
try:
result = a / b
except ZeroDivisionError:
print("错误:除数不能为 0")
return None
except TypeError:
print("错误:请输入数字")
return None
else:
return result
finally:
print("本次计算完成")
print(safe_divide(10, 2))
print(safe_divide(10, 0))
print(safe_divide(10, "a"))
运行后你会看到,程序没有崩溃,而是正常执行完毕并打印了错误提示。这里有几个关键字值得注意:
except ZeroDivisionError:只捕获除零错误,避免把所有错误都吞掉。else:在没有异常时执行,表示“处理成功之后的动作”。finally:不管是否异常都会执行,适合做资源清理、日志记录。return None:在异常时返回一个空值,调用方可以据此判断处理失败。
只捕获特定异常,是一项非常重要的工程习惯。很多初学者喜欢使用裸的 except: 或 except Exception:,捕获所有异常。这样写虽然程序不会崩,但会把程序内部的问题隐藏起来,导致你完全不知道哪里错了。
7.2 在文件读取中使用异常处理
文件操作是异常的多发场景,常见有:文件不存在、权限不足、编码错误、格式不合法。
python复制# 文件路径:safe_read_file.py
def read_numbers(filename):
try:
with open(filename, "r", encoding="utf-8") as f:
lines = [line.strip() for line in f if line.strip()]
except FileNotFoundError:
print(f"错误:找不到文件 {filename}")
return []
except UnicodeDecodeError:
print(f"错误:文件编码不是 UTF-8,请检查 {filename}")
return []
return lines
data = read_numbers("numbers.txt")
print(f"读取到 {len(data)} 行")
这个函数的设计思路是:文件读取出错时,不抛出异常中断主程序,而是返回一个空列表。调用方在看到空列表之后,可以决定是否继续执行。
7.3 判断异常该不该吞掉
异常处理不是越多越好。最佳实践是:可预期的、能恢复的异常用 try-except 捕获;不可预期的、代表程序内部 bug 的错误,应该让它抛出,方便在开发阶段发现。
比如读取用户输入并转换成整数,这是一个可预期的错误,应该捕获 ValueError。但如果某个变量的类型和你预期完全不一致,那说明代码逻辑有问题,捕获后写一个 pass 或 print 只会把问题藏起来。
常见异常类型可以参考下表:
| 异常类型 | 触发场景 | 处理建议 |
|---|---|---|
ValueError |
类型正确但值不合法,例如 int("abc") |
捕获后提示用户重新输入 |
TypeError |
类型不匹配,例如数字与字符串相加 | 检查变量类型 |
FileNotFoundError |
文件不存在 | 捕获后返回默认值或提示路径 |
UnicodeDecodeError |
文件编码与指定编码不一致 | 尝试用其它编码重新读取 |
KeyError |
字典中不存在该键 | 用 get() 方法代替直接下标访问 |
8. 完整示例:做一个“成绩统计小工具”
前面的知识点如果只单独练习,很难形成整体概念。这一节用一个综合示例,把函数、列表处理、文件读写、异常处理和排序全部串起来。
假设现在有一个文本文件 all_scores.csv,每行是一条学生成绩记录,格式为 姓名,成绩。我们的目标是:
- 读取文件,跳过空行和格式不正确的行。
- 计算这些成绩的平均分。
- 按成绩从高到低排序。
- 把排序结果和平均分写入一个新的结果文件
report.txt。
python复制# 文件路径:score_report.py
from statistics import mean
def parse_lines(lines):
students = []
for line in lines:
line = line.strip()
if not line:
continue
parts = line.split(",")
if len(parts) != 2:
print(f"跳过无法解析的行: {line}")
continue
try:
name = parts[0]
score = int(parts[1])
except ValueError:
print(f"跳过成绩格式错误行: {line}")
continue
students.append({"name": name, "score": score})
return students
def load_students(filename):
try:
with open(filename, "r", encoding="utf-8") as f:
lines = f.readlines()
except FileNotFoundError:
print(f"错误:文件 {filename} 不存在")
return []
return parse_lines(lines)
def build_report(students):
if not students:
return "没有有效成绩数据"
avg_score = mean(s["score"] for s in students)
sorted_students = sorted(students, key=lambda s: s["score"], reverse=True)
report_lines = []
report_lines.append(f"学生人数:{len(students)}")
report_lines.append(f"平均成绩:{avg_score:.1f}")
report_lines.append("成绩排名:")
for rank, student in enumerate(sorted_students, start=1):
report_lines.append(f"{rank}. {student['name']}: {student['score']}")
return "\n".join(report_lines)
def save_report(report, filename):
with open(filename, "w", encoding="utf-8") as f:
f.write(report + "\n")
students = load_students("all_scores.csv")
report = build_report(students)
print(report)
save_report(report, "report.txt")
print("\n报告已写入 report.txt")
运行方式:
bash复制python score_report.py
假设 all_scores.csv 内容是:
text复制Alice,88
Bob,72
Cathy,55
David,91
Eve,64
预期输出会包含类似下面的结果:
text复制学生人数:5
平均成绩:74.0
成绩排名:
1. David: 91
2. Alice: 88
3. Bob: 72
4. Eve: 64
5. Cathy: 55
报告已写入 report.txt
这个示例的关键价值在于:每一步都是前面讲过的知识点,但组合起来就变成了一个可以真正处理文件的实用工具。你可以试着替换输入文件的内容、增加一个新的统计维度(比如按分数段分组),来检验自己对流程的理解。
9. 常见问题与排查思路
Part 阶段的学习者会频繁遇到下面这些问题。如果你运行示例代码时出错,可以先对照这个表格排查。
| 问题现象 | 可能原因 | 排查方式 | 解决方案 |
|---|---|---|---|
函数调用后返回 None |
函数内部没有写 return,或 return 没有返回值 |
检查函数所有分支是否都有 return |
在没有返回值的函数中明确返回 None 或返回一个计算结果 |
| 列表推导式报语法错误 | 条件部分的 if 位置写错 |
对照标准格式检查表达式顺序 | 格式固定为 [表达式 for 变量 in 序列 if 条件] |
| 文件读取后中文乱码 | 文件编码不是 UTF-8,或者读取时未指定编码 | 用文本编辑器查看文件编码 | 统一使用 encoding="utf-8";若原文件是 gbk 则改为 encoding="gbk" |
| 文件不存在导致程序崩溃 | 没有处理 FileNotFoundError |
查看报错堆栈中的文件路径 | 用 try-except 捕获异常,或先用 os.path.exists 判断 |
| 排序结果不符合预期 | sorted() 排序方向反了,或 key 写错 |
检查 reverse 参数,打印中间排序结果 |
升序默认;降序加 reverse=True;确认 key 返回的是目标字段 |
ValueError: invalid literal for int() |
文件中存在非数字字符 | 打印出触发错误的行 | 在 int() 外层加 try-except,跳过脏数据 |
| 使用默认参数列表导致函数状态共享 | 可变默认参数在定义时被计算一次 | 打印多次调用结果,观察列表不断增长 | 默认值设为 None,在函数体内重新创建列表 |
| 裸 except 导致错误被隐藏 | 捕获了所有异常但没有处理逻辑 | 去掉裸 except,在开发环境重现错误 | 只捕获可预期的异常类型,其余让程序主动暴露 |
如果你的程序报错时带着一个完整的堆栈信息(traceback),最有效的排查流程是:先读最后一行看异常类型,再往上看是哪一行代码触发,最后看调用链上的参数是否合理。大部分问题不需要搜索引擎,日志里已经写得很清楚了。
10. 最佳实践与工程建议
Part 5 学完之后,你会发现课程布置的练习题开始有了“工程量”:不再是单独的语法题,而是要求你组合多个知识点的综合题。这时候,提前建立一些工程习惯会让后续学习顺畅很多。
10.1 命名规范与代码组织
- 函数名使用小写字母加下划线,例如
calculate_average,不要使用大写或拼音缩写。 - 变量名要反映含义,
stus不如students,lst不如score_list。 - 一个函数只做一件事。如果一个函数既读文件、又算平均分、又打印报告,把它拆成三个函数。
- 主流程代码放在文件底部,函数定义放上面。这样从上往下读文件,就像在读一个故事:先看到有什么工具可用,再看到怎么用。
10.2 数据处理时的防御性写法
- 读文件时始终指定编码,优先使用
utf-8。 - 对用户输入或外部文件数据,不要盲目转换类型,先检查格式,再
int()/float()。 - 使用
dict.get(key, default)代替dict[key],避免KeyError。 - 排序、筛选、转换数据时,先在小数据量上验证,再应用到整个数据集。
10.3 日志与验证思路
Part 阶段不需要引入复杂的日志库,但可以养成分阶段输出中间结果的习惯。比如你写完一个函数,不要急着组合全部流程,而是先单独调用这个函数,打印输出检查是否正确,再做下一步。
“小步验证”是这阶段最重要的调试方式。很多学员写一个大脚本,运行一报错,就不知道是读文件问题、解析问题、计算问题还是输出问题。如果你每一步都验证过,定位错误只需要看最新的那几行改动。
10.4 后续学习方向
- 继续用手动方法练习更多数据结构,比如用字典做词频统计、用嵌套列表保存二维数据。
- 深入练习模块与包:把工具函数放进单独
.py文件,在主文件中import。 - 接触面向对象:当你觉得函数参数太多、数据关联太松散时,就是该学类(class)的时机。
- 数据方向可以开始了解 pandas 的
DataFrame,中文乱码、CSV 格式、索引这些知识,在 Pandas 中同样适用。 - 自动化方向可以练习用
requests拉取网页文本,但前提是先把本地文件的读写和字符串处理练熟。
11. 一个值得记很久的提醒
最后说一个不那么像教程的提醒:Part 5 这个阶段,最忌讳的是“看懂了”就跳过。所有的知识点,从语法层面看都简单,但组合起来,考查的是你能不能在没有提示的情况下完成一个完整任务。
建议你按这个顺序检验自己的掌握程度:
- 不看教程,写一个函数:接收两个整数,返回它们的最大公约数。
- 写一个列表推导式:从一个 1 到 100 的整数范围中,筛出既是偶数又是 3 的倍数的数字。
- 读一个 CSV 文件,计算每门科目的平均分,按平均分写回一个新文件。
- 给上面第 3 步的程序加上异常处理,保证输入文件缺失时程序不会崩溃。
如果这四步都能独立完成,Part 5 的核心目标已经达成,后面的学习会顺利很多。如果某一步卡住,回去重读对应章节,多做两道练习题再继续。学 Python 不是比谁速度快,而是比谁把基础结构记得扎实。Part 5 的“慢”,恰恰是后面所有复杂项目的“快”。
