Python 大数据分析基础 · 第 6 次课

第 6 章 文件与目录操作

文件与编码 · 打开与关闭 · 读写与文件指针 · CSV 文件操作 · 目录常用操作 · 文件操作综合应用 · AI 语料文件(7 个知识模块 + 39 段实测代码 + 21 张插图 + 12 个动态演示图 + 6 个交互面板)

中华女子学院4 学时(讲授 1 + 上机 3)授课人:孙琪翔第 8 周
导

本讲导览

Lesson Overview · 从"程序一关数据就没了"到"数据能留下来、还能给别人用"

前面五章写的程序,数据都在内存里:变量、列表、字典、对象,程序一结束就全部蒸发。想让数据活下来,只有一条路——把它写到磁盘上的文件里。这一章就干这件事:先弄清"文件到底是什么"(一堆字节,加上一套编码规则),再学会用 open() 打开它、读它、写它、关掉它,然后处理最常见的表格数据格式 CSV,最后学会在目录里翻找文件、批量处理。

这一章还有一个特殊地位:它是后面所有数据分析的地基。第 7 章 NumPy、第 8 章 Pandas、第 9 章可视化,第一步永远是"把数据从文件里读进来"。文件读不进来,后面全白搭。

本课主线:数据在"磁盘"和"内存"之间来回走 磁盘 · 文件 data1.txt user_info.csv 本质:一长串字节 程序关掉也还在 内存 · 程序 字符串 / 列表 / 字典 / 对象 本质:字符、数值 程序一结束就清空 结果 · 再落盘 排序结果、统计报表 同事 / 下一章能接着用 这才是"持久保存" open + read 解码 decode write 编码 encode 无论读写什么文件,程序里永远是这四步 ① 打开 open() 选模式 r / w / a ② 读写 read / write 文件指针跟着动 ③ 关闭 close() with 自动帮你关 ④ 内容落盘 别人打开才能看见
本课知识主线:磁盘上的字节——读取时解码成字符——程序里加工——写入时编码回字节——再落到磁盘

四节课时怎么排

第 1 讲 · 45 分钟
文件基本操作
文件与编码 · open 的三个参数 · 模式 r/w/a/x · close 与 with · read / write / tell / seek
上机一 · 45 分钟
把数据读进来
四种读法对照 · 例 6-1 商品类别码 · 逐行读大文件 · 编码踩坑排查
上机二 · 45 分钟
CSV 与目录
csv.writer / reader · 例 6-4 写 user_info.csv · 例 6-5 求最高工资 · os 目录函数 · 遍历目录树
上机三 · 45 分钟
综合应用
例 6-6 短文长度 · 例 6-7 成绩合并排序写文件 · 日志分析 · 批量处理 · AI 语料文件
学习目标:① 说清文本文件与二进制文件的区别,知道 '你好' 在 UTF-8 下是几个字节;② 会用 open(file, mode, encoding) 的三种主要模式打开文件,知道 w 会清空、a 会追加;③ 会用 read / readline / readlines / for line in f 四种方式读文件,会用 write / writelines 写文件;④ 理解文件指针,会用 tell() 和 seek();⑤ 推荐一律用 with,不再手动 close();⑥ 会用 csv 标准库读写 CSV 文件,记得写 newline='';⑦ 会用 os 模块的 getcwd / listdir / mkdir / rmdir / scandir 和 os.path 系列,能写一个递归遍历目录树的函数;⑧ 能把"读数据 — 处理 — 写结果"串成一个完整程序。

本课地图

本章知识点总览

点击节点可跳转到对应讲解位置,点击三角可展开 / 收起分支。

第 6 章 文件与目录操作
▶文件与编码模块一
文件是什么:数据持久存储的抽象
文本文件与二进制文件
常见文件格式与对应的 Python 库
编码:字符与字节之间的翻译官
▶打开与关闭模块二
open(file, mode, encoding) 的三个参数
打开模式:r / w / a / x / b / t / +
路径与转义:r"" 原始字符串、os.path.join
close() 与 with:别让文件漏着
▶读写与文件指针模块三
读:read / readline / readlines / for line in f
写:write / writelines
文件指针:tell() 与 seek()
例 6-1:商品类别码统计
文件对象方法总表
▶CSV 与目录操作模块四·五
CSV 是什么、长什么样
csv.writer:writerow / writerows
csv.reader:每行是一个字符串列表
例 6-4 写入、例 6-5 求最高工资
DictReader / DictWriter(选学)
os 模块的目录函数表
getcwd / chdir / listdir
mkdir / makedirs / rmdir
scandir 与 os.path 判断
递归遍历目录树与 pathlib
▶综合应用与 AI 渗透模块六·七
例 6-6:统计英文短文长度
例 6-7:成绩合并 → 排序 → 写文件
日志分析与批量处理
上机任务清单
jsonl:大模型语料的存储格式
训练日志:追加写与落盘
读词表、读配置、遍历数据集
文件操作在 AI 工程里的位置
说明:本章依据课程课件《6-文件与目录操作》与《Python 编程与数据分析基础》(陈洁、刘姝,清华大学出版社)第 6 章整理,并与教学进度表「CH6 Python 文件与目录操作:文件基本操作 · csv 文件操作 · 目录常用操作 · 文件操作综合应用(讲授 1 + 上机 3 = 4 学时)」对齐。页面中每段代码都是真实运行后回填的结果,运行结果默认隐藏,点"运行"才显示。
先记住三句话:① 文件就是磁盘上的一串字节,"看得懂"是因为用了正确的编码去解它;② 打开文件用 open(路径, 模式, 编码),模式 r 读、w 清空重写、a 追加;③ 一律用 with open(...) as f:,代码块一结束文件自动关——这是唯一推荐的写法。
最容易栽的三个坑:① 写完忘记 close()(或没用 with),内容还在缓冲区,文件里居然是空的;② Windows 上写 CSV 不加 newline='',每行之间凭空多一个空行;③ 用 gbk 打开一个 utf-8 的文件(或反过来),中文字符变成一堆乱码或直接 UnicodeDecodeError。这三条本章都会逐个用代码演示出来。
一

文件与编码 本章起点

文件是什么 · 文本文件与二进制文件 · 常见格式与对应库 · 字符编码 UTF-8 / GBK / ASCII

前五章写的程序有一个共同点:数据都放在变量里。变量活在内存中,程序一结束、电脑一关机,内存里的东西就没了。想让数据"活到下一次运行",只有一条路——写进文件。这一章从这个最简单的动作开始,然后把"打开、读写、关闭"三件事一件件讲透。

1.1 文件是什么

课件给的定义是:文件是数据的抽象和集合,是数据持久存储的重要方式。这句话可以拆成两个关键词来理解——抽象:磁盘上那堆 0 和 1 怎么排我们不用管,Python 给它们包了一层统一的东西叫"文件",你只管按名字打开、按内容读写;持久:数据从内存搬到磁盘,程序退出、机器重启都还在,而且能被别的程序再读出来(今天写的 csv,明天 Excel 和 pandas 都能打开)。

所以"用程序操作文件"永远是三步:① 打开文件——指定路径和名字,拿到一个文件对象;② 通过这个对象读写内容;③ 关闭文件——把缓冲区里的内容真正保存到磁盘。后面两个模块,就是把这三步拆开讲。

文件 = 把数据从内存搬到磁盘 内存(RAM)· 程序运行的时候 nums = [1001, 1002, 2001] 程序一结束,内存就被回收 变量 nums 消失 → 数据没了 换台电脑、换个程序,更拿不到 写入 write 落盘 磁盘文件 data1.txt 1001,1002,2001 关机、重启、过一星期都还在 下次打开程序 → 读回来 别的程序(Excel / pandas)也能读 操作固定三步:① 打开文件 → ② 读 / 写内容 → ③ 关闭文件(保存)
图 6-1 内存是"工作台",文件是"仓库"——数据只有写进文件,才能留到下一次运行
一句话记住:内存是工作台,文件是仓库。工作台上摆着正在处理的数据,仓库里存着要留到明天的数据。open() 是去仓库取货,close() 是把货放回仓库——中间那次"读写"就是干活。
✅ 本节小结:文件是数据的持久存储;程序结束内存清空,写进文件的数据不丢,还能在不同程序之间共享。操作文件永远三步:打开 → 读写 → 关闭。

1.2 文本文件与二进制文件

磁盘上的文件千千万,按"数据怎么组织"只分两类。这个区分非常实用:决定了你用什么模式打开、看到的到底是什么类型的数据。下面的表把两类文件放在一起对照。

对比项文本文件二进制文件
存的是什么字符串(str)字节串(bytes)
编码采用单一特定编码(如 UTF-8)没有"文本编码"概念,要按各自的格式解码
行的概念由若干文本行组成,每行以换行符 \n 结尾没有行,只有一长串字节
常见扩展名.txt .csv .py .json .md.jpg .png .mp3 .mp4 .exe .docx
记事本能看懂吗能直接查看、编辑看不懂(乱码),甚至打不开
打开方式open(path, 'r', encoding='utf-8')open(path, 'rb')

课件里那句"二进制文件需要进行解码之后才能正确显示、修改或执行"说的就是这个意思:一张 jpg 里没有"字符串",只有按 JPEG 格式排好的字节;想看到图,得让图片查看器按 JPEG 规则去解码。而 txt 里存的就是文字本身,只要知道它用的是哪种编码,就能翻译回人能读的字符。下图把两类文件的"内部长相"画出来。

同样叫"文件",里面装的东西不一样 文本文件(txt / csv / py …) 存的是字符串,采用单一特定编码(如 UTF-8) 由若干文本行组成,每行以换行符 \n 结尾 记事本可以直接打开、看懂、编辑 你好,Python 文件里是 UTF-8 字节,文本模式读 → 自动解码成 str 打开方式:open(path, 'r', encoding='utf-8') 二进制文件(jpg / mp3 / mp4 / exe …) 存的是字节串,没有"行"的概念 必须先知道格式 / 编码,才能解码 记事本打开是乱码,图片视频要专用软件 b'\xe4\xbd\xa0\xe5\xa5\xbd' b'\xff\xd8\xff\xe0\x00\x10JFIF' 打开方式:open(path, 'rb') 判断方法:记事本能不能看懂,以及用哪个模式打开('r' 文本 / 'rb' 二进制)
图 6-2 文本文件存"字符",二进制文件存"字节"——打开模式必须跟着数据走

光看图不够直观。下面这段代码做一件事:把同一段中文写进文件,先用文本模式读它,再用二进制模式('rb')读它,看同一个文件给出的两种答案。

同一个文件、两种读法:文本模式读成 str,二进制模式读成 bytes
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'data1.txt')
    with open(path, 'w', encoding='utf-8') as f:
        f.write('你好')

    with open(path, encoding='utf-8') as f:
        print('文本模式读到:', repr(f.read()))

    with open(path, 'rb') as f:
        raw = f.read()
    print('二进制模式读到:', raw)
    print('字节数:', len(raw))
运行结果(实测)
文本模式读到: '你好'
二进制模式读到: b'\xe4\xbd\xa0\xe5\xa5\xbd'
字节数: 6
看输出里的两个细节:① 文本模式读到的 '你好' 是 str,len 是 2(两个字符);② 二进制模式读到的 b'\xe4\xbd\xa0\xe5\xa5\xbd' 是 bytes,每个 \xe4 这样的是一个字节——"你好"两个字在 UTF-8 下占 6 个字节(一个汉字 3 字节)。同一个文件,模式不同,交到你手里的东西就不同。
✅ 本节小结:按数据的组织形式,文件分文本文件(存字符串、单一编码、按 \n 分行、记事本能看懂)和二进制文件(存字节串、要按格式解码、记事本看不懂)。文本用 'r' 打开,二进制用 'rb' 打开。

1.3 常见文件格式与对应的 Python 库

课件第 4 页那张表想说明一件事:文件格式不同,处理它的库就不同。txt 最省事,Python 内置的 open() 就能读写;到了 Excel、Word,就得请专门的库出马。下表按课件内容重绘,加了一列"本课用不用"。

文件类型扩展名需要的 Python 库本课用不用
纯文本.txt不需要其它库,内置 open() 就够重点
CSV 表格.csvcsv(标准库)、pandas重点
Excel 工作簿.xls / .xlsxxlrd、xlwt、openpyxl、pandas后续课程
Word 文档.docxdocx(python-docx)后续课程
JSON 数据.jsonjson(标准库)下一模块
MySQL 数据库—(不是文件)pymysql后续课程
别被这张表吓到:Excel、Word、数据库的库都要另外安装(pip install),本课不装。它们背后的读写思路完全一样——先打开,再读或写,最后关闭。把 txt 和 csv 这两个"纯文本"玩熟了,以后换格式只是换库名。
本课的主线:先把纯文本文件(.txt)的打开、读写、关闭彻底搞清楚,再学 CSV(它本质就是"用逗号排版的纯文本"),最后用 os 模块管目录。一路都只用标准库。
✅ 本节小结:文件格式不同,处理它的库不同——txt 用内置 open(),csv 用标准库 csv 或 pandas,Excel 用 xlrd / xlwt / openpyxl / pandas,Word 用 docx,JSON 用 json,MySQL 用 pymysql。但"打开 → 读写 → 关闭"的思路是通用的。

1.4 编码:字符与字节之间的翻译官

计算机里只有 0 和 1,也就是字节;而我们写进程序的是字符("你"、"好"、"A")。把字符变成字节叫 编码 encode,把字节变回字符叫 解码 decode。同一个字符,用不同编码翻译出来的字节可能完全不同——这就是编码问题的根源。

encode:字符 → 字节;decode:字节 → 字符 字符(str) 你好 encode('utf-8') e4 bd a0 e5 a5 bd 6 字节 字符(str) 你好 encode('gbk') c4 e3 ba c3 4 字节 b'\xe4\xbd\xa0\xe5\xa5\xbd'.decode('utf-8') → '你好' 用错编码去解码 → 乱码或 UnicodeDecodeError;用 ASCII 编中文 → UnicodeEncodeError
图 6-3 同一个"你好",UTF-8 是 6 个字节,GBK 是 4 个字节——encode / decode 必须用同一本"字典"

常用编码就三种,记住它们的差别:

编码一个英文字母 / 数字一个汉字说明
ASCII1 字节编不了(报错)只覆盖 128 个西文字符,早期标准
UTF-81 字节3 字节国际通用,文件与网页的默认选择
GBK1 字节2 字节中文 Windows 的老编码,国内旧文件常见
配套视频黑马程序员 · 第 85 讲 文件编码概念B站 · 讲清字符、字节、编码的关系,配合本节图示看
同一句话编两次:UTF-8 与 GBK 的字节数和内容都不同
s = '你好'
b8 = s.encode('utf-8')
bg = s.encode('gbk')

