Python文件操作学习(已归档)
Python文件操作学习
目标:从不会文件操作开始,逐步掌握科研数据目录管理、文件遍历、CSV 读取和基础统计。项目连接:批量读取受试者 PPG/rPPG 数据、为后续实验流水线做准备当前能力:L0 目标能力:L2学习原则:每一步先运行,再自己修改;完成后留下运行、修改、解释三类证据。
阶段一:路径与文件基础
Step 1:认识当前工作目录
📖 pathlib 安装与工作目录详解
1. pathlib 安装说明
pathlib 是 Python 3.4+ 的标准库模块,不需要额外安装。如果你使用的是 Python 3.4 或更高版本,可以直接使用:
1
| from pathlib import Path
|
常见错误处理:
- 如果看到
ModuleNotFoundError: No module named 'pathlib',说明你的 Python 版本太旧(<3.4)
- 解决方案:升级 Python 到 3.4+,或者使用
pip install pathlib(对于旧版本)
验证 Python 版本:
1 2 3
| python --version
python3 --version
|
2. 工作目录详解
工作目录是你执行 Python 脚本时所在的目录,不是脚本文件所在的目录。
示例场景:
1 2 3 4 5 6 7 8 9 10 11
|
cd /home/yhl/Workspace/rknn
python ../Test1.py
|
关键点:
Test1.py 在 /home/yhl/Workspace/ 目录下
- 你在
/home/yhl/Workspace/rknn/ 目录下运行脚本
- 工作目录是
/home/yhl/Workspace/rknn/ ,不是脚本所在目录
Path.cwd() 返回的是工作目录:/home/yhl/Workspace/rknn
验证示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| from pathlib import Path
print("工作目录:", Path.cwd())
print("脚本目录:", Path(__file__).parent)
relative_path = Path("tmp/data/1.txt") print("相对路径存在:", relative_path.exists())
absolute_path = Path("D:/WorkSpace/opencv/tmp/data/1.txt") print("绝对路径存在:", absolute_path.exists())
|
实际应用建议:
- 优先使用相对路径:代码更灵活,便于移植
- 理解工作目录:调试路径问题时首先检查工作目录
- 使用
__file__ 获取脚本位置:当需要相对于脚本的路径时
- 使用
Path.cwd() 获取工作目录:当需要相对于当前目录的路径时
1 2 3 4 5 6
| from pathlib import Path
current = Path.cwd() print(current) print(current.exists()) print(current.is_dir())
|
理解:Path.cwd() 返回当前工作目录;exists() 判断路径是否存在;is_dir() 判断是否为目录。
自己做:打印当前目录的名称 current.name 和父目录 current.parent。
Step 2:拼接路径
📖 Path 对象属性详解
Path 对象提供了许多有用的属性,用于获取路径的不同部分:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
| from pathlib import Path
path = Path("/home/yhl/Workspace/data/experiment_2026-08-18.csv")
print("属性详解:") print(f"1. name: {path.name}") print(f"2. stem: {path.stem}") print(f"3. suffix: {path.suffix}") print(f"4. parent: {path.parent}") print(f"5. parts: {path.parts}") print(f"6. anchor: {path.anchor}") print(f"7. is_absolute(): {path.is_absolute()}") print(f"8. exists(): {path.exists()}") print(f"9. is_file(): {path.is_file()}") print(f"10. is_dir(): {path.is_dir()}")
|
属性详解表格:
| 属性 |
说明 |
示例值 |
使用场景 |
name |
完整文件名(含扩展名) |
experiment_2026-08-18.csv |
显示文件名、文件匹配 |
stem |
文件名(不含扩展名) |
experiment_2026-08-18 |
生成新文件名、日志命名 |
suffix |
文件扩展名 |
.csv |
文件类型判断、过滤 |
parent |
父目录路径 |
/home/yhl/Workspace/data |
构建相对路径、目录导航 |
parts |
路径各部分元组 |
('/', 'home', 'yhl', 'Workspace', 'data', 'experiment_2026-08-18.csv') |
路径分析、跨平台处理 |
anchor |
根目录 |
/ |
判断是否为绝对路径 |
is_absolute() |
是否为绝对路径 |
True |
路径类型判断 |
exists() |
路径是否存在 |
True/False |
文件操作前检查 |
is_file() |
是否为文件 |
True/False |
文件/目录区分 |
is_dir() |
是否为目录 |
True/False |
文件/目录区分 |
实用技巧:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
| new_path = path.with_suffix('.txt') new_path = path.with_stem('new_name')
new_file = path.parent / "processed" / path.stem + "_processed" + path.suffix
csv_files = [f for f in path.parent.iterdir() if f.suffix == '.csv']
for file in path.parent.glob("*.txt"): new_name = file.stem + "_backup" + file.suffix file.rename(file.parent / new_name)
|
📖 报错解析:TypeError: unsupported operand type(s) for +: ‘WindowsPath’ and ‘str’
Path 对象与字符串是不同类型,+ 运算符未定义;更常见的是优先级陷阱:/(除法)优先级高于 +(加法),混用时 Python 先算 / 得到 WindowsPath,再执行 + 就报 TypeError。路径拼接必须用 / 或 joinpath()。
- 报错原因:
WindowsPath(pathlib 的路径对象)与 str(普通字符串)是不同数据类型,+(字符串相加)在 WindowsPath + 'str' 上没有定义 → TypeError。在 Windows/Linux 上分别表现为 WindowsPath / PosixPath。
- 为什么不能
+ :字符串拼接会破坏路径语义——/ 分隔符、跨平台反斜杠、转义规则都会被污染;pathlib 刻意只支持用 / 运算符拼接路径。
- 正确方法:
1 2 3 4 5 6 7 8 9 10 11 12 13
| from pathlib import Path
root = Path("numpy_file_demo")
f1 = root / "data" / "file.csv"
f2 = root.joinpath("data", "file.csv")
print(str(f1))
f3 = root / "notes.txt"
|
- 记忆要点:拼接只能用
/ 和 joinpath();只有”显示/输出”才用 str() 转字符串,且转换后不要再参与路径运算。
📌 优先级陷阱(最常触发的写法)
文档中这种混合写法会报错:new_file = path.parent / "processed" / path.stem + "_processed" + path.suffix
报错链路(根本原因) :
1 2 3 4 5
| Python 运算符优先级:/(除法)> +(加法) ↓ path.parent / "processed" / path.stem ← 先执行(得到 WindowsPath) ↓ 再执行 WindowsPath + "_processed" + path.suffix ← WindowsPath + str → TypeError
|
path.stem + "_processed" + path.suffix 本意是先拼出字符串文件名的后半段,但因为 + 优先级低于 /,它根本没有机会先执行——/ 已经把全部路径部分算完了。
- 同理:任何”路径
/ 与字符串 + 混写”的长表达式都有可能踩这个坑。
正确写法(先用括号把字符串拼接包起来,或直接用 f-string):
1 2 3 4 5 6 7 8
| new_file = path.parent / "processed" / (path.stem + "_processed" + path.suffix)
new_file = path.parent / "processed" / f"{path.stem}_processed{path.suffix}"
new_file = path.parent.joinpath("processed", f"{path.stem}_processed{path.suffix}")
|
为什么推荐使用 Path 对象?
- 跨平台兼容:自动处理 Windows/Linux 路径差异
- 链式调用:
path.parent / "subdir" / "file.txt" 更直观
- 类型安全:返回的是 Path 对象,不是字符串
- 丰富方法:提供
glob(), rglob(), stat() 等实用方法
1 2 3 4 5 6 7 8 9 10 11 12
| from pathlib import Path
root = Path.cwd() data_dir = root / "data" file_path = data_dir / "subject_001.csv"
print(data_dir) print(file_path) print(file_path.suffix) print(file_path.stem) print(file_path.name) print(file_path.parent)
|
重点:使用 Path / 子路径,不要手动拼接字符串,也不要依赖 Windows 的反斜杠。
自己做:把文件名改成 subject_002.csv,观察 stem 和 name 的变化。
Step 3:创建目录
1 2 3 4 5 6 7 8 9 10 11
| from pathlib import Path
work_dir = Path("numpy_file_demo") raw_dir = work_dir / "raw" result_dir = work_dir / "results"
raw_dir.mkdir(parents=True, exist_ok=True) result_dir.mkdir(parents=True, exist_ok=True)
print(raw_dir.exists()) print(result_dir.exists())
|
parents=True:父目录不存在时一起创建
exist_ok=True:目录已经存在时不报错
自己做:再创建 work_dir / "logs",重复运行代码,确认不会报错。
📖 touch():创建空文件
Path.touch() 创建空文件(类似 Linux touch:文件不存在则创建,已存在则更新时间戳且不报错)。
1 2 3 4
| from pathlib import Path
path = Path("numpy_file_demo") / "notes.txt" path.touch(exist_ok=True)
|
- 与
mkdir() 的区别:mkdir 建目录,touch 建文件。
- 用途:占位文件、日志文件初始化、确保目标文件存在后再写入。
笔记:这个是否有像mkdir一样的parent=True,父目录不存在的时候创建父目录
阶段二:遍历与筛选文件
Step 4:遍历一层目录
1 2 3 4 5 6
| from pathlib import Path
folder = Path("numpy_file_demo")
for item in folder.iterdir(): print(item, "目录" if item.is_dir() else "文件")
|
iterdir() 只遍历当前目录,不递归进入子目录。
自己做:只打印文件,跳过目录:
1 2 3
| for item in folder.iterdir(): if item.is_file(): print(item.name)
|
Step 5:递归查找 CSV
1 2 3 4 5 6 7 8 9
| from pathlib import Path
folder = Path("numpy_file_demo") csv_files = list(folder.rglob("*.csv"))
for path in csv_files: print(path)
print(f"共找到 {len(csv_files)} 个 CSV 文件")
|
场景:受试者数据可能按“原始数据/受试者/日期”多层存放,rglob("*.csv") 可以递归查找。
📖 glob / rglob:通配符匹配文件(详解)
glob 是”用通配符模式匹配文件名”的机制:*、?、[] 等符号描述一批文件,rglob 递归搜索所有子目录。
- 为什么用 glob:不必写死文件名,用模式匹配一批文件(这正是 Step 5 用
rglob("*.csv") 的原因)。
- 通配符速查:
| 模式 |
含义 |
示例 |
* |
匹配任意多个字符(含 0 个) |
*.csv → 所有 CSV 文件 |
? |
匹配任意单个字符 |
subject_?.csv → subject_1.csv、subject_a.csv |
[abc] |
匹配括号内任一字符 |
data[12].csv → data1.csv / data2.csv |
glob vs rglob:
folder.glob("*.csv"):只在 folder 当前层匹配;
folder.rglob("*.csv"):递归所有子目录——受试者数据按”原始数据/受试者/日期”多层存放时用这个;
返回:生成器(可 list() 转列表);无匹配时为空,不会报错。
类比:像命令行 ls *.csv / find . -name "*.csv" 的 Python 版。
验证:对比 list(folder.glob("*.csv")) 与 list(folder.rglob("*.csv")) 的结果数量,观察递归的效果。
iterdir() vs glob() :两者都只遍历当前层(不递归),但用途不同——
iterdir():返回全部子项(无过滤,逐个得到 Path);”只要全部子项”时用;
glob(pattern):按通配符模式过滤(如 *.csv);”只要匹配模式的一批”时用;
- 需递归 → 用
rglob()(Step 5 的场景)。
一句话:iterdir 是”全量列表”,glob/rglob 是”按模式筛选”。
自己做:分别查找 *.txt 和 *.npy,观察没有匹配文件时返回什么。
阶段三:读写文本和 CSV
Step 6:写入文本文件
1 2 3 4 5 6
| from pathlib import Path
path = Path("numpy_file_demo") / "notes.txt" path.write_text("subject_001\nsubject_002\n", encoding="utf-8")
print(path.read_text(encoding="utf-8"))
|
write_text():写入文本,会覆盖原文件
read_text():读取整个文本
- 中文文本明确指定
encoding="utf-8"
📖 write_text() 与 Linux echo 重定向的对应
path.write_text("...") ≈ Linux echo "..." > 文件:都是”写入/覆盖文件内容”。
Step 7:使用 CSV 模块写入和读取
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
| import csv from pathlib import Path
path = Path("numpy_file_demo") / "signal.csv"
with path.open("w", newline="", encoding="utf-8") as f: writer = csv.writer(f) writer.writerow(["time", "value"]) writer.writerows([ [0.0, 0.10], [0.1, 0.20], [0.2, 0.15], ])
with path.open("r", newline="", encoding="utf-8") as f: reader = csv.DictReader(f) for row in reader: print(row["time"], row["value"])
|
重点:with 会自动关闭文件,即使读取或写入过程中发生异常也更安全。
笔记:如果path对应的文件不存在,这里会自动创建一个新文件吗?是哪一行代码创建的?
📖 open() 与本文档用过的文件操作方法/函数速查
open() 是内置函数,打开文件并返回文件对象;它是 Path.open()、write_text()、csv 读写等一切文件操作的底层基础。
- open 是什么:
open(path, mode, encoding=...) → 文件对象;with open(...) as f: 自动关闭(异常也安全);常用 mode:w 写(覆盖)、r 读、a 追加、+ 读写、b 二进制。
- 本文档出现过的文件方法/函数速查:
| 名称 |
类型 |
作用 |
Path.cwd() |
类方法 |
当前工作目录 |
Path.mkdir() |
方法 |
创建目录(parents/exist_ok) |
Path.touch() |
方法 |
创建空文件 |
Path / 子路径 |
运算符 |
路径拼接 |
Path.iterdir() |
方法 |
遍历当前层全部子项 |
Path.glob() |
方法 |
当前层按模式匹配 |
Path.rglob() |
方法 |
递归按模式匹配 |
Path.write_text() |
方法 |
写入文本(覆盖) |
Path.read_text() |
方法 |
读取整个文本 |
Path.open() |
方法 |
打开文件对象(配合 with) |
open() |
内置函数 |
通用打开文件 |
path.stem/.suffix/.name/.parent |
属性 |
路径各组成部分 |
- 记忆:
Path 对象的方法≈”面向对象的文件操作”;open()≈”传统函数式”,两者都能用,推荐在前者项目里保持一致。
笔记:这个📖 open() 与本文档用过的文件操作方法/函数速查不要放这里,放更前面一点,我希望你重构这个文档的逻辑链条,让学习循序渐进
Step 8:用 NumPy 读取数值 CSV
1 2 3 4 5 6 7 8 9 10 11 12 13
| import numpy as np from pathlib import Path
path = Path("numpy_file_demo") / "signal.csv" data = np.loadtxt(path, delimiter=",", skiprows=1)
time = data[:, 0] value = data[:, 1]
print(data.shape) print(time) print(value) print(np.mean(value))
|
适合格式简单、主要由数值构成的实验数据。CSV 中如果有复杂文本、缺失值或混合类型,应改用 Python 标准库的 csv 模块处理。
阶段四:批量处理实验数据
Step 9:批量读取并计算平均值
生成模拟实验数据脚本
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
| """为 Step 9 生成模拟实验数据:多个受试者的随机信号 CSV""" import numpy as np from pathlib import Path
def make_signal(n=10, seed=0): """生成一条模拟信号:时间列 + 随机信号列(正弦 + 噪声,模拟 PPG)""" rng = np.random.default_rng(seed) t = np.linspace(0, 2 * np.pi, n) signal = np.sin(2 * np.pi * t / 50) + 0.3 * rng.normal(size=n) return t, signal
def gen_files(folder="numpy_file_demo", n_subjects=5, n_points=10): """生成 n_subjects 个 CSV,每个放在独立子目录(演示 rglob 递归)""" folder = Path(folder) for i in range(n_subjects): sub = folder / f"subject_{i + 1:03d}" sub.mkdir(parents=True, exist_ok=True)
t, signal = make_signal(n_points, seed=i) path = sub / f"subject_{i + 1:03d}_rest_signal.csv" np.savetxt(path, np.column_stack((t, signal)), delimiter=",", header="time,value", comments="") print(f"已生成:{path},{n_points} 个采样点")
gen_files()
|
正式脚本
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
| from pathlib import Path import numpy as np
def compute_average(folder: str): """批量读取文件夹内所有 CSV 信号,返回逐采样点的平均值""" folder = Path(folder) signals = []
for path in folder.rglob("*.csv"): try: data = np.loadtxt(path, delimiter=",", skiprows=1) if data.ndim != 2 or data.shape[1] < 2: print(f"跳过格式异常文件:{path}") continue signals.append(data[:, 1]) print(f"已读取:{path},{len(data)} 个采样点") except (ValueError, OSError) as exc: print(f"跳过文件:{path},原因:{exc}")
if not signals: raise RuntimeError("没有找到有效的 CSV 信号文件")
lengths = {len(signal) for signal in signals} if len(lengths) != 1: raise ValueError("不同文件的信号长度不一致,不能直接求平均")
return np.mean(np.array(signals), axis=0)
average = compute_average("numpy_file_demo") print(average)
|
项目连接:这是”批量读取多个受试者信号 → 检查长度 → 堆叠 → 求平均“的最小版本。
笔记:将csv表格的这套处理流程沉淀成知识点,并在numpy专项中添加np.loadtxt、np.mean等之类用到的函数的相关用法,注意要做好引用,这涉及两个库之间的联动,需要做好双链。
这里signals.append(data[:, 1]) # 只取第 2 列(下标 1)作为信号值中的data[:, 1]的用法很妙,把这一类取值的用法加入python笔记中,
| 写法 |
取的是什么 |
结果 |
维度 |
data[0, 1] |
第 0 行、第 1 列(单个值) |
20 |
标量 |
data[0, :] |
第 0 行、所有列 |
[10, 20, 30] |
1D |
data[:, 0] |
所有行、第 0 列 |
[10, 40, 70] |
1D |
data[:, 1] |
所有行、第 1 列 |
[20, 50, 80] |
1D ✅ |
data[1:3, 0:2] |
第 1~2 行,第 0~1 列 |
[[40,50],[70,80]] |
2D |
使用类似于上面这样的表格的形式
Step 10:文件名与实验元数据
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| from pathlib import Path
path = Path("subject_001_rest_20260817.csv")
parts = path.stem.split("_")
subject_id = parts[0] + "_" + parts[1] condition = parts[2] date = parts[3]
print(subject_id, condition, date)
|
真实项目中不要过度依赖文件名解析;更稳妥的方式是配套一个 metadata CSV,记录受试者编号、条件、日期和文件路径。
笔记:这里的split是标准库的方法还是pathlib库里的方法,添加使用说明,放在python笔记的字符串相关位置
阶段五:错误处理与可复现
常见错误
- 相对路径相对于“当前工作目录”,不一定相对于 Python 文件所在目录。
- Windows 路径优先使用
Path,避免反斜杠转义问题。
write_text() 默认覆盖文件,重要数据写入前要确认路径。
- 空目录、文件不存在、CSV 表头、缺失值和列数不一致都要处理。
- 不能假设所有 CSV 的采样率、长度和列含义相同。
阶段六:高级文件操作技巧
在掌握基础文件操作后,我们需要更多高级技巧来处理复杂的科研数据场景。
Step 11:文件批量处理
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
| from pathlib import Path import csv
def merge_csv_files(folder: Path, output_file: Path): """把目录下所有 CSV 合并成一个文件(表头只保留一次)""" all_data = []
for csv_file in folder.glob("*.csv"): with open(csv_file, 'r', encoding='utf-8') as f: reader = csv.reader(f) header = next(reader) for row in reader: all_data.append(row)
with open(output_file, 'w', newline='', encoding='utf-8') as f: writer = csv.writer(f) writer.writerow(header) writer.writerows(all_data)
return len(all_data)
def batch_rename(folder: Path, old_pattern: str, new_pattern: str): """把匹配 old_pattern 的文件改名(模式中 * 是通配符)""" renamed_count = 0
for file in folder.glob(old_pattern): new_name = file.name.replace(old_pattern.split('*')[0], new_pattern.split('*')[0]) new_path = file.parent / new_name file.rename(new_path) renamed_count += 1
return renamed_count
def find_large_files(folder: Path, size_mb: int = 100): """递归查找大于 size_mb 的文件,按大小从大到小返回""" large_files = [] size_bytes = size_mb * 1024 * 1024
for file in folder.rglob("*"): if file.is_file() and file.stat().st_size > size_bytes: large_files.append((file, file.stat().st_size / 1024 / 1024))
return sorted(large_files, key=lambda x: x[1], reverse=True)
|
Step 12:文件监控与自动化
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
| from pathlib import Path import time from watchdog.observers import Observer from watchdog.events import FileSystemEventHandler
def monitor_folder(folder: Path, interval: int = 5): """通过"快照对比"找出新增/删除的文件,每 interval 秒检查一次""" initial_files = set(f.name for f in folder.iterdir())
while True: current_files = set(f.name for f in folder.iterdir())
new_files = current_files - initial_files deleted_files = initial_files - current_files
if new_files: print(f"新增文件: {new_files}") if deleted_files: print(f"删除文件: {deleted_files}")
initial_files = current_files time.sleep(interval)
class MyHandler(FileSystemEventHandler): """继承 watchdog 事件处理器,覆写感兴趣的回调方法""" def on_created(self, event): if not event.is_directory: print(f"文件创建: {event.src_path}")
def on_modified(self, event): if not event.is_directory: print(f"文件修改: {event.src_path}")
def start_monitor(folder: Path): """事件驱动监控:操作系统主动通知,比轮询更及时省资源""" event_handler = MyHandler() observer = Observer() observer.schedule(event_handler, str(folder), recursive=True) observer.start()
try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join()
|
Step 13:数据备份与版本管理
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
| from pathlib import Path import shutil from datetime import datetime
def create_backup(source: Path, backup_dir: Path): """创建带时间戳的备份副本(目录整体复制或单文件复制)""" timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") backup_name = f"{source.name}_{timestamp}" backup_path = backup_dir / backup_name
if source.is_dir(): shutil.copytree(source, backup_path) else: shutil.copy2(source, backup_path) return backup_path
def incremental_backup(source: Path, backup_dir: Path): """按相对路径镜像到备份目录,仅复制 mtime 比备份新的文件""" backup_dir.mkdir(exist_ok=True)
for file in source.rglob("*"): if file.is_file(): rel_path = file.relative_to(source) backup_file = backup_dir / rel_path
if not backup_file.exists() or \ file.stat().st_mtime > backup_file.stat().st_mtime: backup_file.parent.mkdir(parents=True, exist_ok=True) shutil.copy2(file, backup_file) print(f"备份: {rel_path}")
def clean_old_backups(backup_dir: Path, keep_days: int = 30): """删除修改时间早于 keep_days 天的备份条目""" cutoff_time = datetime.now().timestamp() - (keep_days * 24 * 3600)
deleted_count = 0 for item in backup_dir.iterdir(): if item.stat().st_mtime < cutoff_time: if item.is_dir(): shutil.rmtree(item) else: item.unlink() deleted_count += 1
return deleted_count
|
Step 14:配置文件处理
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
| import json import yaml from pathlib import Path
def load_json_config(config_path: Path): """读取 JSON 文件并解析为 Python 对象(dict/list)""" with open(config_path, 'r', encoding='utf-8') as f: return json.load(f)
def save_json_config(config: dict, config_path: Path): """把 dict 保存为 JSON 文件""" with open(config_path, 'w', encoding='utf-8') as f: json.dump(config, f, indent=2, ensure_ascii=False)
def load_yaml_config(config_path: Path): """读取 YAML 配置(YAML 比 JSON 更适合手写:无引号、支持注释)""" with open(config_path, 'r', encoding='utf-8') as f: return yaml.safe_load(f)
def save_yaml_config(config: dict, config_path: Path): """把 dict 保存为 YAML 文件""" with open(config_path, 'w', encoding='utf-8') as f: yaml.dump(config, f, default_flow_style=False, allow_unicode=True)
def load_env_config(env_path: Path): """解析 .env(KEY=VALUE 每行一个)为 dict,用于存放密钥/路径等""" config = {} with open(env_path, 'r', encoding='utf-8') as f: for line in f: line = line.strip() if line and not line.startswith('#'): key, value = line.split('=', 1) config[key.strip()] = value.strip() return config
|
阶段七:总结与进阶
回顾所学内容,并展望更高级的文件操作技巧。
📊 学习内容总结
| 阶段 |
核心内容 |
掌握程度 |
| 阶段一 |
pathlib 安装、工作目录、路径属性 |
☐ 基础 |
| 阶段二 |
目录遍历、文件筛选 |
☐ 基础 |
| 阶段三 |
文本和 CSV 文件读写 |
☐ 基础 |
| 阶段四 |
批量数据处理、平均值计算 |
☐ 进阶 |
| 阶段五 |
错误处理、项目结构 |
☐ 进阶 |
| 阶段六 |
高级文件操作、自动化 |
☐ 高级 |
🚀 进阶学习路径
1. 数据处理进阶
1 2 3 4 5 6 7 8 9
| import pandas as pd df = pd.read_csv("data.csv") df.groupby("subject").mean()
chunks = pd.read_csv("large_file.csv", chunksize=1000) for chunk in chunks: process(chunk)
|
2. 并发文件处理
1 2 3 4 5 6 7 8 9 10 11 12 13 14
| from concurrent.futures import ThreadPoolExecutor from pathlib import Path
def process_file(file_path): """处理单个文件""" pass
def parallel_process(folder: Path, max_workers=4): """并行处理文件夹中的所有文件""" files = list(folder.glob("*.csv")) with ThreadPoolExecutor(max_workers=max_workers) as executor: executor.map(process_file, files)
|
3. 文件系统监控
1 2 3 4 5 6 7 8 9 10
|
from watchdog.observers import Observer from watchdog.events import FileSystemEventHandler
class DataHandler(FileSystemEventHandler): def on_created(self, event): if event.src_path.endswith('.csv'): print(f"新数据文件: {event.src_path}")
|
4. 云存储集成
1 2 3 4 5 6 7 8 9 10 11 12 13
| import boto3 from pathlib import Path
def upload_to_s3(local_path: Path, bucket_name: str, s3_key: str): """上传文件到 S3""" s3 = boto3.client('s3') s3.upload_file(str(local_path), bucket_name, s3_key)
def download_from_s3(bucket_name: str, s3_key: str, local_path: Path): """从 S3 下载文件""" s3 = boto3.client('s3') s3.download_file(bucket_name, s3_key, str(local_path))
|
📚 推荐资源
官方文档:
进阶库:
pandas:数据分析
numpy:数值计算
watchdog:文件系统监控
boto3:云存储操作
实践项目:
- 构建自动化数据处理流水线
- 开发实验数据管理系统
- 实现数据备份与版本控制
🎯 下一步建议
- 巩固基础:确保每个阶段的练习都独立完成
- 项目实践:选择一个实际项目应用所学知识
- 代码审查:让他人审查你的代码,学习最佳实践
- 持续学习:关注 Python 生态中的新工具和库
记住:实践是学习编程的最佳方式。不要只看代码,要动手编写、调试和优化!
推荐的项目目录
1 2 3 4 5 6 7 8
| experiment/ ├── data/ │ ├── raw/ │ ├── processed/ │ └── metadata.csv ├── results/ ├── logs/ └── scripts/
|
完成标准
学习验证提交格式
完成后提交三类证据:
证据 1:运行输出
粘贴 Step 9 的真实输出,包括读取了几个文件、数组 shape 和平均结果。
证据 2:主动修改
至少完成一项:
- 增加一个 CSV 文件
- 修改一个文件的采样点数量
- 修改目录结构
- 制造一个格式错误文件并观察程序如何跳过
说明修改前后结果变化及原因。
证据 3:口头解释
用自己的话回答:
- 为什么推荐
Path / "file.csv",而不是字符串拼接路径?
iterdir() 和 rglob() 的区别是什么?
- 为什么批量求平均前要检查每个信号的长度?
- 什么时候用
csv,什么时候用 np.loadtxt?
能力等级目标
当前能力:L0(未完成、未归档,不升级)。 本学习文档只是练习计划,完成它不等于已经掌握。完成基础步骤、在 AI 帮助下跑通,并提交三类证据归档后,才能判 L0 → L2。
若能脱离本文档,独立写出“递归查找 CSV → 读取信号 → 校验 → 汇总”的新脚本,并通过 learn-verify 验证归档后,才是 L2 → L3 候选。归档前仍按 L0 记录。