print('字符数:', len(s))
print('UTF-8 编码:', b8)
print('UTF-8 字节数:', len(b8))
print('GBK 编码:', bg)
print('GBK 字节数:', len(bg))
print('解码回字符:', b8.decode('utf-8'), bg.decode('gbk'))
print('字母 A 的 ASCII 字节:', 'A'.encode('ascii'))
运行结果(实测)
字符数: 2
UTF-8 编码: b'\xe4\xbd\xa0\xe5\xa5\xbd'
UTF-8 字节数: 6
GBK 编码: b'\xc4\xe3\xba\xc3'
GBK 字节数: 4
解码回字符: 你好 你好
字母 A 的 ASCII 字节: b'A'
🎬 动态演示:字符 → 字节:编码与解码是两条相反的路

编码用错只有两种下场,代码都会直接告诉你。先看解码用错:把 GBK 的字节当成 UTF-8 去解。

用错编码解码:GBK 字节交给 UTF-8 → UnicodeDecodeError
gbk_data = '你好'.encode('gbk')
utf8_data = '你好'.encode('utf-8')

print('GBK 字节:', gbk_data)
print('UTF-8 字节:', utf8_data)
print('用 GBK 解码自己:', gbk_data.decode('gbk'))
print('用 UTF-8 去解 GBK 的字节:', gbk_data.decode('utf-8'))
运行结果(实测)
GBK 字节: b'\xc4\xe3\xba\xc3'
UTF-8 字节: b'\xe4\xbd\xa0\xe5\xa5\xbd'
用 GBK 解码自己: 你好
Traceback (most recent call last):
  File "<pyshell>", line 7, in <module>
    print('用 UTF-8 去解 GBK 的字节:', gbk_data.decode('utf-8'))
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc4 in position 0: invalid continuation byte

再看编码用错:ASCII 只能表示 128 个西文字符,拿它编汉字必然失败。

用错编码编码:ASCII 编中文 → UnicodeEncodeError
print('Hello 的 ASCII 字节:', 'Hello'.encode('ascii'))
print('数字与符号:', '2026, ok!'.encode('ascii'))
print('英文标点也行:', '!?,.:;'.encode('ascii'))
print('一共几个字节:', len('Hello'.encode('ascii')))
print('下面换中文——')
print('你好'.encode('ascii'))
运行结果(实测)
Hello 的 ASCII 字节: b'Hello'
数字与符号: b'2026, ok!'
英文标点也行: b'!?,.:;'
一共几个字节: 5
下面换中文——
Traceback (most recent call last):
  File "<pyshell>", line 6, in <module>
    print('你好'.encode('ascii'))
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
实操铁律:读写两边编码必须一致。写文件时用 encoding='utf-8',读的时候也要写 encoding='utf-8';如果文件是别人用 GBK 存的(比如从 Excel 导出的中文 csv),读的时候就必须写 encoding='gbk'。Windows 上 Python 的"默认编码"不一定是 UTF-8,所以永远显式写出 encoding,别偷懒。
✅ 本节小结:encode 把字符变成字节,decode 把字节变回字符,两边必须用同一种编码。同一个"你好",UTF-8 是 6 字节、GBK 是 4 字节、ASCII 根本编不了汉字。编码用错 → UnicodeDecodeError / UnicodeEncodeError,所以读写文件时显式指定 encoding。
二

打开与关闭 重点

open() 三个参数 · r / w / a / x / b / t / + 打开模式 · 路径与转义 · close() 与 with

文件操作的第①步和第③步都在这个模块里。别小看"打开"——模式选错,文件可能被清空;别小看"关闭"——忘了 close(),写进去的内容可能还在缓冲区里没落盘。这一节把这两个动作的坑一次讲全。

2.1 open() 的三个参数

open(file, mode, encoding) 的功能是打开文件并返回一个文件对象。三个参数各自管一件事,缺省值记牢:mode 默认是 'rt'(只读文本),encoding 在 Windows 上不建议依赖默认值。

open(file, mode, encoding):三个参数各管什么 f = open(file, mode, encoding) file:路径 + 文件名 当前目录:只写文件名 其它目录:要带完整路径 例:r'D:\test.txt' mode:打开模式 默认 'rt'(只读文本) r / w / a / x + b / t / + 决定指针位置与能否写 encoding:字符编码 常用 'utf-8'、'gbk' 读写文本时要指定 读写两边要一致 open() 成功 → 返回一个文件对象 f 之后所有读写都通过 f 完成:f.read() / f.write() / f.seek() / f.close()
图 6-4 open() 的三个参数与返回值:file 说"打开谁",mode 说"怎么开",encoding 说"用哪本字典翻译"

如果指定的文件不存在、访问权限不够、磁盘空间不足或者别的原因导致创建文件对象失败,open() 会直接抛出异常。所以打开文件这件事,最好放在 try 里,或者至少心里有数——下面这段代码就是"只读打开一个不存在的文件"的真实下场。

打开一个不存在的文件:open() 直接抛 FileNotFoundError
import os

name = 'chpt6_not_exist.txt'
print('这个文件存在吗?', os.path.exists(name))
f = open(name, encoding='utf-8')
print(f.read())
运行结果(实测)
这个文件存在吗? False
Traceback (most recent call last):
  File "<pyshell>", line 5, in <module>
    f = open(name, encoding='utf-8')
FileNotFoundError: [Errno 2] No such file or directory: 'chpt6_not_exist.txt'
为什么报错信息里只有文件名、没有一长串路径?因为这里给的是相对路径——"当前工作目录下的 chpt6_not_exist.txt"。相对路径是相对程序运行时所在的目录,不是相对你写代码的那个文件。找不到文件时,先 os.getcwd() 看清当前在哪,再决定用相对路径还是完整路径。
✅ 本节小结:open(file, mode, encoding) 打开文件并返回文件对象。file 是路径 + 文件名(同目录只写文件名);mode 默认 'rt';encoding 常用 UTF-8 / GBK。文件打不开(不存在、没权限、磁盘满)→ 抛异常,其中最常见的是 FileNotFoundError。

2.2 打开模式:r / w / a / x / b / t / +

模式决定三件事:能不能读、能不能写、文件不存在时怎么办,还有一件容易忽略的——指针一开始在哪。下表按课件重绘,最后两列是考试和实操最常考的地方。

模式含义文件不存在时已有内容指针初始位置
r只读(默认)抛 FileNotFoundError保留文件开头
w只写新建文件清空重写文件开头
a追加写新建文件保留,写在末尾文件末尾
x独占新建新建文件抛 FileExistsError文件开头
t文本模式(默认)与 r / w / a 组合,如 'rt'—按字符计
b二进制模式与 r / w / a 组合,如 'rb'—按字节计
+可读可写与 r / w / a 组合,如 'r+'—文件开头
🎬 动态演示:r / w / a 打开文件后,指针在哪、文件会怎样

光看表格记不住,跑两段代码就明白了。第一段演示 w 的"先清空再写":同一个文件,第二次用 'w' 打开,第一次写的东西就没了。

w 模式会把原内容清空:先写"第一版",再用 w 打开后只剩"第二版"
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'data1.txt')
    with open(path, 'w', encoding='utf-8') as f:
        f.write('第一版:Tom, Linda, Jack')
    with open(path, encoding='utf-8') as f:
        print('第一次写完:', f.read())

    with open(path, 'w', encoding='utf-8') as f:
        f.write('第二版')
    with open(path, encoding='utf-8') as f:
        print('w 再打开后:', f.read())
运行结果(实测)
第一次写完: 第一版:Tom, Linda, Jack
w 再打开后: 第二版

第二段是 a 的"接着末尾写"。写日志、连续追加数据全靠它——同样一句 'a',不会碰原来的一行字。

a 模式从末尾追加:三次打开,三行都在
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'log.txt')
    with open(path, 'w', encoding='utf-8') as f:
        f.write('第 1 行:程序启动\n')
    with open(path, 'a', encoding='utf-8') as f:
        f.write('第 2 行:开始处理\n')
    with open(path, 'a', encoding='utf-8') as f:
        f.write('第 3 行:处理完成\n')
    with open(path, encoding='utf-8') as f:
        print(f.read())
运行结果(实测)
第 1 行:程序启动
第 2 行:开始处理
第 3 行:处理完成
配套视频黑马程序员 · 第 89 讲 文件的追加写入操作B站 · 配合本节 a 模式演示看
w 是本章最"危险"的一个字母。它一打开文件就把内容清空,写不写都先清。所以:只想读就用 r,想在末尾接着写就用 a,只有确实要整个重写时才用 w。另外 b 与 t 不能同时出现在模式里('rbt' 是错的),二进制模式也别写 encoding。
✅ 本节小结:r 只读、文件不在就报错;w 清空重写、文件不在就新建;a 从末尾追加、文件不在就新建;x 独占新建、已存在就报错;t 是文本(默认)、b 是二进制、+ 表示可读可写。模式不同,指针初始位置和文件内容都会不同。

2.3 路径与转义:r"" 原始字符串

Windows 的路径分隔符是反斜杠 \,而 Python 字符串里 \ 是转义符(\n 是换行、\t 是制表符)。所以 "D:\test.txt" 里的 \t 会被当成制表符,路径就错了。解决方式有两种:写两个反斜杠 "D:\\test.txt",或者在字符串前加 r 变成原始字符串 r"D:\test.txt"。更稳的做法是用 os.path.join() 拼路径,让 Python 自己处理分隔符。

路径的三种写法和拆分:转义、原始字符串、os.path.join
import os

print('反斜杠要转义:', 'chpt6\\data\\test.txt')
print('原始字符串写法:', r'chpt6\data\test.txt')
print('os.path.join:', os.path.join('chpt6', 'data', 'test.txt'))
print('文件名:', os.path.basename('chpt6/data/data1.txt'))
print('扩展名:', os.path.splitext('data1.txt'))
运行结果(实测)
反斜杠要转义: chpt6\data\test.txt
原始字符串写法: chpt6\data\test.txt
os.path.join: chpt6\data\test.txt
文件名: data1.txt
扩展名: ('data1', '.txt')

相对路径

  • 从当前工作目录算起,如 "data1.txt"、"data/data1.txt"
  • 短、好写,但"当前目录"一变就找不到
  • 课上练习、同目录小文件够用

绝对路径

  • 从盘符 / 根目录写起,如 r"D:\mypython\data1.txt"
  • 在哪运行都能找到,但换机器就可能失效
  • 正式项目推荐:用 os.path.join() 拼
推荐写法:path = os.path.join('chpt6', 'data', 'data1.txt')。它不用你操心该写 \ 还是 /,换到 Linux / macOS 上也照样能跑。临时目录里的路径尤其要用它拼。
✅ 本节小结:路径里的 \ 是转义符,要么写成 \\,要么用原始字符串 r"D:\test.txt"。相对路径从当前工作目录算起,绝对路径从盘符算起;拼接路径推荐 os.path.join(),别手工加反斜杠。

2.4 close() 与 with:别让文件漏着

为什么一定要 close()?因为 write() 写的内容不是立刻落到磁盘,而是先放在缓冲区里攒着,close() 才把缓冲区刷到磁盘并释放文件句柄。程序若在 close() 之前异常退出,缓冲区的内容就可能丢。

手动 open() + close() 的问题是:中间一旦报错,close() 那一行就被跳过了。Python 的 with 语句(上下文管理语句)解决了这件事:不论什么原因跳出 with 代码块,都保证文件被正确关闭。

with 的生命周期:离开代码块,文件一定被关闭 ① 进入 with 调用 open() 得到文件对象 f with open(...) as f: ② 代码块内 f.read() / f.write() 正常读写内容 文件此时是打开的 ③ 离开代码块 正常结束 / return 或者抛异常 缩进退出的那一刻 ④ 自动关闭 调用 f.close() 缓冲区刷到磁盘 你不用写这一句 异常也会被关闭 ✓ 手动写法:f = open(...) … f.close()——中间一旦报错,close() 被跳过,数据可能没落盘 with 写法:不论怎么跳出代码块(包括异常),退出时自动 close(),一步到位
图 6-5 with 的四步生命周期——第④步的关闭是 Python 替你做的,发生异常也不跳过
with 与手动 close() 对照:看 f.closed 在代码块内外怎么变
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'test.txt')
    with open(path, 'w', encoding='utf-8') as f:
        f.write('I am Linda.')
        print('代码块内 f.closed =', f.closed)
    print('代码块外 f.closed =', f.closed)

    f = open(path, encoding='utf-8')
    print('手动 open 后 f.closed =', f.closed)
    f.close()
    print('手动 close 后 f.closed =', f.closed)
运行结果(实测)
代码块内 f.closed = False
代码块外 f.closed = True
手动 open 后 f.closed = False
手动 close 后 f.closed = True
🎬 动态演示:with 语句的生命周期:进入 → 读写 → 自动关闭
忘记 close() 会怎样?① 缓冲区里的内容可能没落盘,程序崩了数据就丢了;② 文件句柄被占着,Windows 上再想删、改名这个文件会失败;③ 打开的文件一多,句柄耗尽,后面直接打不开新文件。所以——能用 with 就别手动 open/close,这是本课要求的标准写法。
✅ 本节小结:close() 才把缓冲区刷到磁盘并释放文件;手动 open/close 遇到异常会漏掉 close。用 with open(...) as f: 写,离开代码块自动关闭,异常也关,是推荐写法。
三

读写与文件指针 本章重点

read / readline / readlines / for · write / writelines · tell() 与 seek() · 例 6-1 商品类别码统计 · 方法总表

文件打开了,接下来就是核心动作——读和写。读写时会有一个看不见的"光标"在文件里移动,叫文件指针。读到哪里、写到哪里、为什么第二次读是空的,答案全在指针上。这个模块把四种读法、两种写法、指针的两个方法(tell() / seek())一次讲清楚,最后完整做一节课件例 6-1。

3.1 读:read / readline / readlines / for

读文件有四种常用读法,区别只有两个:一次拿多少、拿回来的是什么类型。而它们都会让指针往后走——读过的内容不会再读第二遍。

方法返回什么读完指针在哪适合什么场景
read()整个文件,一个字符串文件末尾小文件,一次读完
read(size)指定 size 个字符往后移 size分段读,边读边处理
readline()一行,一个字符串(含 \n)下一行开头按行处理
readlines()每行一个字符串拼成的列表文件末尾小文件,要按行存起来
for line in f每次循环一行随循环逐行前进大文件首选,最省内存
四种读法,指针停的地方不一样 文件 data1.txt(3 行) 第一行\n 第二行\n 第三行\n 指针初始在 0(文件开头) read() 返回:整个文件的字符串 指针 → 文件末尾 readline() 返回:'第一行\n'(带着换行符) 指针 → 第 2 行开头 readlines() 返回:['第一行\n', '第二行\n', '第三行\n'] 指针 → 文件末尾 for line in f 每次循环拿 1 行,共循环 3 次 指针 → 随循环前进;最省内存 共同点:读过的内容不会再来一遍——指针只会往前走,除非用 seek() 把它拨回去
图 6-6 四种读法与指针位置:同一份 3 行文件,读法不同,拿到的类型和指针落点都不同
四种读法一次跑完:注意返回值的类型和每行末尾的 \n
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'data1.txt')
    with open(path, 'w', encoding='utf-8') as f:
        f.write('第一行\n第二行\n第三行\n')

    with open(path, encoding='utf-8') as f:
        print('read(5):', repr(f.read(5)))
    with open(path, encoding='utf-8') as f:
        print('readline():', repr(f.readline()))
    with open(path, encoding='utf-8') as f:
        print('readlines():', f.readlines())
    with open(path, encoding='utf-8') as f:
        for line in f:
            print('for 循环:', repr(line))
运行结果(实测)
read(5): '第一行\n第'
readline(): '第一行\n'
readlines(): ['第一行\n', '第二行\n', '第三行\n']
for 循环: '第一行\n'
for 循环: '第二行\n'
for 循环: '第三行\n'
🎬 动态演示:read / readline / readlines / for 四种读法的差别
配套视频黑马程序员 · 第 86 讲 文件的读取操作B站 · read / readline / readlines 的实机演示
每行末尾都带着 \n:readline() 和 for line in f 拿到的字符串包含换行符,直接 print() 会多出一个空行。处理数据前先 line.strip() 去掉首尾空白(空格、\n、\r 都去),再做 split()、int() 这类操作。比较"这一行是不是空的"也用它。
✅ 本节小结:读文件有四种读法——read() 读全部成一个字符串、readline() 读一行、readlines() 读所有行成一个列表、for line in f 逐行遍历(大文件首选,最省内存)。四种读法都会移动指针,每行末尾带 \n,处理前用 .strip() 去掉。

3.2 写:write / writelines

写文件两个方法,都很简单,但有一个坑必须记住:write() 不会自动换行,writelines() 也不会。想让文件"一行一条",得自己把 '\n' 拼进去。

write() 返回写入的字符数;writelines() 不加换行,要自己拼 \n
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'data2.txt')
    with open(path, 'w', encoding='utf-8') as f:
        n = f.write('Tom')
        print('write 返回的字符数:', n)
    with open(path, 'a', encoding='utf-8') as f:
        f.writelines(['Linda', 'Jack'])
    with open(path, encoding='utf-8') as f:
        print('writelines 后:', repr(f.read()))
    with open(path, 'a', encoding='utf-8') as f:
        f.writelines([x + '\n' for x in ['Bob', 'Amy']])
    with open(path, encoding='utf-8') as f:
        print('自己拼换行后:', repr(f.read()))
运行结果(实测)
write 返回的字符数: 3
writelines 后: 'TomLindaJack'
自己拼换行后: 'TomLindaJackBob\nAmy\n'
✗ 直接写列表项:全挤在一行
f.writelines(['Tom', 'Linda', 'Jack'])
# 文件里是:TomLindaJack
✓ 自己补上 \n:一行一条
f.writelines([x + '\n' for x in ['Tom', 'Linda', 'Jack']])
# 文件里是:
# Tom
# Linda
# Jack
配套视频黑马程序员 · 第 88 讲 文件的写出操作B站 · write 与 writelines 的写法与换行问题
两个容易踩的点:① write() 的参数必须是字符串,写数字要先 str() 转换,否则报 TypeError;② 用 'w' 模式写之前,文件原有的内容已经没了——想"接着写"请用 'a'。
✅ 本节小结:write(s) 写入一个字符串并返回写入的字符数;writelines(list) 写入一组字符串、返回 None,但不会自动加换行,要自己拼 '\n'。写数字前先 str()。

3.3 文件指针:tell() 与 seek()

文件对象内部有一个指针,指向"下一次读或写的位置"。tell() 告诉你它在哪,seek(offset, whence) 把它挪到别处。whence 有三个取值:0 从文件开头算(默认)、1 从当前位置算、2 从文件末尾算。下面这张图是课件里 TomLinda 那段交互的完整复盘。

文件内容 TomLinda:指针走过的四个位置 初始指针在 0(文件开头);tell() 返回"下一次要读的位置" 文件内容 T o m L i n d a 0 1 2 3 4 5 6 7 ① read(3) f.read(3) → 'Tom' tell() → 3 指针停在 3('L' 的位置) ② read(5) f.read(5) → 'Linda' tell() → 8 指针到 8(文件末尾) ③ seek(3, 0) f.seek(3, 0) → 3 tell() → 3 指针被拨回 3 ④ 再 read(5) f.read(5) → 'Linda' tell() → 8 又读到 'Linda' seek 的第二个参数 whence:0 从文件头算、1 从当前位置算、2 从文件末尾算(文本模式只能用 0)
图 6-7 文件指针的四个位置:read 往前推、tell 读数、seek 拨回去
课件里的 TomLinda 完整复盘:read → tell → read → seek → 再 read
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'test1.txt')
    with open(path, 'w', encoding='utf-8') as f:
        f.write('Tom')
        f.write('Linda')

    with open(path, encoding='utf-8') as f:
        print('read(3) →', f.read(3), ';tell() →', f.tell())
        print('read(5) →', f.read(5), ';tell() →', f.tell())
        f.seek(3, 0)
        print('seek(3, 0) 后 tell() →', f.tell())
        print('再 read(5) →', f.read(5))
运行结果(实测)
read(3) → Tom ;tell() → 3
read(5) → Linda ;tell() → 8
seek(3, 0) 后 tell() → 3
再 read(5) → Linda
🎬 动态演示:文件指针:read / tell / seek 三者怎么互动

指针还有一个限制:文本模式下只能 seek 到"绝对位置"(whence=0),因为一个汉字占几个字节要看编码,Python 没法从"当前位置"或"文件末尾"可靠地按字符偏移。所以下面这种写法会直接报错。

文本模式下 seek 用 whence=1 → UnsupportedOperation
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'test1.txt')
    with open(path, 'w', encoding='utf-8') as f:
        f.write('TomLinda')
    with open(path, encoding='utf-8') as f:
        f.seek(2, 1)
        print(f.read())
运行结果(实测)
Traceback (most recent call last):
  File "<pyshell>", line 8, in <module>
    f.seek(2, 1)
io.UnsupportedOperation: can't do nonzero cur-relative seeks
什么时候 whence=1/2 能用?用二进制模式('rb')打开时,字节就是字节,三种 whence 都支持;文本模式请老老实实用 seek(n, 0)。另外 seek 可以往前也可以往后,tell() 返回的是下一次读写的位置(不是刚读完的那个字符的位置)。
✅ 本节小结:tell() 返回当前指针位置;seek(offset, whence) 移动指针,whence 取 0 文件头(默认)、1 当前位置、2 文件末尾。文本模式只能用 whence=0,否则抛 UnsupportedOperation。

3.4 例 6-1:商品类别码统计

下面这个例子是课件例 6-1 的完整复现。题目是:从文件 data1.txt 中读取一组商品编号数据(数据之间以英文逗号分隔),取出各编号的前 2 位(表示商品的类别码),然后去除重复的类别码,并按类别码排序。思路一共五步:读全部 → 按逗号切 → 每个编号取前 2 位 → 用集合去重 → 排序。

data1.txtUTF-8 · 纯文本
1001,1002,2001
2002,1001,3001
两行商品编号,编号之间用英文逗号分隔,行末还有换行符——所以 split(',') 切出来的某一项会带着 \n,取前 2 位时不受影响。
例 6-1:一串字符,五次变身 ① 读 fr.read() → '1001,1002,2001\n2002,1001,3001' 一个字符串 ② 切 codes.split(',') → ['1001', '1002', '2001\n2002', '1001', '3001'] 列表,5 项 ③ 截 [c[0:2] for c in alist] → ['10', '10', '20', '10', '30'] 列表,类别码 ④ 去重 set(codes) → {'10', '20', '30'} 集合,无序 ⑤ 排序 sorted(list(uni_codes)) → ['10', '20', '30'] 列表,升序 数据形态变了四次:字符串 → 列表 → 列表 → 集合 → 列表;每一步都可以 print 出来看
图 6-8 例 6-1 的五步数据形态:每一次转换都对应一行代码,形参名也在图里
例 6-1 完整复现:读 data1.txt → split → 取前 2 位 → 去重 → 排序
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'data1.txt')
    with open(path, 'w', encoding='utf-8') as f:
        f.write('1001,1002,2001\n2002,1001,3001')

    with open(path, 'r', encoding='utf-8') as fr:
        codes = fr.read()                     # 读取数据,返回一个字符串
        print(codes)

    alist = codes.split(',')                  # 返回一个字符串列表
    print(alist)
    codes = [c[0:2] for c in alist]           # 每个编号取前 2 位
    print(codes)
    uni_codes = set(codes)                    # 去除重复的类别码
    uni_codes = sorted(list(uni_codes))
    print(uni_codes)
运行结果(实测)
1001,1002,2001
2002,1001,3001
['1001', '1002', '2001\n2002', '1001', '3001']
['10', '10', '20', '10', '30']
['10', '20', '30']
和课件原例的差别只有一处:课件里 data1.txt 已经存在,路径是 r"d:\mypython\data1.txt";这里为了让你能直接点"运行"看到结果,先用 tempfile.TemporaryDirectory() 建一个临时目录,把 data1.txt 写进去再读——逻辑和课件一字不差,只是把"文件从哪来"补上了。真实作业里,你的数据文件放在代码同级目录即可。
✅ 本节小结:例 6-1 的套路是"读 → 切 → 截 → 去重 → 排序":read() 得到字符串,split(',') 得到列表,列表推导式 c[0:2] 取类别码,set() 去重,sorted() 排序。set 是无序的,要得到排好序的结果必须再 sorted() 一次。

3.5 文件对象方法总表

把 open() 返回的文件对象 f 身上的方法归拢一下,读写文件 99% 的操作都在这张表里。下面的图按"读、写、定位、关闭"分成四类,表里再逐个说清返回值和注意事项。

文件对象 f 的方法:读、写、定位、关闭 读 read(size) readline() readlines() for line in f 越读指针越往后 写 write(s) writelines(list) write 返回字符数 writelines 不加换行 参数必须是 str 定位 tell() seek(offset, whence) tell 返回当前位置 seek 移动指针 文本模式 whence 只能 0 关闭 close() with open(...) as f close 才真正保存 with 离开自动关 推荐用 with f 是 open() 返回的文件对象——先有 f,才能读、写、定位;用完一定要关
图 6-9 文件对象的方法地图:读四招、写两招、定位两招、关闭一招
方法作用返回值备注
read(size=-1)读取全部内容或 size 个字符str指针会后移
readline()读取一行str(含 \n)到末尾返回 ''
readlines()读取所有行list,每项一行每项含 \n,小文件用
write(s)写入一个字符串写入的字符数(int)s 必须是 str
writelines(list)写入一组字符串None不会自动加换行
seek(offset, whence=0)移动文件指针新的位置(int)文本模式 whence 只能是 0
tell()返回当前指针位置int下一次读写的起点
close()关闭文件None关闭后不能再读写
一张表记法:读的四个方法都"只动指针不写文件";写的两个方法都"从指针处往后写";tell / seek 是指针的仪表盘和方向盘;close 是保存并交还资源。真正写进文件的数据,要等 close()(或 with 结束)刷盘之后才算数。
✅ 本节小结:文件对象的常用方法分四类——读:read / readline / readlines / for;写:write / writelines;定位:tell / seek;关闭:close(或 with)。记住返回值:read 系列给字符串或列表,write 给字符数,writelines 与 close 给 None。
四

CSV 文件读写 本章重点

逗号分隔的纯文本表格 · csv.writer 写 · csv.reader 读 · next() 跳表头 · 例 6-4 写 user_info.csv · 例 6-5 求最高工资 · DictReader / DictWriter

前面三个模块,我们读写的一直是 .txt 纯文本:一行一句话,read() 回来就是一串字符。可现实里的数据往往长成表格的样子——姓名、年龄、职业、工资,一列一个字段,一行一条记录。要把它存成纯文本,最简单的办法就是在字段之间插一个分隔符;最自然的选择是逗号,于是就有了 CSV。

4.1 CSV 是什么

CSV 是 Comma-Separated Values(逗号分隔值)的缩写。它是一种以逗号作为分隔符的纯文本文件格式,通常用来存表格数据:每一行是一条记录,行内各字段用逗号隔开,同一份文件里每行的列数应当相同。txt / csv 这类文本文件可以直接用记事本打开看,也能用 Excel 打开看——同一份文件,两种看法。

先看 Excel 里的样子。下面这张图就是把 user_info.csv 拖进 Excel 之后的样子:表头是姓名、年龄、职业、工资,下面张三、李四两行数据。别被单元格骗了——文件本身并没有任何“表格结构”,它就是三行用逗号连起来的纯文本。

user_info.csv 在 Excel 里打开的样子:A 列姓名、B 列年龄、C 列职业、D 列工资,三行数据分别是张三 20 销售员 5000 和李四 22 程序员 8000。这就是 user_info.csv 在 Excel 里打开的样子,文件本身仍是逗号分隔的纯文本。
图 6-10 这就是 user_info.csv 在 Excel 里打开的样子,文件本身仍是逗号分隔的纯文本

把“表格”还原成“文本”,就是下面这个文件卡片:记事本里看到的三行字,和 Excel 里看到的三行两列,指的是同一份数据。Excel 只是按逗号把它摆成了网格。

user_info.csvUTF-8 · 纯文本 · 3 行
姓名,年龄,职业,工资
张三,20,销售员,5000
李四,22,程序员,8000
双击用记事本打开就是这三行;用 Excel 打开就被逗号拆成了三行四列的表格。文件里没有“格”,只有逗号。

逗号当分隔符有个绕不开的麻烦:字段内容本身就带逗号怎么办?比如“销售, 北京”这种写法。CSV 的规矩是:如果字段里含逗号,就用一对英文双引号把它包起来,引号里面的逗号一律不算分隔符。下图把一行 CSV 拆开来看。

一行 CSV:逗号是分隔符,引号里的逗号不算 张三,20,"销售, 北京",5000 ← 文件里的这一行 张三 第 1 列 · 姓名 20 第 2 列 · 年龄 销售, 北京 第 3 列 · 引号包住的字段 5000 第 4 列 · 工资 第 3 列里的逗号被引号保护起来了:按规矩拆,逗号不是分隔符;直接 split(',') 会把它拆坏。 拆出来的字段都是字符串:'20' 和 '5000' 不是数字,要算工资得先 int('5000')。 列数相同的多行摞在一起,就是一张 CSV 表格——表头行也算一行。
图 6-11 一行 CSV 怎么变成四个字段:逗号切开,引号保护字段内部的逗号

明白了“逗号拆分”的规矩,就该知道手工 split(',') 不靠谱。Python 标准库自带 csv 模块,它就是专门按上面那套规矩干活的分隔器。下面的 demo 把两种拆法摆在一起对比:普通的 str.split 遇到带引号的字段会翻车,csv.reader 则拆得干干净净。

手工 split 和 csv.reader 拆同一行:带引号的字段谁拆得对
import csv, io

line = '张三,20,销售员,5000'
print('先用 str.split(","):')
print(line.split(','))
print('字段个数:', len(line.split(',')))

line2 = '"销售, 北京",5000'
print('遇到带逗号的字段:', line2.split(','))
print('字段个数:', len(line2.split(',')))
print('csv.reader 读出来:', list(csv.reader(io.StringIO(line2))))
运行结果(实测)
先用 str.split(","):
['张三', '20', '销售员', '5000']
字段个数: 4
遇到带逗号的字段: ['"销售', ' 北京"', '5000']
字段个数: 3
csv.reader 读出来: [['销售, 北京', '5000']]
🎬 动态演示:一行 CSV 是怎么被拆成一个个字段的
✅ 本节小结:CSV 是逗号分隔的纯文本——一行一条记录、每行列数相同、记事本和 Excel 都能打开。字段内部含逗号时用引号包起来,所以拆列不要用 split(','),交给 csv 模块。

4.2 csv.writer:写 CSV

写 CSV 分两步:先用 open() 打开文件拿到文件对象,再用 csv.writer(fileobj) 在文件对象外面包一层 csv 写对象。这一层“壳”的作用只有一个:把列表转成一行逗号分隔的文本,然后交给文件对象写下去。

写法作用说明
csv.writer(f)创建 csv 写对象参数是已打开的文件对象,不是文件名
writer.writerow(list)写一行列表里一个元素 = 一个字段,返回写入的字符数
writer.writerows(rows)写多行参数是“列表的列表”,一次写多行

看 demo:表头用 writerow() 写一行,数据用 writerows() 一次写完。写完之后再以文本方式读回来,你就能看到 csv 模块到底往文件里写了什么。

writerow 写一行、writerows 写多行,把课程表存成 CSV
import csv, os, tempfile

rows = [
    ['课程', '班级', '人数'],
    ['Python', '数据1班', 45],
    ['Python', '数据2班', 48],
]

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'course.csv')
    with open(path, 'w', encoding='utf-8', newline='') as f:
        writer = csv.writer(f)
        writer.writerow(rows[0])       # 写一行:表头
        writer.writerows(rows[1:])     # 写多行:数据
    with open(path, encoding='utf-8', newline='') as f:
        print(f.read())
运行结果(实测)
课程,班级,人数
Python,数据1班,45
Python,数据2班,48

注意 open(path, 'w', encoding='utf-8', newline='') 里的最后一个参数 newline='':写 CSV 时必须写。这不是可有可无的装饰,漏了它,Windows 上的 CSV 会变成“每隔一行一个空行”。原因在下面这个 demo 里看得最清楚。

漏写 newline='' 会怎样:多出来的空行是这么来的
import csv, os, tempfile

rows = [['姓名', '年龄'], ['张三', 20], ['李四', 22]]

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'user_info.csv')

    with open(path, 'w', encoding='utf-8') as f:          # 漏写 newline=''
        csv.writer(f).writerows(rows)
    with open(path, encoding='utf-8', newline='') as f:
        raw = f.read()
    print('漏写时:', repr(raw))
    print('再读回来:', list(csv.reader(raw.splitlines())))

    with open(path, 'w', encoding='utf-8', newline='') as f:   # 正确写法
        csv.writer(f).writerows(rows)
    with open(path, encoding='utf-8', newline='') as f:
        raw = f.read()
    print('写对后:', repr(raw))
    print('再读回来:', list(csv.reader(raw.splitlines())))
运行结果(实测)
漏写时: '姓名,年龄\r\r\n张三,20\r\r\n李四,22\r\r\n'
再读回来: [['姓名', '年龄'], [], ['张三', '20'], [], ['李四', '22'], []]
写对后: '姓名,年龄\r\n张三,20\r\n李四,22\r\n'
再读回来: [['姓名', '年龄'], ['张三', '20'], ['李四', '22']]
为什么必须写 newline=''?行尾的换行符有两拨人在管:csv 模块默认往每行末尾写一个 \r\n(回车 + 换行两个字符);而 Python 在 Windows 上以文本模式写文件时,还会把其中的 \n 再翻译成 \r\n。两个一叠加,行尾就从 \r\n 变成了 \r\r\n——用记事本、Excel 或普通文本模式打开时,一个单独的 \r 也算一次换行,于是每两行之间多出一个空行;csv.reader 读到空行就返回 [](就是 demo 里“再读回来”多出来的那些方括号)。加上 newline='' 就是告诉 open():别做换行符翻译,行尾交给 csv 自己管。机房用的是 Windows,这个参数一定要写。
✅ 本节小结:写 CSV = open(..., 'w', newline='') 拿到文件对象 → csv.writer(f) 包一层 → writerow() / writerows() 写行。少写 newline='',Windows 上就会多出空行。

4.3 csv.reader:读 CSV

读是写的逆过程,但要注意一个关键差别:写进去的是列表,读出来的却全是字符串。csv.reader(iterable) 返回一个可迭代对象,每迭代一次给你一行,这一行是一个字符串列表——哪怕文件里写的是 20、5000 这样的数字,读回来也是 '20'、'5000'。

下图把“文件对象”和“csv 读写对象”的关系画清楚:文件对象负责行,csv 读写对象负责把一行文本和一行列表互相转换。

csv.writer / csv.reader 只是包在文件对象外面的一层壳 ① 写:程序里的列表 → 一行文本 → 磁盘 ② 读:磁盘 → 一行文本 → 字符串列表 程序里的列表(列表的列表) [['张三', 20, '销售员', 5000]] csv.writer(f).writerow(row) 文件对象 f(文本模式) '张三,20,销售员,5000\r\n' f.close()(或离开 with 块) 磁盘上的 user_info.csv 按 UTF-8 编码存成的字节 程序里的列表(全是字符串) ['张三', '20', '销售员', '5000'] csv.reader(f) 逐行迭代 文件对象 f(文本模式) '张三,20,销售员,5000\r\n' open(path, encoding='utf-8') 磁盘上的 user_info.csv 按 UTF-8 编码存成的字节 读写都要先 open() 拿到文件对象;文件对象只认“行”,拆列是 csv 模块干的活
图 6-12 文件对象管“行”,csv 读写对象管“列”——两条通路都从 open() 开始

csv.reader 读出来的第一行通常是表头(姓名、年龄、职业、工资)。表头不是数据,后面算工资时得把它跳过。跳过的方法不是“判断一下再 continue”,而是在循环之前先调用一次 next(reader),把第一行取走——之后 for row in reader 就是从第二条记录开始。

csv.reader 迭代:每行是一个字符串列表,next() 先取走表头
import csv, os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'user_info.csv')
    with open(path, 'w', encoding='utf-8', newline='') as f:
        writer = csv.writer(f)
        writer.writerow(['姓名', '年龄', '职业', '工资'])
        writer.writerow(['张三', 20, '销售员', 5000])
        writer.writerow(['李四', 22, '程序员', 8000])

    with open(path, encoding='utf-8', newline='') as f:
        reader = csv.reader(f)
        header = next(reader)              # 先取走表头
        print('表头(跳过):', header)
        for row in reader:
            print(row, '| 类型:', type(row).__name__)
        print('字段都是字符串:', [type(x).__name__ for x in row])
运行结果(实测)
表头(跳过): ['姓名', '年龄', '职业', '工资']
['张三', '20', '销售员', '5000'] | 类型: list
['李四', '22', '程序员', '8000'] | 类型: list
字段都是字符串: ['str', 'str', 'str', 'str']
读 CSV 的三条铁律:① 每行是列表,不是字符串;② 列表里每个元素都是 str,要算数必须 int() / float() 转换;③ 表头用 next(reader) 跳过,不要在循环里判断“第一行不是数据”。
✅ 本节小结:csv.reader(f) 逐行迭代,每行给一个字符串列表;next(reader) 把表头取走,循环就从数据行开始。数字字段读回来是字符串,别忘了转换。

4.4 例 6-4 + 例 6-5:把 user_info.csv 写进去再读出来

这两个例题是本节的核心,数据就用课件里的那两行:张三(20 岁,销售员,5000)和李四(22 岁,程序员,8000)。课件的代码把文件写在 d:\mypython\ 下,这里为了不污染你的磁盘,改用 tempfile.TemporaryDirectory() 建一个临时目录,代码结构一行都没变。

例 6-4 将列表中的用户信息写入 user_info.csv 文件

先把三行数据(含表头)放在列表里,然后 csv.writer 逐行写进去;紧接着再打开同一个文件读回来,确认写进去的内容。这一步很关键——写完立刻读回来看一眼,比在脑子里推断可靠得多。

例 6-4:把 data 写入 user_info.csv,再读回来看看
import csv, os, tempfile

data = [['姓名', '年龄', '职业', '工资'],
        ['张三', 20, '销售员', 5000],
        ['李四', 22, '程序员', 8000]]

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'user_info.csv')

    # 例 6-4:把列表中的用户信息写入 user_info.csv
    with open(path, 'w', encoding='utf-8', newline='') as f:
        csv_writer = csv.writer(f)
        for row in data:
            csv_writer.writerow(row)       # 逐行写入列表内容

    # 再把文件读回来,确认写进去的是什么
    with open(path, 'r', encoding='utf-8', newline='') as f:
        csv_reader = csv.reader(f)
        for row in csv_reader:
            print(row)
运行结果(实测)
['姓名', '年龄', '职业', '工资']
['张三', '20', '销售员', '5000']
['李四', '22', '程序员', '8000']

例 6-5 读取 user_info.csv,计算工资收入的最大值

读的时候要处理三件事:跳表头(next(csv_reader))、取工资列(row[3],第 4 列,下标从 0 开始)、转成整数(int(row[3]))。工资收集到 salary 列表里,最后 max(salary) 求最大值。

例 6-5:next() 跳表头 → int(row[3]) 收工资 → max() 求最高工资
import csv, os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'user_info.csv')
    with open(path, 'w', encoding='utf-8', newline='') as f:
        csv.writer(f).writerows([['姓名', '年龄', '职业', '工资'],
                                 ['张三', 20, '销售员', 5000],
                                 ['李四', 22, '程序员', 8000]])

    # 例 6-5:读 user_info.csv,求工资的最大值
    salary = []
    with open(path, 'r', encoding='utf-8', newline='') as f:
        csv_reader = csv.reader(f)
        header_row = next(csv_reader)      # 跳过表头
        for row in csv_reader:
            salary.append(int(row[3]))     # 第 4 列是工资
    print(salary)
    print('最高工资为:' + str(max(salary)))
运行结果(实测)
[5000, 8000]
最高工资为:8000
例 6-5 里 header_row = next(csv_reader) 这个赋值其实没用到 header_row,它的副作用才是重点:next() 把表头那一行消耗掉了。如果省掉这一句,int('工资') 会直接抛 ValueError。另外课件里的路径写死在 d:\mypython\,也没显式写 encoding 和 newline;这里换成临时目录并按前两节的规范补齐,读写逻辑与课件完全一致。
✅ 本节小结:例 6-4 用 csv.writer 把“列表的列表”逐行写成 CSV;例 6-5 用 next() 跳表头、int(row[3]) 把字符串工资转成整数、max() 求最高工资。这两步合起来,就是“存进去、算出来”的完整闭环。

4.5 DictReader / DictWriter(选学)

csv.reader 给的是列表,取字段只能靠列号(row[0]、row[3])。一旦 CSV 的列顺序变了,所有下标都得跟着改,很容易错位。所以 csv 模块还提供了按表头名取字段的版本:csv.DictReader 把每行变成字典,csv.DictWriter 按 fieldnames 写字典。

csv.reader → 列表(按列号取)
row = ['张三', '20', '销售员', '5000']
row[0]        # '张三'
row[3]        # '5000'
# 列顺序一变,下标全得改
csv.DictReader → 字典(按表头取)
row = {'姓名': '张三', '年龄': '20',
       '职业': '销售员', '工资': '5000'}
row['姓名']    # '张三'
row['工资']    # '5000'
# 列顺序变了也不怕
🎬 动态演示:csv.reader 给列表、DictReader 给字典

看 demo:用 DictWriter(f, fieldnames=['姓名', '职业', '工资']) 写,字典的键和 fieldnames 对上就写、对不上就报错;读的时候 DictReader 自动把表头当年键,每行给一个字典。

DictWriter 按 fieldnames 写字典,DictReader 按表头读成字典
import csv, os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'user_info.csv')
    with open(path, 'w', encoding='utf-8', newline='') as f:
        writer = csv.DictWriter(f, fieldnames=['姓名', '职业', '工资'])
        writer.writeheader()
        writer.writerow({'姓名': '张三', '职业': '销售员', '工资': 5000})
        writer.writerow({'姓名': '李四', '职业': '程序员', '工资': 8000})

    with open(path, encoding='utf-8', newline='') as f:
        for row in csv.DictReader(f):
            print(row['姓名'], row['职业'], row['工资'],
                  '| 键:', list(row.keys()))
运行结果(实测)
张三 销售员 5000 | 键: ['姓名', '职业', '工资']
李四 程序员 8000 | 键: ['姓名', '职业', '工资']
选学内容,考试不要求默写。判断标准:如果后面还要按字段名反复取数据、或者列顺序可能变,用 DictReader 更稳;只是从头到尾按位置处理几列,reader 就够了。读回来的字典值仍然是字符串,要算数还得转换。
✅ 本节小结:列表按列号,字典按表头。数据列多、顺序会变时用 DictReader / DictWriter,靠 fieldnames 对齐字段名,比记 row[3] 稳。
五

目录常用操作 上机常用

os 模块目录函数 · getcwd / chdir / listdir · mkdir vs makedirs · rmdir 只删空目录 · scandir 与 DirEntry · os.path 判断与拆分 · 递归遍历目录树

文件操作处理的是“一个文件”,目录操作处理的是“一堆文件放在哪”。Python 内置的 os 模块提供了目录与路径的常用方法:看当前在哪、列目录内容、建目录、删目录、判断是文件还是目录、把路径拼起来或拆开。这些函数是后面“遍历整个数据集目录”“批量改名”这类任务的地基。

5.1 os 模块的目录函数

先把这一节要用的函数摆成一张表。不用背,写代码时回来查。要注意两个容易混淆的地方:listdir 和 scandir 都能列目录,但返回的东西完全不一样;mkdir 和 makedirs 只差几个字母,能建的层级却差很多。

函数作用返回 / 要点
os.listdir(path)列出目录下的所有名字字符串列表;只有名字,不带路径;顺序不保证
os.scandir(path)列出目录项DirEntry 可迭代对象,每项有 name / path / is_file() / is_dir()
os.mkdir(path)创建一级目录父目录必须已存在;目录已存在报 FileExistsError
os.makedirs(path)创建多级目录缺的父目录自动补齐;已存在时加 exist_ok=True 不报错
os.rmdir(path)删除目录只能删空目录;非空报 OSError,要连内容删用 shutil.rmtree()
os.getcwd()取当前工作目录返回绝对路径字符串
os.chdir(path)切换当前工作目录之后的相对路径都相对于它;切走记得切回
os.path.isdir(path)判断是不是目录返回 True / False;配套还有 isfile / exists
os.path.join(a, b)拼接路径按系统分隔符连接,自动处理该不该加 \
os.path.basename(path) / splitext(path)取文件名 / 拆后缀basename 给 'file1.txt';splitext 给 ('file1', '.txt')
路径的两种写法:listdir('.') 里的 '.' 表示当前目录,'..' 表示上一级。写 listdir(路径) 是“看别人家”,写 listdir('.') 是“看自己家”——不切换目录也能看,所以多数时候不需要 chdir。
✅ 本节小结:目录操作的函数分成三组——看(listdir / scandir / getcwd)、改(mkdir / makedirs / chdir)、删(rmdir)。再加一组判断与路径处理(os.path.*)。

5.2 当前目录:getcwd / chdir / listdir

假设 Windows 的 D 盘上有一个叫 my_dir 的文件夹,结构如下图:里面有三个东西——file1.txt、file2.csv 两个文件,以及子目录 dir1;dir1 里又放着 file3.py、file4.py、file5.txt 三个文件。后面几节的 demo 都用这个结构,只是建在临时目录里。

my_dir 文件夹里到底有什么 my_dir/ listdir(my_dir) 返回: ['dir1', 'file1.txt', 'file2.csv'] (顺序不保证,这里按字母排) dir1 是目录,不是文件: os.path.isdir('my_dir/dir1') → True file1.txt file2.csv dir1/ file3.py file4.py file5.txt 蓝色框 = 目录,白色框 = 文件;my_dir 下一层 3 项,dir1 里还有 3 个文件——这就是“树”
图 6-13 my_dir 的目录树:一个目录里可以既有文件,又有子目录,子目录里再有文件

getcwd() 问“我现在在哪个目录”,chdir(path) 说“我要换到那个目录去”,listdir(path) 列“那个目录里有什么”。三个函数配合起来,就是课件里那串操作:先 chdir 进 my_dir,再 getcwd 看位置,最后 listdir('.') 看内容。不切换目录也能列,直接写 listdir(r“D:\my_dir”) 就行。

照 my_dir 的样子建一棵目录树,再用 listdir 列出来
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    work = os.path.join(td, 'my_dir')
    os.makedirs(os.path.join(work, 'dir1'))
    for name in ['file1.txt', 'file2.csv']:
        with open(os.path.join(work, name), 'w', encoding='utf-8') as f:
            f.write('x')
    for name in ['file3.py', 'file4.py', 'file5.txt']:
        with open(os.path.join(work, 'dir1', name), 'w', encoding='utf-8') as f:
            f.write('x')

    print('my_dir 里:', sorted(os.listdir(work)))
    print('dir1 里:', sorted(os.listdir(os.path.join(work, 'dir1'))))
    print('dir1 是目录吗:', os.path.isdir(os.path.join(work, 'dir1')))
运行结果(实测)
my_dir 里: ['dir1', 'file1.txt', 'file2.csv']
dir1 里: ['file3.py', 'file4.py', 'file5.txt']
dir1 是目录吗: True

chdir 有一个坑:它改的是整个进程的工作目录。切进去忘了切回来,后面所有用相对路径的代码都会在错误的目录里找文件。所以演示 chdir 的标准写法是——先存旧目录,演示完再切回。

getcwd / chdir:切进去,干完活,再切回来
import os, tempfile

old = os.getcwd()                        # 先记住原来的工作目录
with tempfile.TemporaryDirectory() as td:
    work = os.path.join(td, 'my_dir')
    os.mkdir(work)
    with open(os.path.join(work, 'file1.txt'), 'w', encoding='utf-8') as f:
        f.write('hello')

    os.chdir(work)                       # 切换当前工作目录
    print('getcwd() 等于 abspath("."):', os.getcwd() == os.path.abspath('.'))
    print('当前目录里的内容:', os.listdir('.'))
    os.chdir(old)                        # 演示完必须切回来

print('已经切回原来的目录:', os.getcwd() == old)
运行结果(实测)
getcwd() 等于 abspath("."): True
当前目录里的内容: ['file1.txt']
已经切回原来的目录: True
不要 chdir 完了不回来。一个 Python 程序从头到尾只有一个工作目录,改了就影响后面所有代码。能用 listdir(路径) 传路径解决的,就别 chdir;非得切,就学上面的写法:old = os.getcwd() → 干活 → os.chdir(old)。
✅ 本节小结:getcwd() 看位置、chdir() 换位置、listdir() 看内容。listdir('.') 看当前目录,listdir(路径) 看不切换也能看的目录。切换目录务必切回。

5.3 建目录与删目录:mkdir / makedirs / rmdir

建目录的两个函数只差三个字母,能力却差一截:mkdir 只能建一级,父目录必须已经存在;makedirs 可以一次建多级,缺的父目录它会一层一层补上。删目录的 rmdir 则有一条铁律:只能删空目录。

建目录与删目录:三个函数的分工 os.mkdir(path) 只能建一级 mkdir('a') ✓ mkdir('a/b') ✗ 父目录 b 不存在 → FileNotFoundError 目录已存在时: → FileExistsError os.makedirs(path) 可以一次建多级 makedirs('a/b/c') ✓ 缺的父目录自动补齐 已存在时加参数: exist_ok=True 就不抛异常 建层级深的目录用它 os.rmdir(path) 只能删空目录 rmdir('空目录') ✓ rmdir('非空目录') ✗ → OSError 要连内容一起删: shutil.rmtree(path) 危险操作,用完就没了 口诀:mkdir 建一层,makedirs 建一条链;rmdir 只扫空地,有东西先搬走或 rmtree
图 6-14 mkdir / makedirs / rmdir 三个函数的分工与各自的报错

看 demo 验证:mkdir 建两级会在父目录缺失时抛 FileNotFoundError,同一个目录再建一次抛 FileExistsError;换成 makedirs,三级目录一次到位。

mkdir 只能建一级、makedirs 能建多级:用异常把差别看清楚
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    os.mkdir(os.path.join(td, 'a'))
    print('mkdir 建一级 a:', os.path.isdir(os.path.join(td, 'a')))

    try:                                  # 父目录 b 不存在
        os.mkdir(os.path.join(td, 'b', 'c'))
    except FileNotFoundError as e:
        print('mkdir 建 b/c 失败:', type(e).__name__)

    os.makedirs(os.path.join(td, 'b', 'c', 'd'))
    print('makedirs 建三级 b/c/d:',
          os.path.isdir(os.path.join(td, 'b', 'c', 'd')))

    try:                                  # 同一目录再建一次
        os.mkdir(os.path.join(td, 'a'))
    except FileExistsError as e:
        print('重复建 a 失败:', type(e).__name__)
运行结果(实测)
mkdir 建一级 a: True
mkdir 建 b/c 失败: FileNotFoundError
makedirs 建三级 b/c/d: True
重复建 a 失败: FileExistsError

删目录时,先确认它是不是空的。空目录 rmdir 一下就没了;非空目录会抛 OSError,因为 Python 不敢替你决定“里面的东西要不要一起删”。正确姿势是:先把里面的东西删空,再删它自己。

rmdir 只删空目录:非空会报错,先清空再删
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    d = os.path.join(td, 'test')
    os.makedirs(os.path.join(d, 'sub'))
    print('test 里现在有:', os.listdir(d))

    try:
        os.rmdir(d)                        # 非空目录
    except OSError as e:
        print('rmdir 删非空目录:', type(e).__name__)
        print('提示里说到目录非空:', '空' in str(e) or 'empty' in str(e).lower())

    os.rmdir(os.path.join(d, 'sub'))       # 先删空子目录
    os.rmdir(d)                            # 再删 test
    print('test 还在吗:', os.path.exists(d))
运行结果(实测)
test 里现在有: ['sub']
rmdir 删非空目录: OSError
提示里说到目录非空: True
test 还在吗: False
rmdir 和 shutil.rmtree 的区别是“安全性”:rmdir 只能删空目录,误删的可能性很小;shutil.rmtree(路径) 会连里面的所有文件和子目录一起删掉,且不进回收站。初学阶段写 rmtree 前,先把路径 print 出来看三遍。
✅ 本节小结:mkdir 建一级、父目录必须在;makedirs 建多级、父目录自动补;rmdir 只删空目录,非空要 shutil.rmtree(删了就没了,小心)。

5.4 scandir 与 os.path 判断

前面 listdir 返回的是名字列表——想知道某个名字是文件还是目录,还得再调一次 os.path.isdir。os.scandir(path) 更省事:它返回一个由 DirEntry 对象组成的可迭代对象,每个 DirEntry 自带 name(名字)、path(拼好的路径)和 is_file() / is_dir() 两个判断方法。它不会一次性把所有信息读进内存,目录很大时也扛得住。

scandir 返回 DirEntry:名字、路径、是文件还是目录,一次拿全
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    work = os.path.join(td, 'my_dir')
    os.makedirs(os.path.join(work, 'dir1'))
    for name in ['file1.txt', 'file2.csv']:
        with open(os.path.join(work, name), 'w', encoding='utf-8') as f:
            f.write('x')

    entries = sorted(os.scandir(work), key=lambda e: e.name)
    print('拿到的东西:', type(entries[0]).__name__)
    for e in entries:
        kind = '目录' if e.is_dir() else '文件'
        print(e.name, '是', kind, '| is_file =', e.is_file())
运行结果(实测)
拿到的东西: DirEntry
dir1 是 目录 | is_file = False
file1.txt 是 文件 | is_file = True
file2.csv 是 文件 | is_file = True

除了 scandir,os.path 这组函数更常用:exists / isfile / isdir 做判断,join / basename / splitext 做路径的拼与拆。下图把它们的分工画开。

os.path:拼路径、拆路径,五个函数 拼接:os.path.join('my_dir', 'dir1', 'file3.py') my_dir + dir1 + file3.py my_dir\dir1\file3.py 拆分一个完整路径: D:\my_dir\dir1\file3.py 完整路径(绝对路径) os.path.basename(path) 'file3.py' 只要文件名 os.path.dirname(path) 'D:\my_dir\dir1' 只要前面的目录 os.path.splitext(path) ('file3', '.py') 拆成 主名 + 后缀 这三个拆分函数都只处理字符串,不检查文件是否真的存在;判断存在要用 exists / isfile / isdir
图 6-15 os.path 的拼与拆:join 拼,basename / dirname / splitext 拆
🎬 动态演示:路径拼接与拆分——join / basename / splitext

看 demo:join 用系统分隔符拼接(Windows 上是 \),不用自己写 + '\\';basename / dirname 拆出文件名和目录;splitext 把主名和后缀分成两个字符串——注意 report.tar.gz 的“后缀”只算最后一个点后面的 .gz。

os.path.join / basename / dirname / splitext / exists 一把过
import os

print('join:', os.path.join('my_dir', 'dir1', 'file3.py'))
print('basename:', os.path.basename('my_dir/dir1/file1.txt'))
print('dirname:', os.path.dirname('my_dir/dir1/file1.txt'))
print('splitext:', os.path.splitext('file2.csv'))
print('splitext 拆多后缀:', os.path.splitext('report.tar.gz'))
print('exists 判断:', os.path.exists('不存在的文件.txt'))
运行结果(实测)
join: my_dir\dir1\file3.py
basename: file1.txt
dirname: my_dir/dir1
splitext: ('file2', '.csv')
splitext 拆多后缀: ('report.tar', '.gz')
exists 判断: False
手工拼路径 path + '\\' + name 的问题在于:Windows 用 \,Linux / macOS 用 /;多一个或少一个分隔符就会拼出 my_dir\\file1.txt 或 my_dirfile1.txt。用 os.path.join() 由系统来决定分隔符,跨平台也稳。
✅ 本节小结:scandir 返回 DirEntry 可迭代对象,自带 name / path / is_file() / is_dir();os.path 负责判断(exists / isfile / isdir)和路径拼拆(join / basename / splitext)。

5.5 遍历目录树(递归)与 pathlib 简介

把 5.2 的目录树真正“走一遍”,需要递归:处理一个目录时,如果里面还有子目录,就用同样的办法再进子目录处理,直到没有子目录为止。函数自己调用自己,天然适合这种“一层套一层”的结构。

下图是递归遍历的执行顺序:先处理 my_dir,发现 dir1 是目录,就钻进去把它的三个文件打印完,再退回来继续处理 file1.txt、file2.csv。这种“钻到底再回来”的顺序叫深度优先。

🎬 动态演示:递归遍历目录树,文件夹里还有文件夹

递归函数要写对两件事:基准情形(目录里没有子目录了,循环自然结束)和递归调用(遇到子目录,带着新的路径和更深的缩进再调自己)。缩进用 ' ' * depth 造出来,层级越深缩进越多,打印结果就是一棵树。

递归函数 walk(path, depth):把 my_dir 整棵树打印出来
import os, tempfile

def walk(path, depth=0):
    for name in sorted(os.listdir(path)):
        full = os.path.join(path, name)
        mark = '[目录]' if os.path.isdir(full) else '[文件]'
        print('    ' * depth + mark + ' ' + name)
        if os.path.isdir(full):
            walk(full, depth + 1)

with tempfile.TemporaryDirectory() as td:
    work = os.path.join(td, 'my_dir')
    os.makedirs(os.path.join(work, 'dir1'))
    for name in ['file1.txt', 'file2.csv']:
        with open(os.path.join(work, name), 'w', encoding='utf-8') as f:
            f.write('x')
    for name in ['file3.py', 'file4.py', 'file5.txt']:
        with open(os.path.join(work, 'dir1', name), 'w',
                  encoding='utf-8') as f:
            f.write('x')

    print('my_dir/')
    walk(work, 1)
运行结果(实测)
my_dir/
    [目录] dir1
        [文件] file3.py
        [文件] file4.py
        [文件] file5.txt
    [文件] file1.txt
    [文件] file2.csv

标准库 pathlib 是 Python 3.4 之后推荐的路径写法,把路径当对象而不是字符串:Path('my_dir') / 'dir1' / 'file3.py' 用 / 拼路径,.name / .parent / .suffix / .stem 取各部分,.iterdir() 列目录。选学,但很值得认识。

pathlib 选学:用 / 拼路径,用属性拆路径
from pathlib import Path

p = Path('my_dir') / 'dir1' / 'file3.py'   # 用 / 拼路径
print('拼接结果:', p)
print('文件名:', p.name)
print('所在目录:', p.parent)
print('后缀:', p.suffix, '| 去掉后缀:', p.stem)
print('父目录的名字:', p.parent.name)
运行结果(实测)
拼接结果: my_dir\dir1\file3.py
文件名: file3.py
所在目录: my_dir\dir1
后缀: .py | 去掉后缀: file3
父目录的名字: dir1
为什么递归遍历是后面所有“批量处理”的基础?因为数据集往往按“类别 / 子类 / 文件”存成多层目录。会写递归遍历,就能把一个目录树下所有 .csv 找出来、批量统计行数、统一改名——本课最后两节的文件综合应用和第 7 节的 AI 真实数据文件,用的都是这个套路。
✅ 本节小结:遍历目录树用递归——遇到子目录就带新路径和更深的缩进调自己;pathlib.Path 用 / 拼路径、用属性拆路径,是更现代的写法(选学)。
六

文件操作综合应用 综合实战

例 6-6 短文长度 · 例 6-7 成绩合并排序 · 日志追加与批量处理 · 上机任务

前面五节把文件操作拆成了零件:打开、读、写、文件指针、CSV、目录。这一节把零件装回去——看三个真实用途的小案例。课件上的例 6-6 和例 6-7 代码都很短,但它们是后面所有"数据处理"程序的骨架:读文件 → 变成 Python 的数据结构 → 算 → 写回文件。看例题时不要只盯着语法,要盯住"数据在这一步变成了什么形态"。

6.1 例 6-6:统计英文短文的长度

例 6-6 要做的事一句话就能说完:data3.txt 里每一行是一篇英文短文,统计每篇短文有多少个字符。题目看着简单,但它把"文本文件按行读"讲得很干净——for line in f 每次给你一整行,而且这一行末尾还带着换行符 \n。

综合应用的通用流水线:读进来 → 变形态 → 算出来 → 写回去 ① 打开 + 读取 open(path) 配 for line in f 拿到的每一行是字符串 ② 清洗 + 拆分 strip() 去空白 split() 拆成字段 ③ 处理 + 计算 extend / float / sort 在内存里倒腾列表与字典 ④ 写出文件 open(dst, 'w') 配 write() 磁盘上多了一个新文件 每一行 → 一个字符串 只要需要的那几段 列表 / 字典(在内存里) 磁盘上的新文件 套路可以复用:例 6-6 是「读 → 数长度 → 打印」,例 6-7 是「读 → 合并成列表 → 排序 → 写回」。 数据在磁盘上是字符,进了程序才变成字符串、列表、字典——形态每变一次,都要你亲手写代码。
图 6-16 文件操作综合应用的通用流水线:四个步骤,每一步都在改变数据的形态
例 6-6 完整复现:data3.txt 每行一篇短文,统计每篇长度
import os, tempfile

PASSAGES = [
    'Reading makes a full man.',
    'Practice makes perfect.',
    'A little learning is a dangerous thing.',
]

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'data3.txt')
    with open(path, 'w', encoding='utf-8') as f:      # 先造一个 data3.txt
        for p in PASSAGES:
            f.write(p + '\n')

    with open(path, 'r', encoding='utf-8') as f:      # 再按行读回来
        for line in f:
            print(line.strip())                       # 去掉行尾换行后再打印
            text = len(line.strip())                  # 一篇短文的长度
            print('长度:' + str(text))
运行结果(实测)
Reading makes a full man.
长度:25
Practice makes perfect.
长度:23
A little learning is a dangerous thing.
长度:39
两个容易忽略的细节:① line.strip() 去掉的是首尾的空白与换行符,不会动中间的空格——所以它统计的正是一篇短文本身的字符数;② len() 数的是字符个数,不是字节数(第 1 节讲过,"你好"是 2 个字符,在 UTF-8 下却占 6 个字节)。如果文件里混了中文,这两种"长度"会差很多。
为什么不用 f.readlines()?因为 for line in f 是一次只取一行——文件有 100 万行也只占一行的内存。例 6-6 只有三行无所谓,但第 7 节的语料文件动辄几十万行,这个习惯就得从第一行代码开始养。
✅ 本节小结:按行读文本是最常用的姿势——for line in f 一次一行,strip() 剪掉行尾换行,len() 数长度。例 6-6 的全部核心只有四行,但"一行一篇短文"这个约定,正是后面 CSV、jsonl、日志文件的共同前提:行是文本文件最小的记录单位。

6.2 例 6-7:成绩合并 → 排序 → 写文件

例 6-7 是本课最有代表性的一个例子。data2.txt 里每一行是一组成绩,成绩之间用空格分隔;要求把所有组的成绩合并到一起、按升序排序,再把结果写进 data2_sorted.txt。它值得反复看,是因为它有三次数据形态变化,而且每一次变化都只由一行代码完成。

例 6-7 完整复现:split → extend → float → sort → 写回(打印三次形态变化)
import os, tempfile

DATA = '78.5 92.0 66.5\n88.0 95.5\n70.0 81.0 59.5 100.0\n'

with tempfile.TemporaryDirectory() as td:
    src = os.path.join(td, 'data2.txt')
    dst = os.path.join(td, 'data2_sorted.txt')
    with open(src, 'w', encoding='utf-8') as f:       # 先造一个 data2.txt
        f.write(DATA)

    scores = []
    with open(src, 'r', encoding='utf-8') as fr:
        for line in fr:
            line = line.strip()
            alist = line.split()                      # 返回字符串列表
            scores.extend(alist)                      # 合并数据
    print('scores 1: ', scores)

    scores = [float(sc) for sc in scores]             # 转换为浮点数
    print('scores 2: ', scores)

    scores.sort()                                     # 排序
    print('scores 3: ', scores)

    with open(dst, 'w', encoding='utf-8') as fw:      # 写回新文件
        for sc in scores:
            fw.write(str(sc) + ' ')                   # 用空格分隔

    with open(dst, encoding='utf-8') as fr:
        content = fr.read()
    print('data2_sorted.txt 的内容:[' + content + ']')
    print('末尾有换行符吗?', content.endswith('\n'))
运行结果(实测)
scores 1:  ['78.5', '92.0', '66.5', '88.0', '95.5', '70.0', '81.0', '59.5', '100.0']
scores 2:  [78.5, 92.0, 66.5, 88.0, 95.5, 70.0, 81.0, 59.5, 100.0]
scores 3:  [59.5, 66.5, 70.0, 78.5, 81.0, 88.0, 92.0, 95.5, 100.0]
data2_sorted.txt 的内容:[59.5 66.5 70.0 78.5 81.0 88.0 92.0 95.5 100.0 ]
末尾有换行符吗? False
例 6-7 的数据形态变化:同一份成绩,在程序里换了四次"衣服" ① 逐行 split + extend 字符串列表 · 9 个元素 ['78.5', '92.0', '66.5', '88.0', '95.5', '70.0', '81.0', '59.5', '100.0'] ② 列表推导式 float() 浮点列表 · 还是 9 个 [78.5, 92.0, 66.5, 88.0, 95.5, 70.0, 81.0, 59.5, 100.0] ③ scores.sort() 升序 · 原列表被改动 [59.5, 66.5, 70.0, 78.5, 81.0, 88.0, 92.0, 95.5, 100.0] ④ 逐个 write 写回 文件 · 空格分隔、无换行 59.5 66.5 70.0 78.5 81.0 88.0 92.0 95.5 100.0 字符串列表 → 浮点列表 → 排好序的列表 → 文件里的字符串;"排序"只能作用在数字上,所以第 ② 步不能省
图 6-17 例 6-7 的数据形态变化:文件里其实只有一行(空格分隔),末尾还留下一个空格、没有换行符
🎬 动态演示:例 6-7 的数据形态变化——字符串列表 → 浮点列表 → 排好序 → 写回文件
写回那一行有三处讲究:① str(sc) 把浮点数变回字符串——write() 只收字符串,直接写 78.5 会抛 TypeError;② 数字后面跟的是空格而不是 \n,所以整个文件最后是"一行、9 个数字、空格分隔";③ 最后一个数字后面也留下了一个空格,文件末尾没有换行符——读回来时 read() 得到的字符串就长那样。想让末尾不留多余空格,就得改成先拼好再写:fw.write(' '.join(str(sc) for sc in scores))。
一次完整的"文件 → 程序 → 文件":磁盘只被碰了两次 data2.txt(原始) 78.5 92.0 66.5 88.0 95.5 70.0 81.0 59.5 100.0 程序内存:scores 读入后:字符串列表 float 后:浮点列表 sort 后:升序 data2_sorted.txt(新) 59.5 66.5 70.0 78.5 81.0 88.0 92.0 95.5 100.0 (实际只有一行,这里折行显示) ① 读:open(src, 'r') → for line in f → line.split() → scores.extend() ② 写:open(dst, 'w') → for sc in scores: f.write(str(sc) + ' ') 中间所有计算(合并、转类型、排序)都发生在内存里,一个字节都没再碰磁盘
图 6-18 文件 → 程序 → 文件 的读写回路:程序只是"搬运 + 加工"的中转站
✅ 本节小结:split() 把一行拆成字符串列表,extend() 把它们并成一个大列表,[float(sc) for sc in scores] 把字符串换成浮点数,sort() 排好序,最后 f.write(str(sc) + ' ') 依次写回。五步、五件小事,一步都不能省——这就是"数据清洗"最原始的形态,第 8 章 Pandas 的 read_csv → astype → sort_values → to_csv 做的是同一件事,只是把五行写成了一行。

6.3 综合案例:追加写日志与批量处理

真实工作里,文件操作很少是"读一个文件、写一个文件"这么干净。下面三个套路是出现频率最高的:往日志里追加一行、把日志读回来做 Top-N 统计、批量遍历目录挑出要的文件。它们把前五节的每一个知识点都用上了。

套路一:追加写日志(a 模式 + 时间戳)

日志文件的特点是"只往后加、从不回头改"。所以它必须用 a 模式打开——a 每次把指针放到文件末尾,写多少接多少,原有内容一行都不会丢。下面的例子用的是固定好的"假时间",好处是每次运行结果完全一样,方便你对照。

追加写日志:a 模式 + 时间戳,每次循环只加一行
import os, tempfile

# 固定好的"假时间",保证输出每次一样(真实项目里用 datetime.now())
RECORDS = [
    ('2026-03-02 08:15:01', '192.168.1.10', '/index'),
    ('2026-03-02 08:15:37', '10.0.0.23', '/detail?id=7'),
    ('2026-03-02 08:16:02', '192.168.1.10', '/cart'),
    ('2026-03-02 08:17:44', '10.0.0.23', '/pay'),
    ('2026-03-02 08:18:09', '172.16.5.8', '/index'),
]

with tempfile.TemporaryDirectory() as td:
    log = os.path.join(td, 'access.log')
    for ts, ip, url in RECORDS:
        with open(log, 'a', encoding='utf-8') as f:    # a 模式:追加,不清空
            f.write(ts + ' ' + ip + ' ' + url + '\n')

    with open(log, encoding='utf-8') as f:
        print(f.read(), end='')

    print('-' * 44)
    print('一共写了', len(RECORDS), '轮,每轮都是 a 模式,前面的记录全都还在')
运行结果(实测)
2026-03-02 08:15:01 192.168.1.10 /index
2026-03-02 08:15:37 10.0.0.23 /detail?id=7
2026-03-02 08:16:02 192.168.1.10 /cart
2026-03-02 08:17:44 10.0.0.23 /pay
2026-03-02 08:18:09 172.16.5.8 /index
--------------------------------------------
一共写了 5 轮,每轮都是 a 模式,前面的记录全都还在
这里换成 w 就全毁了:open(log, 'w') 一打开就把文件截断成空,循环五轮之后文件里只剩最后一行的内容——前四行在第一次循环时就没了。日志、流水、训练记录这类"只增不改"的文件,永远用 a。
真实代码里时间戳这样取:from datetime import datetime,然后 datetime.now().strftime('%Y-%m-%d %H:%M:%S')。注意页面上的例子故意用了固定字符串——同一个 demo 每次运行的结果必须一致,否则校验器和你的眼睛都会被"每次都不一样"搞乱。这条经验在做数据实验时同样成立:能固定的随机种子、时间、路径,就都固定下来。

套路二:把日志读回来做 Top-N 统计

日志写完之后要能读回来才有价值。每一行按空格 split() 之后,第 3 段是 IP、第 4 段是 URL,用一个字典数次数,再按次数倒序排——这就是最朴素的"访问统计"。

日志统计:按空格切分 + 字典计数 + 排序取前几名
import os, tempfile

LOG = [
    '2026-03-02 08:15:01 192.168.1.10 /index',
    '2026-03-02 08:15:37 10.0.0.23 /detail?id=7',
    '2026-03-02 08:16:02 192.168.1.10 /cart',
    '2026-03-02 08:17:44 10.0.0.23 /pay',
    '2026-03-02 08:18:09 172.16.5.8 /index',
    '2026-03-02 08:19:33 192.168.1.10 /pay',
    '2026-03-02 08:20:11 10.0.0.23 /index',
    '2026-03-02 08:21:05 172.16.5.8 /detail?id=7',
]

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'access.log')
    with open(path, 'w', encoding='utf-8') as f:
        f.write('\n'.join(LOG) + '\n')

    ip_count, url_count = {}, {}
    with open(path, encoding='utf-8') as f:
        for line in f:
            parts = line.split()               # 时间 空格 IP 空格 URL
            ip_count[parts[2]] = ip_count.get(parts[2], 0) + 1
            url_count[parts[3]] = url_count.get(parts[3], 0) + 1

    print('共', sum(ip_count.values()), '条记录,来自', len(ip_count), '个 IP')
    print('-' * 40)
    rank = sorted(ip_count.items(), key=lambda kv: kv[1], reverse=True)
    for i, (ip, n) in enumerate(rank, 1):
        print('IP 第', i, '名:', ip, ' 访问', n, '次')
    print('-' * 40)
    rank = sorted(url_count.items(), key=lambda kv: kv[1], reverse=True)
    for i, (url, n) in enumerate(rank[:3], 1):
        print('URL 第', i, '名:', url, ' ', n, '次')
运行结果(实测)
共 8 条记录,来自 3 个 IP
----------------------------------------
IP 第 1 名: 192.168.1.10  访问 3 次
IP 第 2 名: 10.0.0.23  访问 3 次
IP 第 3 名: 172.16.5.8  访问 2 次
----------------------------------------
URL 第 1 名: /index   3 次
URL 第 2 名: /detail?id=7   2 次
URL 第 3 名: /pay   2 次

套路三:批量遍历目录,挑出某一类文件

数据拿到手,第一个动作往往是"先把要的文件挑出来"。思路固定:os.walk() 递归遍历整棵目录树 → 用 endswith('.csv') 判断扩展名 → 挑中的用 shutil.copy2() 复制到一个干净的目录。这一套就是"数据准备"的雏形。

批量处理:遍历目录树,挑出所有 .csv 并复制到新目录
import os, shutil, tempfile

with tempfile.TemporaryDirectory() as td:
    root = os.path.join(td, 'raw')             # 造一棵小目录树
    os.makedirs(os.path.join(root, '2026-02'))
    os.makedirs(os.path.join(root, '2026-03'))
    files = [
        ('2026-02/sales_0201.csv', '日期,金额\n02-01,120\n'),
        ('2026-02/sales_0202.csv', '日期,金额\n02-02,340\n'),
        ('2026-02/notes.txt', '这批数据是测试用的\n'),
        ('2026-03/sales_0301.csv', '日期,金额\n03-01,560\n'),
        ('readme.md', '# 原始数据说明\n'),
    ]
    for rel, content in files:
        with open(os.path.join(root, rel), 'w', encoding='utf-8') as f:
            f.write(content)

    picked = []
    for folder, subdirs, names in os.walk(root):
        subdirs.sort()                         # 排序,让遍历顺序固定
        for name in sorted(names):
            if name.endswith('.csv'):          # 只要 .csv
                picked.append(os.path.join(folder, name))

    out_dir = os.path.join(td, 'csv_only')
    os.makedirs(out_dir)
    for p in picked:
        shutil.copy2(p, os.path.join(out_dir, os.path.basename(p)))
        print('挑出:', os.path.basename(os.path.dirname(p)) + '/' + os.path.basename(p))

    print('-' * 40)
    print('共挑出', len(picked), '个 CSV;csv_only 目录里:', sorted(os.listdir(out_dir)))
运行结果(实测)
挑出: 2026-02/sales_0201.csv
挑出: 2026-02/sales_0202.csv
挑出: 2026-03/sales_0301.csv
----------------------------------------
共挑出 3 个 CSV;csv_only 目录里: ['sales_0201.csv', 'sales_0202.csv', 'sales_0301.csv']
🎬 动态演示:文件综合应用的流水线——遍历 → 判断 → 处理 → 写出
关于 shutil:它是标准库里的"高级文件操作"模块。shutil.copy2(src, dst) 复制文件时连修改时间一起带过来,shutil.move() 移动(相当于剪切),shutil.rmtree() 删整棵非空目录树(os.rmdir() 只能删空目录)。注意 rmtree 不回收、不进回收站,写之前一定先 print 一下要删的路径。
✅ 本节小结:三个套路其实就是三种"文件组合拳"——追加写用 a、统计先把每行 split() 再进字典、批量处理用 os.walk + 扩展名判断。把这三段和例 6-6、例 6-7 放在一起看,你会发现"数据处理"这个词没那么玄:无非是把文件里的字符读成列表、算完之后再写回文件。

6.4 上机任务

下面四道题都在上一节的三段代码上改,一次只改一点点——每道题都必须真的建文件、真的运行、真的打开生成的文件看一眼。写不动的时候,先回到流水线图(图 6-16)问自己:"我现在卡在第几步?"

  1. 短文长度排行榜:把例 6-6 改成先统计再汇总——用列表保存 (长度, 短文) 元组,全部读完后按长度倒序打印前三名,并把结果写进 data3_rank.txt。要求:循环里不要 print,只在最后统一输出。
  2. 成绩合并的四个加强版:在例 6-7 基础上依次加上 ① 输出平均分(保留 1 位小数)、② 去掉重复的成绩、③ 只把 60 分及以上的成绩写进 data2_pass.txt、④ 把 write 改用 ' '.join(),让文件末尾不再有多余空格。
  3. 日志分析与追记:自己造 10 行访问日志(时间、IP、URL 各段用空格分隔),统计 URL 的访问次数前 3 名,然后再用 a 模式往同一个日志文件末尾追加一行 统计完成 前三名=...。做完用记事本打开,确认原来 10 行一行都没少。
  4. 目录体检脚本:在自己的上机目录里手工建出 my_dir/file1.txt、my_dir/file2.csv、my_dir/dir1/file3.py、my_dir/dir1/file4.csv 这样的结构,然后写脚本遍历整棵树,用一个字典统计各类扩展名各有几个文件,最后打印成 .csv → 2 个 这样一行一条,并按扩展名排序。
交作业时自查三件事:① 代码里有没有出现硬编码的绝对路径(比如 D:\mypython\...)?应该用相对路径或 os.path.join();② 打开文件的地方是不是都用了 with 或者成对的 close()?③ 写文件的循环跑完之后,有没有真的去读一遍那个文件,确认内容和预期一致?
配套视频 黑马程序员 · 第 90 讲 文件操作的综合案例 B站 · 把打开、读取、计算、写回串成一个完整流程
✅ 本节小结:四道题练的其实是同一件事——先想清楚数据要变成什么形态,再决定用哪个函数去变它。做完记得验证:用 read() 读回来打印、用 len() 数行数、用记事本打开看格式。程序说"成功"不算成功,文件里真的是你想要的才叫成功。
七

AI 渗透:真实数据文件 AI 关联

jsonl 语料 · 训练日志追加写 · 词表与数据集清单 · 文件操作在 AI 工程链路里的位置

这一章学的文件操作,在 AI 工程里不是"先修课",而是每天都得干的活儿:语料是文件、词表是文件、训练日志是文件、模型权重是文件、数据集清单也是文件。一个 AI 工程师排一天的时间,很大一部分花在"把数据从一个文件搬到另一个文件"上。这一节看三种最典型的"AI 里的文件",你会发现它们的写法全是本章的东西。

7.1 jsonl:大模型语料的存储格式

JSON 你见过:整个文件是一个数组或对象,json.load() 一次读进来变字典。jsonl(JSON Lines)不一样——一行一条 JSON,行与行之间互不相关。大模型的训练语料、指令微调数据、评测集,绝大多数都是这个格式:train.jsonl、sft.jsonl、eval.jsonl。

samples.jsonl:一行就是一条完整记录,行尾用 \n 分隔 samples.jsonl (UTF-8 纯文本,用记事本就能看) 1 {"id": 1, "text": "今天天气很好", "label": "正面"} 2 {"id": 2, "text": "物流太慢了", "label": "负面"} 3 {"id": 3, "text": "包装完整,下次还买", "label": "正面"} 4 ……(几十万行,每行末尾都是换行符 \n) 把第 1 行 json.loads 一下 {'id': 1, 'text': '今天天气很好', 'label': '正面'} id  → 整数 text → 字符串 label → 类别标签 得到的就是一个字典 一行结束 = 一条记录结束:所以可以边读边处理,不必把整个文件读进内存 第 3 行就算坏了,也只坏这一条,1、2、4 行照常解析
图 6-19 jsonl 的结构:文件 = 很多行,每行 = 一条完整的 JSON 记录(一个字典)
写 jsonl:一条一行,json.dumps 之后逐行 write
import json, os, tempfile

records = [
    {'id': 1, 'text': '今天天气很好', 'label': '正面'},
    {'id': 2, 'text': '物流太慢了', 'label': '负面'},
    {'id': 3, 'text': '包装完整,下次还买', 'label': '正面'},
]

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'samples.jsonl')
    with open(path, 'w', encoding='utf-8') as f:
        for r in records:
            line = json.dumps(r, ensure_ascii=False)   # 中文原样保留
            f.write(line + '\n')                        # 一条记录占一行

    with open(path, encoding='utf-8') as f:
        lines = f.readlines()
    print('文件一共', len(lines), '行,一行一条记录:')
    for i, line in enumerate(lines, 1):
        print('第', i, '行 →', line.strip())

    print('-' * 44)
    print('把第 2 行单独解析回字典:', json.loads(lines[1]))
运行结果(实测)
文件一共 3 行,一行一条记录:
第 1 行 → {"id": 1, "text": "今天天气很好", "label": "正面"}
第 2 行 → {"id": 2, "text": "物流太慢了", "label": "负面"}
第 3 行 → {"id": 3, "text": "包装完整,下次还买", "label": "正面"}
--------------------------------------------
把第 2 行单独解析回字典: {'id': 2, 'text': '物流太慢了', 'label': '负面'}
🎬 动态演示:jsonl 语料——一行一条 JSON 记录
读 jsonl:逐行 json.loads,一行坏了只跳过这一行
import json, os, tempfile

LINES = [
    '{"id": 1, "text": "今天天气很好", "label": "正面"}',
    '{"id": 2, "text": "物流太慢了", "label": "负面"}',
    '{"id": 3, "text": "这一行故意写坏了", "label":',
    '{"id": 4, "text": "包装完整", "label": "正面"}',
]

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'samples.jsonl')
    with open(path, 'w', encoding='utf-8') as f:
        f.write('\n'.join(LINES) + '\n')

    labels, bad = {}, []
    with open(path, encoding='utf-8') as f:
        for no, line in enumerate(f, 1):
            line = line.strip()
            if not line:
                continue                     # 跳过空行
            try:
                obj = json.loads(line)
            except json.JSONDecodeError:
                bad.append(no)               # 只记下坏行,继续往下读
                continue
            labels[obj['label']] = labels.get(obj['label'], 0) + 1

    print('解析成功的记录:', 4 - len(bad), '条;坏行行号:', bad)
    print('标签分布:', labels)
    print('结论:坏掉的一条被跳过,其余记录一条都没丢')
运行结果(实测)
解析成功的记录: 3 条;坏行行号: [3]
标签分布: {'正面': 2, '负面': 1}
结论:坏掉的一条被跳过,其余记录一条都没丢
为什么语料不用一个大 JSON,而用 jsonl? 一个大 JSON:[{…}, {…}, {…}, …] · 必须先把整个文件读进内存,才能 json.loads · 写到一半断电,整个文件都坏了,一条不剩 · 想在末尾补一条,也得重写整个文件 · 几十万条记录时,光读进来就吃掉几 GB 内存 (适合:配置文件、几百条以内的小结果) jsonl:一行一条记录 · for line in f 边读边处理,内存只要一行 · 第 3 行坏了只跳过它,其余照常解析 · 追加一条 = open(path, 'a') + 写一行 · 训练可以先跑 4 万条,下次从第 4 万零 1 条续 (适合:训练语料、日志、评测集) 大模型的语料动辄几百万条、训练一跑几小时——能流式读、能断点续,比"文件好看"重要得多 而 jsonl 的全部技术含量,就是本章的:for line in f + json.loads + 追加一行
图 6-20 一个大 JSON 与 jsonl 的对比:读法、坏行影响、追加方式各不相同
json.dumps 的 ensure_ascii 参数别漏:默认 ensure_ascii=True,中文会被转成 \u4eca\u5929 这样的转义序列——文件仍然能被 json.loads 正确读回来,但人眼看着是一堆乱码,而且每条记录都白白多出好几个字节。写中文语料一律用 json.dumps(obj, ensure_ascii=False)。
✅ 本节小结:jsonl = 一行一个 json.dumps 的结果。写的时候 for r in records: f.write(json.dumps(r, ensure_ascii=False) + '\n'),读的时候 for line in f: json.loads(line)。它把"文件操作"和"数据格式"两件事接在了一起:行是文件层的分隔,JSON 是数据层的结构,两者互不干扰——这正是它能扛住几十万条语料的原因。

7.2 训练日志:追加写 + 落盘

模型训练一跑就是几十分钟到几天,中途随时可能崩。所以训练脚本必须把每一轮的 loss、准确率立刻追加到日志文件里——这样即使进程被杀,前面几十轮的记录还在。写法就是上一节的套路一:a 模式,一轮一行。

训练日志:每轮追加一行,读完再统计最低 loss 出现在第几轮
import os, tempfile

# 假时间 + 假指标,保证输出每次一样(真实训练里由程序实时产出)
EPOCHS = [
    ('2026-03-02 09:00:12', 1, 1.8421, 0.4120),
    ('2026-03-02 09:03:45', 2, 1.2053, 0.6681),
    ('2026-03-02 09:07:20', 3, 0.8834, 0.7462),
    ('2026-03-02 09:11:02', 4, 0.6742, 0.8105),
    ('2026-03-02 09:14:38', 5, 0.5120, 0.8563),
]

with tempfile.TemporaryDirectory() as td:
    log = os.path.join(td, 'train.log')

    for ts, ep, loss, acc in EPOCHS:                  # 每轮训练完追加一行
        with open(log, 'a', encoding='utf-8') as f:
            f.write(ts + ' epoch=' + str(ep) + ' loss=' + format(loss, '.4f')
                    + ' acc=' + format(acc, '.4f') + '\n')

    losses, accs = [], []
    with open(log, encoding='utf-8') as f:
        for line in f:
            fields = {}
            for token in line.split():                # 时间 epoch=1 loss=… acc=…
                if '=' in token:                      # 只挑 key=value 形式的段
                    key, val = token.split('=')
                    fields[key] = float(val)
            losses.append(fields['loss'])
            accs.append(fields['acc'])

    print('每轮 loss:', losses)
    print('每轮 acc :', accs)
    print('-' * 40)
    best = min(losses)
    print('最低 loss =', best, ',出现在第', losses.index(best) + 1, '轮')
    print('5 轮一共下降:', format(losses[0] - losses[-1], '.4f'))
    print('日志文件', os.path.getsize(log), '字节,一行一轮,随时打开都能看')
运行结果(实测)
每轮 loss: [1.8421, 1.2053, 0.8834, 0.6742, 0.512]
每轮 acc : [0.412, 0.6681, 0.7462, 0.8105, 0.8563]
----------------------------------------
最低 loss = 0.512 ,出现在第 5 轮
5 轮一共下降: 1.3301
日志文件 260 字节,一行一轮,随时打开都能看
解析日志的一个小陷阱:时间戳 2026-03-02 09:00:12 中间本身就有个空格,按空格 split() 之后"第几段是 loss"就不好数了(日期一段、时刻一段,位置容易算错)。所以上面代码改成只认 key=value 形式的段:谁带等号就解析谁。字段顺序变了、以后多加一个字段,代码都不用改——这是解析日志比较稳的写法。
为什么不把指标存在变量里、训完再一次性写?因为"训完"可能永远不会到来——显存溢出、断电、手动 Ctrl+C,随便哪一下都会让内存里的列表消失。日志的作用就是把进度钉在磁盘上。这也是本章反复强调"写完要 close() / 用 with"的原因:不关闭,数据可能还躺在缓冲区里,一崩就全没了。
再往前一步:真实训练常用 tensorboard、wandb 这类工具画 loss 曲线,但它们的底层动作和这段代码一样——追加一行文本。所以你现在写的 f.write(ts + ' loss=' + ...),就是那些炫酷曲线的第一层。
✅ 本节小结:训练日志 = a 模式 + 一轮一行 + 立刻落盘。读回来统计更简单:split() 之后按 '=' 取右半边,float() 转成数字,然后 min() / index() 就能回答"第几轮最好"。能追加、能读回、能统计——这三件事凑齐了,日志才真的有用。

7.3 读词表 / 读配置 / 读数据集清单

除了语料和日志,AI 工程里还有三种"小而重要"的文件。它们的格式各不相同,但读法都落在本章的知识点上。

vocab.txt:词表

  • 一行一个词(或一个字符)
  • 行号就是它的 id
  • 用 enumerate 边读边编号 → 字典
  • 文本转向量时查这张表

config.json:配置

  • 整个文件是一个字典
  • json.load(f) 一次读完
  • 存学习率、批大小、层数
  • 改参数不用改代码

dataset/:数据集目录

  • 一个类别一个文件夹
  • os.listdir + 计数 = 分布
  • 类别不均衡要在训练前发现
  • os.walk 数文件数
读词表:一行一个词,行号即 id,做成字典
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    path = os.path.join(td, 'vocab.txt')
    with open(path, 'w', encoding='utf-8') as f:
        f.write('<pad>\n<unk>\n我\n喜\n欢\n数\n据\n分\n析\n')

    word2id = {}
    with open(path, encoding='utf-8') as f:
        for idx, line in enumerate(f):          # 行号就是 id
            w = line.strip()
            if w:                               # 跳过空行
                word2id[w] = idx

    print('词表大小:', len(word2id), '个')
    print('前 4 项:', list(word2id.items())[:4])
    print('“数”的 id =', word2id['数'])
    print('-' * 40)
    text = '我喜欢数据分析!'                     # 最后一个字符不在词表里
    ids = [word2id.get(ch, word2id['<unk>']) for ch in text]
    print('文本:', text)
    print('转向量:', ids)
    print('(不在词表里的字符会落到 <unk>,id =', word2id['<unk>'], ')')
运行结果(实测)
词表大小: 9 个
前 4 项: [('<pad>', 0), ('<unk>', 1), ('我', 2), ('喜', 3)]
“数”的 id = 5
----------------------------------------
文本: 我喜欢数据分析!
转向量: [2, 3, 4, 5, 6, 7, 8, 1]
(不在词表里的字符会落到 <unk>,id = 1 )
遍历数据集目录:统计每个类别、每个划分下有多少样本
import os, tempfile

with tempfile.TemporaryDirectory() as td:
    root = os.path.join(td, 'dataset')          # 造一个 train/val × pos/neg 的目录
    for split in ['train', 'val']:
        for label, n in [('pos', 3), ('neg', 2)]:
            d = os.path.join(root, split, label)
            os.makedirs(d)
            for i in range(n):
                name = split + '_' + label + '_' + str(i) + '.txt'
                with open(os.path.join(d, name), 'w', encoding='utf-8') as f:
                    f.write('样本' + str(i))

    total = 0
    for split in sorted(os.listdir(root)):      # 第一层:train / val
        for label in sorted(os.listdir(os.path.join(root, split))):
            d = os.path.join(root, split, label)
            n = len([x for x in os.listdir(d) if x.endswith('.txt')])
            total += n
            print(split + '/' + label, '→', n, '个样本')

    print('-' * 40)
    print('数据集总计:', total, '个样本')
    print('(类别只有两种,正负样本 3 : 2,训练前就能看出不均衡)')
运行结果(实测)
train/neg → 2 个样本
train/pos → 3 个样本
val/neg → 2 个样本
val/pos → 3 个样本
----------------------------------------
数据集总计: 10 个样本
(类别只有两种,正负样本 3 : 2,训练前就能看出不均衡)
三个文件、三种读法,但思路是同一个:先问"这个文件的一行(或一个文件)代表什么",再决定用 for line in f 还是 json.load 还是 os.listdir。格式决定读法,读法决定数据变成什么结构——这句话可以一直用到第 8 章读 Excel。
✅ 本节小结:词表是"一行一个词 + 行号当 id",用 enumerate 一句就变成字典;配置文件是"整个文件一个字典",json.load() 一次读完;数据集是"一个类别一个目录",os.listdir 数一数就是分布。这三种小文件,是每个 AI 项目的入口。

7.4 文件操作在 AI 工程里的位置

把这一节看到的文件按 AI 工程的时间线排一下,你会发现一条完整的链路上每一步都在读写文件——而且用的全是本章这几个函数。

阶段在读写什么文件用到的本章知识
数据准备原始语料 .txt / .csv,清洗后写成 .jsonlfor line in f、split()、json.dumps、os.walk
训练训练日志 .log(每轮追加)、检查点 .ptopen(..., 'a')、write()、二进制模式 'wb'
评估预测结果 .csv、指标汇总 .jsoncsv.writer、json.dump、字典统计
推理 / 部署模型权重 .bin / .safetensors、配置 config.json、词表 vocab.txtopen(..., 'rb')、json.load、按行读词表
实验管理每次实验一个目录:参数、日志、指标、产物os.makedirs、shutil.copy2、路径拼接
回头看这一章:AI 工程里的"数据流",物理上就是文件流。爬下来的 20 万条评论要写成 jsonl,训练每一轮的 loss 要追加进 log,评估结果要导出成 csv 再读回来画图,模型权重和词表要存成文件下次加载——这些活儿没有一行用到"模型",全是 open、for line in f、split、write。所以文件操作不是"基础语法练习",它是 AI 工程链路的传送带:数据在磁盘和内存之间搬来搬去的那一段,全靠它。下一章学 NumPy 时你会看到 np.loadtxt() 这样的函数——它内部做的,正是这一节里"打开 → 按行读 → 转成数字 → 放进数组"那几步。
✅ 本节小结:数据准备 → 训练 → 评估 → 推理 → 实验管理,五个阶段五次读写文件。这一章练的四件事——按行读、按行写、追加、遍历目录——正好是这条链路里出现频率最高的四个动作。把例 6-6、例 6-7 和三个日志/批量案例写熟,你就已经会写 AI 项目里 80% 的"数据处理脚本"了。
八

交互演示区

改参数、点按钮,立刻看结果 · 浏览器内 JS 模拟,输出已与 Python 3.14 逐字对齐

演示一:文字 → 字节 编码模拟器

对应 1.4 节。输入任意文字,选一种编码,看它变成哪几个字节;再用另一种编码去解码,看是得到乱码还是 UnicodeDecodeError。默认这一组正好演示最经典的坑:“你好A”在 UTF-8 下是 7 字节、GBK 下是 5 字节,UTF-8 编出来的字节拿去按 GBK 解码就是乱码;反过来 GBK 的字节按 UTF-8 解码会直接报错,ASCII 连一个汉字都编不出来。

点上面的按钮试试

演示二:文件指针 tell() / seek() 模拟器

对应 3.3 节。文件内容固定是 TomLinda(8 个字符、没有换行符)。点一次走一步:read(n) 从指针处读 n 个字符、readline() 读一行、seek(n) 把指针挪到第 n 个字符、tell() 看指针现在在哪。下方每一步都会显示“指针从几走到几”,再画出指针位置;点“重置”可以清空步骤从头再来(试试 seek(3) 之后再 read(5),能再读出一次 Linda)。

点上面的按钮试试

演示三:打开模式 r / w / a / x

对应 2.2 节。文件里原来已经有“第一行 / 第二行”(在 Windows 文本模式下 \n 存成 \r\n,共 20 字节)。选一种模式打开,看打开后文件内容变成什么、指针停在哪;再取消勾选“文件已经存在”,看文件不存在时每种模式的真实行为(r 抛 FileNotFoundError,w / a / x 会新建文件,x 遇到已存在的文件抛 FileExistsError)。

点上面的按钮试试

演示四:CSV 解析 + 最高工资(例 6-5)

对应 4.4 节。左边这段文本相当于 user_info.csv:csv.reader 一行行读成字符串列表,next() 跳过表头,int(row[3]) 把第 4 列工资转成整数收进列表,最后 max() 求最高工资。可以改数据试试:加一行、改工资、故意把工资写成“5000元”,看 Python 抛什么异常;引号里的逗号不算分隔符(如 "张,三")。

点上面的按钮试试

演示五:虚拟目录 my_dir(listdir / scandir / 递归遍历)

对应 5.2—5.5 节。这里用 JS 数组描述了一棵 my_dir 目录树:dir1 里三个文件、dir2 里还有一个 sub 子目录、根目录下还有两个文件。选 listdir 只拿到一串名字;选 scandir 会带上 is_dir() 的 True / False 标记;选“递归遍历”把整棵树按缩进打印出来。注意 listdir 的返回顺序由文件系统决定,这里按 Windows 上常见的字母序展示。

点上面的按钮试试

演示六:例 6-7 成绩合并 → 转浮点 → 排序 → 写文件

对应 6.2 节。这段文本相当于 data2.txt:一行对应一组成绩、成绩之间用空格分隔。点按钮相当于走一遍例 6-7 的流水线:strip() → split() 得到字符串列表 → extend() 合并 → float() 转浮点 → sort() 升序 → 把结果按空格分隔写进 data2_sorted.txt。注意 str(85.0) 是 '85.0',整数成绩也会带小数点。

点上面的按钮试试
这些面板都是照抄 Python 算法用 JS 重写的:字符 → 字节的编码表、tell() / seek() 的指针位置、r/w/a/x 四种打开模式的行为、csv.reader 的拆行拆列、listdir / scandir 的返回结果、sorted() / max() / float() 的规则,都和 Python 3.14 实际跑出来的结果逐字对齐。把面板里的数据复制到上面任意一段示例代码里再跑一遍,输出是一样的。
结

知识点总结卡 · 易错清单 · 作业

复习用:下面每一条都能自己讲出来,这一章就算过关

一、知识点总结卡

文件与编码

  • 文件 = 数据的持久存储,本质是磁盘上的一串字节
  • 文本文件:存字符串,单一编码,按 \n 分行(txt / csv / py)
  • 二进制文件:存字节串,需解码才能看(jpg / mp3 / mp4 / exe)
  • s.encode('utf-8') 字符 → 字节;b.decode('utf-8') 字节 → 字符
  • 中文在 UTF-8 下占 3 字节,GBK 下占 2 字节,ASCII 根本编不了
  • 格式对应库:txt 内置 / csv → csv · pandas / excel → openpyxl · pandas / json → json

打开与关闭

  • open(file, mode, encoding),mode 默认 'rt'
  • r 只读、文件不存在报错;w 清空重写;a 末尾追加;x 新建、已存在报错
  • t 文本(默认)/ b 二进制 / + 可读可写
  • 路径里 \ 要转义成 \\,或写 r"D:\test.txt"
  • 拼路径优先用 os.path.join(),别手工 + '\\'
  • 推荐写法只有一个:with open(...) as f:

读写与文件指针

  • read(n) 读 n 个字符;read() 全读
  • readline() 一行;readlines() 全部行 → 列表
  • for line in f 逐行迭代,最省内存,大文件用它
  • 每行末尾带 \n,用 .strip() 去掉
  • write(s) 返回写入的字符数;writelines() 不自动加换行
  • tell() 当前指针位置;seek(offset, whence) 移动指针

CSV 文件

  • 逗号分隔的纯文本表格,可用记事本和 Excel 打开
  • 写:csv.writer(f) → writerow() / writerows()
  • 读:csv.reader(f) 迭代,每行是字符串列表
  • 开文件必须写 newline='',否则 Windows 上多空行
  • 读数字要自己转:int(row[3]) / float(...)
  • 表头用 next(reader) 跳过
  • DictReader 按表头取字段(选学)

目录操作

  • os.getcwd() 当前目录;os.chdir(p) 切换
  • os.listdir(p) 返回名字列表(不含子目录内容)
  • os.scandir(p) 返回 DirEntry,有 .name / .path / .is_file() / .is_dir()
  • os.mkdir() 建一级;os.makedirs() 建多级
  • os.rmdir() 只能删空目录;非空用 shutil.rmtree()
  • os.path.exists / isfile / isdir / join / basename / splitext

综合应用套路

  • 固定四步:读 → 处理 → 写 → 核对
  • 读进来的是字符串,参与计算前先 int() / float()
  • 多行数据先 split() 成列表,再 extend() 合并
  • 写完一定再读一遍验证,别凭感觉
  • 批量处理目录:遍历 → 判断扩展名 → 处理 → 输出
  • AI 语料多用 jsonl:一行一条 JSON,可流式读

二、易错清单(都在这台机器上真实踩过)

现象 / 报错原因正确做法
写完文件,打开一看是空的 没 close(),内容还在缓冲区没刷到磁盘 用 with open(...) as f:,自动关
FileNotFoundError: [Errno 2] No such file or directory r 模式打开一个不存在的文件 先 os.path.exists() 判断;或改用 w/a 模式创建
CSV 每两行之间多一个空行 Windows 换行符 \r\n 被写了两遍 open(path, 'w', newline='', encoding='utf-8')
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc4 文件其实是 GBK 编码,却用 UTF-8 去读 用记事本另存为 UTF-8,或 encoding='gbk' 去读
UnicodeEncodeError: 'ascii' codec can't encode character 默认编码是 ASCII,写不了中文 open(..., encoding='utf-8'),永远显式写编码
读出来的数字算不了,TypeError: unsupported operand CSV / 文本读进来的都是字符串 先 int(row[3]) 或 float(sc) 转换
PermissionError: [Errno 13] 文件正被 Excel / WPS 打开占用,或被设成只读 先关掉占用它的程序,再运行
os.rmdir() 报 OSError: Directory not empty rmdir 只能删空目录 先清空内容,或用 shutil.rmtree()
TypeError: write() argument must be str, not int write() 只能写字符串 f.write(str(n) + '\n')
UnsupportedOperation: can't do nonzero cur-relative seeks 文本模式下 seek 只能相对文件头 用 f.seek(n, 0);需要任意跳转就用 'rb' 二进制模式

三、课后作业(四题,都要"真的读写文件")

本章作业

  1. 编码探查:把 '中华女子学院' 分别用 utf-8、gbk 编码,打印两种字节序列与各自的字节数;再用 gbk 去解码 utf-8 的字节,把结果和报错都记下来。
  2. 成绩单:自己造一个 scores.csv(姓名, 语文, 数学, 英语 四列,至少 6 行),用 csv 读入,算出每人总分与班级每科平均分,写入 scores_out.csv(原四列 + 总分列)。
  3. 目录清单:写一个递归函数 scan(path, indent=0),打印指定目录下的树形结构,并统计共有多少个 .py 文件、总字节数,把结果写到 report.txt。
  4. 日志统计:造一个 access.log(每行格式 2026-10-21 10:00:01 192.168.1.5 GET /index.html,至少 12 行),统计出现次数最多的前 3 个 IP 与各 IP 的访问次数,按次数降序打印。

提交要求:每题给出代码 + 运行结果截图 + 生成的文件;所有读写都显式写 encoding='utf-8';一律用 with open(...) as f:;变量名要能读懂。

四、下讲预告

第 7 次课 · 第 7 章 NumPy 数值计算
数组的创建与访问 · 向量化运算 · 统计计算与矩阵操作 · 成绩表加权总分 —— 数据分析真正开始的地方(43 段实测代码 + 16 张插图 + 12 个动态演示图 + 6 个交互面板)
进入第 7 次课 →
本章自测(不查资料,先自己在纸上写)
  1. '你好' 用 utf-8 编码后有几个字节?用 gbk 呢?为什么不一样?
  2. 下面两次 open 有什么区别:open('a.txt','w') 和 open('a.txt','a')?文件已存在时哪个会把原内容清空?
  3. 文件内容 'TomLinda',依次执行 read(3)、tell()、read(5)、seek(3,0)、read(5),每一步的结果是什么?
  4. 写 CSV 时为什么不加 newline='' 会多出空行?
  5. os.listdir() 和 os.scandir() 返回的东西有什么不同?要判断"这是个文件还是文件夹",用哪个更方便?
  6. 把"读成绩 → 排序 → 写回文件"写成完整程序,一共几步?每一步的数据形态是什么?