Python-05-异常与文件IO
一句话概括
异常不是「出错了」,而是 Python 的第二种返回通道——函数既可以把结果
return出去,也可以把「为什么没结果」raise出去。文件 IO 则是这个机制最大的用户:所有资源都必须保证被释放,于是有了with与上下文管理器。
一、是什么
1.1 异常的本质:调用栈上的非局部跳转
函数调用会形成一个调用栈(call stack)。正常情况下,控制流沿栈逐层返回;raise 做的事情是沿栈向上快速回退,直到遇到匹配的 except,中途所有函数的剩余代码都被跳过。
def read_config(path: str) -> dict:
with open(path, encoding="utf-8") as f: # ① 打不开就在这里抛
return parse(f.read()) # ② 解析失败在这里抛
def parse(text: str) -> dict:
key, _, value = text.partition("=")
if not _:
raise ValueError(f"配置行缺少 '=':{text!r}") # ③ 抛出的位置
return {key.strip(): value.strip()}
def main() -> None:
try:
cfg = read_config("app.conf") # ④ 调用点
except FileNotFoundError:
cfg = {}
print("配置文件不存在,使用默认配置")
except ValueError as e:
# e 里带着③处构造的消息;e.__traceback__ 还记着从③到④的完整调用链
print(f"配置格式错误:{e}")
print(cfg)
if __name__ == "__main__":
main()
一次 raise 携带三样东西:
| 组成部分 | 内容 | 怎么看到 |
|---|---|---|
| 异常类型 | ValueError、FileNotFoundError … | type(e) |
| 异常消息 | 人读的描述 | str(e) / e.args |
| 回溯(traceback) | 从 raise 点到 except 点的完整调用链,含文件名与行号 | 未捕获时自动打印;traceback 模块可格式化 |
重点
回溯是从下往上读的:最下面一行是异常抛出的位置,上面依次是调用它的位置。新手最常见的误读是盯着最上面一行找 bug,其实最下面那行才是现场。
1.2 内置异常层次结构
Python 的所有异常都派生自 BaseException。3.x 的完整主干如下(只列常用分支):
BaseException ← 所有异常的根,业务代码永远不要直接捕获它
├── SystemExit ← sys.exit() 抛出
├── KeyboardInterrupt ← 用户按 Ctrl+C 抛出
├── GeneratorExit ← 生成器被 close() 时抛出
└── Exception ← 绝大多数「业务异常」的根,except Exception 基本安全
├── ArithmeticError
│ ├── ZeroDivisionError ← 1/0
│ ├── OverflowError ← 数值过大
│ └── FloatingPointError
├── LookupError ← 「查不到」类错误的共同基类
│ ├── IndexError ← lst[99]
│ └── KeyError ← d["missing"]
├── ValueError ← 类型对但值不对:int("abc")
│ └── UnicodeError
│ ├── UnicodeDecodeError ← 解码失败(读文件时的常客)
│ └── UnicodeEncodeError ← 编码失败(写文件时的常客)
├── TypeError ← 类型不对:len(42)
├── AttributeError ← 没有这个属性:None.foo
├── NameError ← 变量名不存在
├── OSError (= IOError) ← 一切系统调用/IO 错误的基类(PEP 3151 重组过)
│ ├── FileNotFoundError ← 文件不存在
│ ├── FileExistsError ← 文件已存在(mkdir 时常见)
│ ├── PermissionError
│ ├── IsADirectoryError
│ ├── NotADirectoryError
│ ├── TimeoutError
│ └── ConnectionError
│ ├── BrokenPipeError
│ └── ConnectionResetError
├── RuntimeError
│ ├── RecursionError ← 超过递归深度
│ └── NotImplementedError ← 抽象方法没被实现
├── StopIteration ← 迭代器耗尽,for 循环内部依赖它
├── AssertionError ← assert 失败
├── ImportError
│ └── ModuleNotFoundError
└── Warning(作为异常抛出时使用)
从这棵树能读出三条设计意图:
LookupError同时罩住IndexError和KeyError,所以except LookupError能一次抓住「索引越界」和「键不存在」。OSError是平台错误的统一门面。PEP 3151 之前,文件不存在会抛IOError或OSError且带errno,非常难写可移植代码;现在统一成FileNotFoundError等具体类型。BaseException与Exception的分界是刻意的。KeyboardInterrupt、SystemExit不是「程序 bug」,而是「用户/系统要求退出」,必须让它们穿透业务代码,否则 Ctrl+C 会被吞掉。
不要写裸
except:```python
try:
do_something()
except: # 捕获 BaseException,连 Ctrl+C 和 sys.exit() 都被吃掉
pass
```
后果:程序无法中断、退出码被吞、真正的错误被静默隐藏。至少写成
except Exception:,更好的是捕获具体类型。
二、为什么这样设计
2.1 为什么用异常而不是错误码
| 维度 | 错误码(C 风格) | 异常(Python 风格) |
|---|---|---|
| 正常路径的代码 | 每步都要 if (ret != 0) return ret; | 直线写下去,错误处理集中在末尾 |
| 忘记检查 | ✅ 静默继续,用错值 | ✅ 立刻崩溃,问题暴露 |
| 错误信息 | 通常只有一个整数 | 类型 + 消息 + 回溯 |
| 能否携带上下文 | 困难 | raise ... from 保留原因链 |
| 性能 | 几乎零开销 | try 块本身零开销,抛异常较贵 |
| 跨层传播 | 每层都要手动转发 | 自动沿栈上浮 |
| 适合场景 | 预期内的、频繁发生的结果(如「缓存未命中」) | 预期外的、罕见的、无法就地处理的情况 |
Python 的 try 语句在不触发异常时几乎不产生额外开销(CPython 3.11+ 引入 zero-cost exception handling,性能进一步改善)。所以「用异常做控制流会慢」这个说法要分情况:抛出异常确实慢(要构造对象、拼回溯),但保护代码不慢。
2.2 为什么把「取消」和「退出」放在 Exception 之外
import sys
try:
while True:
process_one_item()
except Exception:
# 这里抓不到 KeyboardInterrupt,用户按 Ctrl+C 依然能停下程序
log_error()
raise
如果 KeyboardInterrupt 继承 Exception,一个粗心的 except Exception: pass 就会让程序变成「按 Ctrl+C 没反应」的僵尸。这条继承线是给人类操作留的后门。
2.3 为什么需要 with
没有 with 的时代,释放资源必须手写 try/finally:
f = open("data.txt", encoding="utf-8")
try:
data = f.read()
finally:
f.close() # 无论是否异常都要执行
一旦涉及多个资源(文件 + 锁 + 数据库连接),嵌套层数迅速失控。with 把「获取—使用—释放」这个模式抽象成上下文管理器(context manager)协议,PEP 343 引入。它的好处是:释放逻辑写在类型本身,写业务代码的人不需要记得清理。
三、核心内容
3.1 try/except/else/finally 的执行顺序
四个子句的职责:
| 子句 | 何时执行 | 用途 |
|---|---|---|
try | 总是(先执行) | 放「可能失败」的代码,只放必要的行 |
except | try 中抛出匹配异常时 | 处理错误 |
else | try 中没有抛出异常时 | 放「只有成功后才该做」的代码 |
finally | 无论是否异常、是否 return,一定执行 | 释放资源、记录日志 |
def divide(a: float, b: float) -> float:
try:
print("① try 开始")
result = a / b
except ZeroDivisionError as e:
print(f"② except:{e}")
return float("nan") # 注意:返回前 finally 仍会执行
else:
print("③ else:没有异常")
return result
finally:
print("④ finally:一定执行")
print(divide(6, 3))
# ① try 开始 / ③ else:没有异常 / ④ finally:一定执行 / 2.0
print(divide(6, 0))
# ① try 开始 / ② except:division by zero / ④ finally:一定执行 / nan
else 为什么存在:把「可能失败的调用」和「只在成功后才做的事」分开,避免误捕获后者的异常。
# ❌ 危险:process() 内部的 KeyError 会被当成「读取失败」处理
# 而且 open() 的句柄要靠引用计数回收,不该这么写
try:
data = load_json(path)
process(data)
except KeyError:
data = {}
# ✅ 正确:except 只罩住 load_json,process 的 KeyError 会正常上浮
try:
data = load_json(path)
except KeyError:
data = {}
else:
process(data)
3.2 return 与 finally 的交互
这是最经典的面试题,规则只有一条:
finally中的return/break/continue会覆盖try/except中的返回值。
def f1() -> str:
try:
return "try"
finally:
return "finally" # 覆盖了 "try"
print(f1()) # finally
def f2() -> int:
x = 1
try:
return x
finally:
x = 999 # 只改局部变量,返回值在 return 时就已确定
print("finally 执行了")
print(f2()) # 先打印 finally 执行了,再返回 1
def f3() -> int:
try:
return 1
finally:
print("清理") # 没有 return,不影响返回值
print(f3()) # 清理 / 1
def f4() -> int:
try:
raise ValueError("内部错误")
finally:
return -1 # 连异常都被吞掉了!这是危险写法
print(f4()) # -1,而且没有任何报错
def f5() -> int:
try:
raise ValueError("内部错误")
finally:
print("清理完成") # 只是清理,不改变控制流
# 调用 f5() 会先打印「清理完成」,然后把 ValueError 正常抛给调用方
def f6() -> None:
try:
return
finally:
# break/continue 同样危险:它们会把循环变量状态搅乱
for i in range(3):
try:
continue
finally:
print("每轮都执行 finally", i)
绝不要在 finally 里写 return
上面的
f4会静默吞掉异常,是排查噩梦的源头。finally只用来释放资源和记录日志,永远不要用它改变控制流。
执行顺序总结(try 抛出异常且被捕获的情况):
def demo():
try:
print("1. try")
raise ValueError("boom")
except ValueError:
print("2. except")
return "from except"
else:
print("3. else(不会执行)")
finally:
print("4. finally")
print("返回值:", demo())
# 1. try / 2. except / 4. finally / 返回值: from except
3.3 捕获具体异常
import json
# ❌ 太宽:分不清「文件不存在」还是「JSON 格式错误」,也没法分别处理
try:
cfg = json.loads(open("a.json", encoding="utf-8").read())
except Exception:
cfg = {}
# ✅ 具体:每一类错误都有对应策略,且文件句柄保证被关闭
try:
with open("a.json", encoding="utf-8") as f:
cfg = json.load(f)
except FileNotFoundError:
cfg = {} # 首次运行,用默认值
except json.JSONDecodeError as e:
raise ValueError(f"配置文件 a.json 不是合法 JSON(第 {e.lineno} 行)") from e
except PermissionError:
raise # 无法处理,交给上层
| 写法 | 是否推荐 | 原因 |
|---|---|---|
except: | ❌ | 吞掉 KeyboardInterrupt、SystemExit |
except Exception: | 🔸 仅在顶层兜底时 | 掩盖程序 bug,无法区分错误类型 |
except (A, B): | ✅ | 多种错误共用同一处理逻辑 |
except A as e: | ✅ | 需要读取消息、日志、raise ... from e |
except A: | ✅ | 只做恢复,不需要错误详情 |
except A: ... else: ... | ✅ | 把成功路径与失败路径彻底分开 |
实践建议
「捕获」的判据是:你能对这个错误做点有意义的事吗? 能就地恢复(用默认值、重试、降级)就捕获;不能就让它上浮,在能处理的那一层统一处理。中间层加一条
except Exception只为打日志再raise是合理的,但一定要带raise重新抛出。
3.4 异常链:raise ... from
PEP 3134 引入异常链接,让「A 是 B 引起的」这个因果关系被记录下来。异常对象有三个相关属性:
| 属性 | 含义 |
|---|---|
__context__ | 隐式链:在处理 A 的过程中又抛了 B,Python 自动设置 |
__cause__ | 显式链:raise B from A 手动设置 |
__suppress_context__ | raise B from None 时置为 True,切断显示 |
import json
class ConfigError(Exception):
"""配置相关的自定义异常:让调用方只处理一种类型。"""
def load_port(path: str) -> int:
try:
with open(path, encoding="utf-8") as f:
raw = json.load(f)
except FileNotFoundError as e:
# from e 保留「文件不存在」这个根因,回溯里会同时显示两层
raise ConfigError(f"配置文件缺失:{path}") from e
except json.JSONDecodeError as e:
raise ConfigError(f"{path} 不是合法 JSON:{e.msg}(第 {e.lineno} 行)") from e
try:
return int(raw["port"])
except KeyError as e:
raise ConfigError("配置缺少 port 字段") from e
except (TypeError, ValueError) as e:
raise ConfigError(f"port 必须是整数,实际是 {raw['port']!r}") from e
try:
load_port("missing.json")
except ConfigError as e:
print(f"启动失败:{e}")
print("根因类型:", type(e.__cause__).__name__)
输出(回溯中会同时看到两层):
启动失败:配置文件缺失:missing.json
根因类型: FileNotFoundError
# 对比三种写法的显示效果
def without_from():
try:
int("abc")
except ValueError:
raise RuntimeError("转换失败") # 隐式链接,回溯显示 "During handling of the above exception"
def with_from():
try:
int("abc")
except ValueError as e:
raise RuntimeError("转换失败") from e # 显式链接,显示 "The above exception was the direct cause"
def suppress():
try:
int("abc")
except ValueError:
raise RuntimeError("转换失败") from None # 切断,只显示 RuntimeError
实践建议
在库代码里把底层异常(
OSError、sqlite3.Error)转换成自己的领域异常时,总是用raise ... from e。这样调用方既能只写一个except,又能顺着__cause__找到真正原因。
3.5 自定义异常
class AppError(Exception):
"""本项目所有业务异常的基类。
好处:调用方可以用 except AppError 一次性兜住全部业务错误,
同时又能用具体子类精确处理。"""
def __init__(self, message: str, *, code: int = 0, detail: dict | None = None):
super().__init__(message) # 让 str(e)/e.args 正常工作
self.message = message
self.code = code
self.detail = detail or {}
def __str__(self) -> str:
return f"[{self.code}] {self.message}"
class ValidationError(AppError):
"""用户输入不合法。"""
class RetryableError(AppError):
"""可重试的临时故障(网络抖动、锁超时)。"""
def withdraw(balance: float, amount: float) -> float:
if amount <= 0:
raise ValidationError("取款金额必须为正", code=4001, detail={"amount": amount})
if amount > balance:
raise ValidationError("余额不足", code=4002, detail={"balance": balance})
return balance - amount
try:
withdraw(100, 200)
except ValidationError as e:
print(e, e.detail)
自定义异常的 5 条经验规则:
- 从
Exception(或其子类)派生,不要从BaseException派生。 - 继承一个项目自己的基类,调用方才有统一的兜底选择。
__init__里调用super().__init__(message),否则str(e)是空字符串。- 不要只为了「多个名字」而建子类:如果两个异常的处理方式完全一样,用一个即可。
- 异常类名以
Error结尾是 PEP 8 的建议(内置异常都如此)。
3.6 断言与异常的区别
def average(scores: list[int]) -> float:
# assert 用于「绝不该发生」的内部一致性检查,不是参数校验
assert scores, "scores 不应为空(调用方保证)"
return sum(scores) / len(scores)
def average_safe(scores: list[int]) -> float:
# 面向外部输入的检查必须用 raise:assert 可能被 -O 优化掉
if not scores:
raise ValueError("scores 不能为空")
return sum(scores) / len(scores)
| 对比项 | assert | raise |
|---|---|---|
| 语义 | 内部不变量(程序员假设) | 契约违约(调用方错误) |
| 编译优化 | python -O 会全部移除 | 始终生效 |
| 异常类型 | AssertionError | 任意 |
| 能否带上下文 | 只有消息字符串 | 完整异常对象 |
| 适合场景 | 单元测试、调试期自检、不可能分支 | 参数校验、IO 失败、业务规则 |
| 不适合 | 校验用户输入、校验公共 API 参数 | 检查「不可能发生」的内部状态(用 assert 更明确) |
-O会删掉所有 assert```python
def transfer(amount):
assert amount > 0, "金额必须为正" # python -O 下这行完全消失
do_transfer(amount)
```
生产环境常用
-O或PYTHONOPTIMIZE=1启动,任何安全相关的检查写成assert都等于没写。
3.7 什么时候抛异常,什么时候返回错误码
判据是调用方是否必须立即处理:
| 情况 | 选择 | 理由 |
|---|---|---|
| 参数不合法、前置条件不满足 | 抛异常(ValueError、TypeError) | 调用方必须修代码,无法继续 |
| 资源不可用(文件、网络、数据库) | 抛异常,且用具体类型 | 调用方需要决定重试/降级/上报 |
| 业务规则拒绝(余额不足、重复提交) | 抛自定义异常 | 让调用方用 except 精确捕获 |
| 预期内且高频的正常分支 | 返回 None / False / 哨兵值 | 例如 dict.get、str.find 返回 -1 |
| 「查不到」是常态(缓存、可选配置) | 返回 None 或默认值 | 用异常会污染正常流程 |
| 需要返回多个可能结果 | 返回结果对象(如 Result[T, E]) | 避免异常做控制流,便于类型检查 |
# 示例:同一个功能两种风格并存是合理的
def find_user(uid: int) -> "User | None":
"""不抛异常:找不到是正常情况(比如用于「存在性检查」)。"""
return _DB.get(uid)
def get_user(uid: int) -> "User":
"""抛异常:调用方期望一定拿到用户,找不到就是错误。"""
user = _DB.get(uid)
if user is None:
raise LookupError(f"用户不存在:{uid}")
return user
(上面两段是接口设计示意,_DB、User 需按实际项目替换。)
3.8 上下文管理器与 with
协议:对象实现 __enter__ 和 __exit__ 即可用于 with。
class Timer:
"""测量代码块耗时,无论是否异常都会打印。"""
def __init__(self, label: str):
self.label = label
def __enter__(self):
import time
self._start = time.perf_counter()
return self # as 后面拿到的就是这个返回值
def __exit__(self, exc_type, exc_value, traceback):
import time
cost = time.perf_counter() - self._start
print(f"[{self.label}] 耗时 {cost * 1000:.2f} ms")
# 返回 False/None → 不压制异常,让它继续上浮
# 返回 True → 吞掉异常(危险,慎用)
return False
with Timer("计算") as t:
total = sum(range(1_000_000))
print(total)
__exit__ 的三个参数:
| 参数 | 无异常时 | 有异常时 | 用途 |
|---|---|---|---|
exc_type | None | 异常类 | 按类型决定是否压制 |
exc_value | None | 异常实例 | 读取消息 |
traceback | None | 回溯对象 | 记录现场 |
class Transaction:
"""极简事务:正常结束提交,出异常回滚。"""
def __init__(self, conn):
self.conn = conn
def __enter__(self):
self.conn.begin()
return self.conn
def __exit__(self, exc_type, exc_value, tb):
if exc_type is None:
self.conn.commit()
else:
self.conn.rollback()
return False # 回滚后仍然把异常抛给调用方,不掩盖问题
contextlib:不用写类也能做上下文管理器
import contextlib
import os
@contextlib.contextmanager
def temporary_env(key: str, value: str):
"""临时修改环境变量,退出时恢复原值。
@contextmanager 把「yield 之前的代码」当作 __enter__,
「yield 之后的代码」当作 __exit__。yield 的值就是 as 拿到的东西。"""
old = os.environ.get(key)
os.environ[key] = value
try:
yield value
finally:
# 用 finally 保证即使 with 块内抛异常也能恢复
if old is None:
os.environ.pop(key, None)
else:
os.environ[key] = old
with temporary_env("APP_MODE", "test") as mode:
print(os.environ["APP_MODE"]) # test
print(os.environ.get("APP_MODE")) # None,已恢复
contextlib 常用工具:
| 工具 | 作用 | 典型场景 |
|---|---|---|
@contextmanager | 用生成器写上下文管理器 | 临时状态、加锁、计时 |
contextlib.suppress(E) | 忽略指定异常 | 删除可能不存在的文件 |
contextlib.closing(obj) | 退出时调用 obj.close() | 老式只有 close() 的对象 |
contextlib.ExitStack | 动态管理数量不定的上下文 | 一次打开未知个数的文件 |
contextlib.nullcontext() | 什么都不做的占位 | 让「可选上下文」写法统一 |
contextlib.redirect_stdout(f) | 重定向标准输出 | 捕获函数打印、写日志文件 |
import contextlib
from pathlib import Path
# suppress:比 try/except/pass 更明确地表达「我知道可能失败,且不在乎」
with contextlib.suppress(FileNotFoundError):
Path("tmp-not-exist.txt").unlink()
# ExitStack:一次性打开任意多个文件,退出时全部关闭
paths = ["a.txt", "b.txt"]
with contextlib.ExitStack() as stack:
files = [stack.enter_context(open(p, "w", encoding="utf-8")) for p in paths]
for f in files:
f.write("hello\n")
# 到这里所有文件都已关闭,即使中途某个 open 失败,之前打开的也会被关掉
3.9 文件打开模式
open(file, mode, encoding=...) 的 mode:
| 模式 | 含义 | 文件不存在 | 文件已存在 | 读/写 |
|---|---|---|---|---|
"r" | 只读(默认) | FileNotFoundError | 从头读 | 读 |
"w" | 只写 | 创建 | 清空 | 写 |
"a" | 追加 | 创建 | 在末尾追加 | 写 |
"x" | 独占创建 | 创建 | FileExistsError | 写 |
"r+" | 读写 | FileNotFoundError | 从当前位置覆盖 | 读写 |
"w+" | 读写 | 创建 | 清空 | 读写 |
"a+" | 读写(写只能追加) | 创建 | 末尾追加 | 读写 |
加 "b" | 二进制 | 同上 | 同上 | bytes |
加 "t" | 文本(默认) | 同上 | 同上 | str |
from pathlib import Path
Path("demo.txt").write_text("第一行\n", encoding="utf-8")
with open("demo.txt", "a", encoding="utf-8") as f:
f.write("第二行\n") # 追加,不破坏已有内容
with open("demo.txt", "r", encoding="utf-8") as f:
print(f.read())
"w"会立刻清空文件
open("important.txt", "w")在打开的那一刻就把文件截断为 0 字节,哪怕你后面一行都没写。想「安全更新」文件请用「写临时文件 →os.replace原子替换」的模式:```python
import os, tempfile
from pathlib import Path
def atomic_write(path: str, text: str, encoding: str = "utf-8") -> None:
"""先写临时文件再原子替换:中途崩溃也不会留下半个文件。"""
target = Path(path)
fd, tmp = tempfile.mkstemp(dir=target.parent, suffix=".tmp")
try:
with os.fdopen(fd, "w", encoding=encoding) as f:
f.write(text)
os.replace(tmp, target) # 原子操作,同一文件系统内瞬间完成
except BaseException:
Path(tmp).unlink(missing_ok=True) # 出错时清理临时文件
raise
```
3.10 文本模式与二进制模式
| 对比项 | 文本模式 "r" | 二进制模式 "rb" |
|---|---|---|
| 读到的类型 | str | bytes |
| 是否做编码转换 | ✅ 按 encoding 解码 | ❌ 原始字节 |
| 换行符 | 通用换行(\r\n → \n) | 原样保留 |
| 能否 seek | 只能在 tell() 返回值处 seek | 任意位置 |
| 适用 | 文本文件(txt/csv/json/py) | 图片、音视频、压缩包、pickle、需要精确控制字节时 |
| 缓冲区类型 | TextIOWrapper → BufferedWriter | BufferedReader |
# 二进制:读写图片等非文本数据必须用 "rb"/"wb",不能用文本模式
data = b"\x89PNG\r\n\x1a\n" # PNG 文件头魔数
with open("demo.png", "wb") as f:
f.write(data)
with open("demo.png", "rb") as f:
head = f.read(8)
print(head == data) # True
# 手动在两种模式间转换
text = head.decode("latin-1") # 用能无损映射 0-255 的编码做调试输出
print(text.encode("utf-8")[:4])
3.11 编码问题:为什么必须显式写 encoding
Python 3 的文本模型是「str 是 Unicode 码点序列,bytes 是字节序列,两者之间必须显式编码/解码」。
open() 不传 encoding 时用 locale.getpreferredencoding(False),于是:
| 平台 / 环境 | 默认编码 | 后果 |
|---|---|---|
| Linux + UTF-8 locale | utf-8 | 正常 |
| Windows 中文版(旧 Python) | cp936(GBK) | 写出的文件在 UTF-8 环境里乱码 |
| Windows(Python 3.15 起计划改为 UTF-8) | 变化中 | 跨版本行为不一致 |
| Docker 容器未设 locale | ascii 或 utf-8 | 读写中文直接抛 UnicodeEncodeError |
# ❌ 隐式依赖平台默认编码:在中文 Windows 上按 GBK 解码,在 Linux 上按 UTF-8,
# 同一份代码在两地读同一个文件会得到不同结果(甚至直接 UnicodeDecodeError)
with open("data.txt", "r") as f:
text = f.read()
# ✅ 永远显式指定 encoding,让行为与平台彻底解耦
with open("data.txt", "r", encoding="utf-8") as f:
text = f.read()
乱码的本质是「用错的编码去解码」:
s = "中文"
gbk_bytes = s.encode("gbk")
print(gbk_bytes) # b'\xd6\xd0\xce\xc4'
# 用 GBK 的字节去按 UTF-8 解码 → 报错或乱码
try:
gbk_bytes.decode("utf-8")
except UnicodeDecodeError as e:
print("解码失败:", e)
# 用 latin-1 强行解码不会报错(它是单字节映射),但结果是乱码
print(gbk_bytes.decode("latin-1")) # ÖÐÎÄ
# errors 参数的两种救急写法
print(gbk_bytes.decode("utf-8", errors="replace")) # ����
print(gbk_bytes.decode("utf-8", errors="ignore")) # 空(字节全被丢弃)
# 正确做法是用对的编码
print(gbk_bytes.decode("gbk")) # 中文
编码相关的三个坑
1. 写文件不指定 encoding:Windows 上生成的 CSV 用 Excel 打开是乱码(因为 Excel 默认按 GBK 解析 UTF-8 文件——给 Excel 用的 CSV 应考虑
utf-8-sig带 BOM)。2.
errors="ignore"当万能药:它会静默丢数据。只在「日志之类的、丢几个字符无所谓」的场景用。3. 二进制数据用文本模式打开:会触发解码错误,或者(更糟)在 Windows 上被替换换行符而损坏文件。
# 给 Excel 用的 CSV:带 BOM 的 UTF-8
with open("report.csv", "w", encoding="utf-8-sig", newline="") as f:
f.write("姓名,分数\n李雷,95\n")
3.12 读写大文件
核心原则:不要 read() 一个可能很大的文件。
from pathlib import Path
# ❌ 1 GB 的文件会吃掉约 1 GB+ 内存(str 比 bytes 更占空间)
text = Path("huge.log").read_text(encoding="utf-8")
# ✅ 逐行迭代:文件对象本身是可迭代的,内部有缓冲,内存恒定
count = 0
with open("huge.log", encoding="utf-8") as f:
for line in f: # 一次只驻留一行
if "ERROR" in line:
count += 1
print(count)
# ✅ 固定块读取:适合二进制或没有换行的超长单行文件
with open("huge.bin", "rb") as f:
while chunk := f.read(8192): # 海象运算符,Python 3.8+
process(chunk) # 8 KB 一块,内存恒定
| 方法 | 内存占用 | 返回 | 适用 |
|---|---|---|---|
f.read() | str/bytes | 小文件、需要全文处理 | |
f.read(n) | 前 个字符/字节 | 大文件分块、二进制协议 | |
f.readline() | 一行 | 需要精确控制读几行 | |
f.readlines() | list[str] | 小文件的全部行 | |
for line in f | 逐行 | 大文本文件的首选 | |
f.writelines(iterable) | (流式) | None | 批量写,注意不自动加换行 |
Path.read_text() / read_bytes() | 全文 | str/bytes | 小文件的便捷写法 |
缓冲(buffering):默认情况下 open() 使用 io.DEFAULT_BUFFER_SIZE(通常 8192 字节)的缓冲,把多次小写入合并成少量系统调用。
# 默认缓冲:10000 次 write 会被合并成约 100 次系统调用
with open("buf.txt", "w", encoding="utf-8") as f:
for i in range(10_000):
f.write(f"{i}\n")
# buffering=0 仅在二进制模式可用:每次 write 都是一次系统调用,通常更慢
with open("unbuf.bin", "wb", buffering=0) as f:
f.write(b"x")
缓冲意味着「写在内存里,没落盘」
在
with块结束(或显式f.flush()、os.fsync(f.fileno()))之前,数据可能只在用户态缓冲里。程序被kill -9时这些数据会丢失。需要强持久化(如写关键日志、数据库 WAL)时必须flush()+os.fsync()。
3.13 pathlib 与 os.path
pathlib(PEP 428)用对象代替字符串拼接路径,是 Python 3.6+ 的推荐写法。
| 任务 | os.path(字符串 API) | pathlib(对象 API) |
|---|---|---|
| 拼接路径 | os.path.join("a", "b", "c.txt") | Path("a") / "b" / "c.txt" |
| 取父目录 | os.path.dirname(p) | Path(p).parent |
| 取文件名 | os.path.basename(p) | Path(p).name |
| 去扩展名 | os.path.splitext(p)[0] | Path(p).stem |
| 取扩展名 | os.path.splitext(p)[1] | Path(p).suffix |
| 判断存在 | os.path.exists(p) | Path(p).exists() |
| 判断是文件/目录 | os.path.isfile / isdir | .is_file() / .is_dir() |
| 创建目录 | os.makedirs(p, exist_ok=True) | Path(p).mkdir(parents=True, exist_ok=True) |
| 读文本 | open(p, encoding=...).read() | Path(p).read_text(encoding=...) |
| 写文本 | open(p, "w", encoding=...).write(s) | Path(p).write_text(s, encoding=...) |
| 遍历目录 | os.listdir(p) | Path(p).iterdir() |
| 递归匹配 | glob.glob("**/*.py", recursive=True) | Path(p).rglob("*.py") |
| 绝对路径 | os.path.abspath(p) | Path(p).resolve()(会解析符号链接) |
| 跨平台 | ✅ | ✅(更好,语义清晰) |
| 传给需要字符串的旧 API | 直接用 | 一般也行;必要时 str(p) |
from pathlib import Path
root = Path("project")
(root / "src").mkdir(parents=True, exist_ok=True) # parents=True 相当于 mkdir -p
(root / "src" / "main.py").write_text("print('hi')\n", encoding="utf-8")
(root / "README.md").write_text("# 项目\n", encoding="utf-8")
# 遍历所有 Python 文件
for py in root.rglob("*.py"):
print(py, "→", py.read_text(encoding="utf-8").strip())
# 各部分拆解
p = Path("/home/user/data/report.tar.gz")
print(p.name) # report.tar.gz
print(p.stem) # report.tar
print(p.suffix) # .gz
print(p.suffixes) # ['.tar', '.gz'] —— 多重后缀要小心
print(p.with_suffix(".zip")) # /home/user/data/report.tar.zip
print(p.parent) # /home/user/data
# 文件信息
f = root / "README.md"
st = f.stat()
print(st.st_size, st.st_mtime)
os.path.abspath与Path.resolve不等价
resolve()会解析符号链接(symlink)并把路径规范化,strict=False(默认)时对不存在的路径也能返回结果;abspath只做字符串层面的规范化。在包含 symlink 的目录里,两者结果可能不同。需要「不解析符号链接的绝对路径」时用Path(p).absolute()或os.path.abspath。
目录操作速查:
import shutil
from pathlib import Path
d = Path("tmpdir")
d.mkdir(exist_ok=True) # 存在也不报错(幂等)
(d / "a.txt").touch() # 创建空文件或更新时间戳
# 遍历:os.walk 是深度优先生成器,适合树上做累积计算
import os
for dirpath, dirnames, filenames in os.walk("."):
# 原地修改 dirnames 可以剪枝(跳过某些目录),这是 os.walk 的特性
dirnames[:] = [x for x in dirnames if not x.startswith(".")]
print(dirpath, len(filenames))
# 递归删除整个目录树
shutil.rmtree(d, ignore_errors=True)
# 递归复制目录树
shutil.copytree("src_dir", "dst_dir", dirs_exist_ok=True)
# 移动/重命名(跨文件系统也能用)
shutil.move("a.txt", "b.txt")
删除操作不可撤销
shutil.rmtree等价于rm -rf,Path.unlink()直接删文件,都不进回收站。写这类脚本时先if input("确认?") == "y":之类的保护。
3.14 csv 与 json 的读写
CSV:看似简单,其实有引号、逗号、换行、BOM 四个坑,必须用 csv 模块而不是 split(",")。
import csv
from pathlib import Path
rows = [
["姓名", "年龄", "城市"],
["李雷", 20, "北京"],
["韩梅梅", 19, '上海, 浦东'], # 含逗号的字段
["王五", 22, 'He said "hi"'], # 含引号的字段
]
# newline="" 是官方文档明确要求的:
# 让 csv 模块自己处理行结束符,避免 Windows 上出现空行
with open("people.csv", "w", encoding="utf-8-sig", newline="") as f:
writer = csv.writer(f)
writer.writerows(rows)
with open("people.csv", encoding="utf-8-sig", newline="") as f:
for row in csv.reader(f):
print(row)
# DictReader/DictWriter:用表头当键,代码可读性远好于下标
with open("people.csv", encoding="utf-8-sig", newline="") as f:
reader = csv.DictReader(f)
for record in reader:
print(record["姓名"], record["城市"]) # 注意:读出来都是 str
import csv
# 写字典:fieldnames 顺序决定列顺序
with open("scores.csv", "w", encoding="utf-8", newline="") as f:
writer = csv.DictWriter(f, fieldnames=["name", "score"], extrasaction="ignore")
writer.writeheader() # 别忘了写表头
writer.writerow({"name": "李雷", "score": 95, "extra": "会被忽略"})
writer.writerows([{"name": "韩梅梅", "score": 88}])
JSON:与 CSV 不同,JSON 有类型(字符串/数字/布尔/null/数组/对象),读出来会保持类型。
import json
from datetime import date
from pathlib import Path
data = {
"name": "李雷",
"age": 20,
"courses": ["数学", "物理"],
"graduated": False,
"advisor": None,
}
# ensure_ascii=False 才能让中文原样输出(默认 True 会转成 \uXXXX)
# indent=2 便于人读,但会让文件变大
text = json.dumps(data, ensure_ascii=False, indent=2)
print(text)
Path("data.json").write_text(text, encoding="utf-8")
loaded = json.loads(Path("data.json").read_text(encoding="utf-8"))
print(loaded["courses"][0], type(loaded["age"])) # 数学 <class 'int'>
# 直接读写文件用 dump/load(少一次字符串中间态,大文件更省内存)
with open("data.json", "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
with open("data.json", encoding="utf-8") as f:
print(json.load(f)["name"])
JSON 的类型映射与限制:
| Python | JSON | 注意 |
|---|---|---|
dict | object | 键必须是 str/int/float/bool/None |
list / tuple | array | 读回来都是 list(元组不保留) |
str | string | — |
int / float | number | 大整数可能丢精度(JS 侧只保证 53 位) |
True / False | true / false | — |
None | null | — |
datetime、set、自定义对象、bytes | ❌ | 抛 TypeError: Object of type X is not JSON serializable |
# 自定义编码:default 回调负责把不认识的对象转成可序列化形式
class Student:
def __init__(self, name: str, birthday: date):
self.name = name
self.birthday = birthday
def encode(obj):
if isinstance(obj, Student):
return {"__type__": "Student", "name": obj.name,
"birthday": obj.birthday.isoformat()}
if isinstance(obj, date):
return obj.isoformat()
if isinstance(obj, set):
return sorted(obj) # 排序以保证输出稳定,便于 diff 与测试
raise TypeError(f"不支持的类型:{type(obj).__name__}")
def decode(d):
if d.get("__type__") == "Student":
return Student(d["name"], date.fromisoformat(d["birthday"]))
return d
s = Student("李雷", date(2005, 3, 1))
raw = json.dumps(s, default=encode, ensure_ascii=False)
print(raw) # {"__type__": "Student", ...}
back = json.loads(raw, object_hook=decode)
print(type(back).__name__, back.birthday) # Student 2005-03-01
JSON 不能有循环引用、不能有 NaN
json.dumps遇到自引用结构会抛ValueError: Circular reference detected。float("nan")/inf默认会被写成非标准的NaN/Infinity(allow_nan=False可改为报错),很多解析器(包括标准 JSON)不接受。需要传输这类数据时改用手写字符串或 base64。
3.15 临时文件
import tempfile
import os
from pathlib import Path
# 1. 临时目录:整个 with 块结束后递归删除
with tempfile.TemporaryDirectory(prefix="myapp-") as tmpdir:
p = Path(tmpdir) / "scratch.txt"
p.write_text("中间结果", encoding="utf-8")
print(p.exists()) # True
print(Path(tmpdir).exists()) # False —— 已自动清理
# 2. 命名临时文件:delete=True 时关闭即删除
fd, name = tempfile.mkstemp(suffix=".csv", prefix="export-")
try:
with os.fdopen(fd, "w", encoding="utf-8", newline="") as f:
f.write("a,b\n1,2\n")
finally:
os.unlink(name)
# 3. 匿名临时文件:没有名字,适合只想在内存/临时盘放数据
with tempfile.TemporaryFile("w+", encoding="utf-8") as f:
f.write("hello")
f.seek(0) # 写完要回到开头才能读到
print(f.read())
# 4. 需要指定盘符时(大文件避开系统盘)
with tempfile.NamedTemporaryFile(mode="w", suffix=".log",
encoding="utf-8", delete=False) as f:
f.write("日志内容")
path = f.name
print(path)
os.unlink(path)
| 工具 | 有路径吗 | 何时删除 | 适用 |
|---|---|---|---|
TemporaryDirectory | 是(目录) | with 退出时递归删除 | 需要多文件协作的临时工作区 |
NamedTemporaryFile | 是 | delete=True 时关闭即删 | 需要把路径交给外部程序 |
TemporaryFile | 否 | 关闭即删 | 纯 Python 内部的临时数据 |
mkstemp | 是 | 手动删 | 需要精细控制生命周期 |
Windows 上不能重复打开命名临时文件
NamedTemporaryFile在 Windows 上默认以独占方式打开,同一个进程再open(f.name)会PermissionError。需要「写完后由另一个函数按路径读」时,用delete=False+ 自己管理删除。
四、怎么用
一个端到端例子:读取 CSV 成绩单,计算统计量,写出 JSON 报告。它同时用到异常分层、pathlib、编码、CSV/JSON 与原子写入。
"""成绩报告生成器:综合演示异常处理与文件 IO。"""
from __future__ import annotations
import csv
import json
import os
import tempfile
from dataclasses import dataclass, asdict
from pathlib import Path
class ReportError(Exception):
"""报告生成失败的业务异常基类。"""
@dataclass(frozen=True)
class Score:
name: str
subject: str
score: float
def load_scores(path: Path) -> list[Score]:
"""读取成绩 CSV。所有底层异常都转成 ReportError,并保留根因。"""
if not path.exists():
raise ReportError(f"成绩文件不存在:{path}")
scores: list[Score] = []
try:
# utf-8-sig:如果文件带 BOM(Excel 导出的常见情况)也能正确解析
# newline="":交给 csv 模块处理行结束符
with open(path, encoding="utf-8-sig", newline="") as f:
for lineno, row in enumerate(csv.DictReader(f), start=2):
try:
scores.append(Score(
name=row["姓名"].strip(),
subject=row["科目"].strip(),
score=float(row["分数"]),
))
except (KeyError, ValueError, AttributeError) as e:
# 单行错误不中断整体,但要给出可定位的信息
raise ReportError(f"{path.name} 第 {lineno} 行格式错误:{row!r}") from e
except UnicodeDecodeError as e:
raise ReportError(f"{path.name} 不是 UTF-8 编码,请另存为 UTF-8") from e
except OSError as e:
raise ReportError(f"读取 {path.name} 失败:{e}") from e
if not scores:
raise ReportError(f"{path.name} 中没有有效数据行")
return scores
def summarize(scores: list[Score]) -> dict:
by_subject: dict[str, list[float]] = {}
for s in scores:
by_subject.setdefault(s.subject, []).append(s.score)
summary = {}
for subject, values in sorted(by_subject.items()):
summary[subject] = {
"人数": len(values),
"平均分": round(sum(values) / len(values), 2),
"最高分": max(values),
"最低分": min(values),
}
return summary
def atomic_write_json(path: Path, payload: dict) -> None:
"""先写同目录临时文件再原子替换,避免中断时留下半个文件。"""
path.parent.mkdir(parents=True, exist_ok=True)
fd, tmp = tempfile.mkstemp(dir=path.parent, suffix=".tmp")
try:
with os.fdopen(fd, "w", encoding="utf-8") as f:
json.dump(payload, f, ensure_ascii=False, indent=2)
f.flush() # 先把 Python 缓冲刷到操作系统
os.fsync(f.fileno()) # 再要求操作系统落盘
os.replace(tmp, path) # 原子替换
except BaseException:
Path(tmp).unlink(missing_ok=True) # 任何失败都清理临时文件
raise
def main() -> int:
src = Path("scores.csv")
dst = Path("report.json")
# 准备一份示例输入,方便直接运行本文件
if not src.exists():
src.write_text(
"姓名,科目,分数\n李雷,数学,95\n韩梅梅,数学,88\n李雷,物理,79\n韩梅梅,物理,91\n",
encoding="utf-8",
)
try:
scores = load_scores(src)
payload = {
"总记录数": len(scores),
"科目统计": summarize(scores),
"明细": [asdict(s) for s in scores],
}
atomic_write_json(dst, payload)
except ReportError as e:
# 能预期的业务错误:友好提示,返回非零退出码
print(f"[错误] {e}")
return 1
except Exception as e:
# 非预期错误:打印完整回溯,方便定位(生产环境应交给日志/监控)
import traceback
traceback.print_exc()
print(f"[致命] 未预期的错误:{type(e).__name__}: {e}")
return 2
print(f"已生成 {dst},共 {len(scores)} 条记录")
print(dst.read_text(encoding="utf-8"))
return 0
if __name__ == "__main__":
raise SystemExit(main())
运行输出(节选):
{
"总记录数": 4,
"科目统计": {
"数学": { "人数": 2, "平均分": 91.5, "最高分": 95.0, "最低分": 88.0 },
"物理": { "人数": 2, "平均分": 85.0, "最高分": 91.0, "最低分": 79.0 }
},
...
}
这个例子体现的设计取舍:
| 决策 | 理由 |
|---|---|
自定义 ReportError 作统一出口 | 调用方只写一个 except,同时能用 __cause__ 追根因 |
| 逐行处理而非整表处理 | 单行错误能精确定位到行号 |
os.fsync + os.replace | 保证「要么没有报告,要么是完整报告」,不会读到半截 JSON |
返回 int 退出码而不是 sys.exit | 让 main() 可被测试;SystemExit 只在最外层抛出 |
except Exception 放最后兜底 | 非预期错误必须留痕(打印回溯),不能静默 |
五、注意事项与常见坑
坑 1:
except的顺序必须从具体到宽泛```python
try:
do()
except Exception: # 先写宽的
print("通用处理")
except ValueError: # 永远到不了这里!
print("具体处理")
```
Python 按书写顺序匹配,第一个匹配的
except生效。宽泛的放最后。linter(如flake8)会对此发出警告。
坑 2:
except ... as e里的e在块结束后被删除```python
try:
1 / 0
except ZeroDivisionError as e:
pass
print(e) # NameError: name 'e' is not defined
```
这是刻意的设计(PEP 3110):避免异常对象与回溯形成引用环,从而延迟垃圾回收。需要在块外使用就把
e赋给别的变量,或err = e。
坑 3:在
except里raise新异常而不带from```python
except OSError as e:
raise MyError("失败") # 隐式链接,回溯里写着 "During handling of..."
```
虽然上下文仍被保留(
__context__),但语义模糊。显式写raise MyError("失败") from e表达因果关系;如果确实无关,写from None明确切断。
坑 4:
try块包得太大```python
try:
a = load() # 可能抛 FileNotFoundError
b = transform(a) # 可能抛 ValueError(不该在这里被当作加载失败)
save(b) # 可能抛 PermissionError
except FileNotFoundError:
...
```
try块越短越好,只包住确实会抛目标异常的那几行。其余逻辑放到else或try之外。
坑 5:
open后忘记关闭```python
data = open("a.txt", encoding="utf-8").read() # 文件句柄靠引用计数/GC 关闭,不可靠
```
CPython 的引用计数通常能及时关闭,但 PyPy 等实现不保证,且 Windows 上会占用文件锁。永远用
with。
坑 6:混用
os.path与pathlib导致类型混乱
os.path.join返回str,Path支持str参数,但把Path传给旧式 C 扩展有时需要str(p)。团队内统一一种风格,跨边界时显式转换。
坑 7:Windows 路径分隔符与转义
```python
path = "C:\new\test.txt" # \n 被当成换行符,\t 被当成制表符!
```
修法三选一:用原始字符串
r"C:\new\test.txt"、用正斜杠"C:/new/test.txt"(Python 在 Windows 上也能识别)、或用Path("C:/new/test.txt")。
实践建议
- 写库代码:把底层异常转成自己的领域异常,带
from e。- 写应用入口:
main()返回int退出码,最外层raise SystemExit(main())。- 写批处理脚本:单条记录失败不要中断整批,记录失败行号与原因,最后汇总。
- 所有
open()显式写encoding=;CSV 加newline="";给 Excel 用utf-8-sig。- 处理大文件时先在代码里写下「峰值内存 ≈ 一行大小」的注释,提醒自己不要退化成
read()。
六、练习题
- 基础题:写一个函数
safe_int(s, default=0),把字符串转成int,失败时返回default。要求捕获具体异常(ValueError),并思考为什么不捕获Exception。
- 基础题:下面的函数返回什么?先手算再运行验证,并解释原因。
```python
def tricky():
try:
return "A"
except Exception:
return "B"
else:
return "C"
finally:
return "D"
```
- 进阶题:实现一个
safe_write(path, text)函数,要求:(a) 用临时文件 +os.replace保证原子性;(b) 目录不存在时自动创建;(c) 写入失败时清理临时文件并抛出带根因的自定义异常WriteError;(d) 用with保证句柄关闭。写出完整代码与关键行注释。
- 进阶题:写一个统计大日志文件的函数,找出出现次数最多的前 5 个 IP 地址(日志每行格式形如
2026-10-11 10:00:01 INFO 192.168.1.7 GET /index)。要求:(a) 内存占用与文件大小无关;(b) 文件不存在时给出清晰错误;(c) 编码异常有专门提示;(d) 写出时间与空间复杂度(用 LaTeX),其中 是行数、 是不同 IP 数。
- 思考题:为什么 Python 把
KeyboardInterrupt和SystemExit放在Exception之外,而不是放在里面?如果把它们改成Exception的子类,会产生什么实际问题?举一个现实中的场景。
七、常见问题(FAQ)
Q1:try 会影响性能吗?需要把 try 放到循环外面吗?
A:进入 try 块本身几乎零开销(CPython 3.11+ 使用 zero-cost exception handling,不触发异常时与普通代码速度相同)。真正昂贵的是抛出异常:要构造异常对象、捕获回溯(读取栈帧信息,代价与栈深度相关)。所以:
- 不要为了避免
try而把代码写丑; - 不要在正常路径上大量抛异常(例如用异常判断「字符串是否为数字」——应该用
str.isdigit()或try/except但仅在失败率低时); - 若某异常确实高频发生,把它改成返回值或预检查是合理的优化。
Q2:finally 里可以写 raise 吗?
A:可以,但会替换正在传播的异常。如果 try 里抛了 A,finally 里又抛了 B,最终调用方看到 B,而 A 会作为 B.__context__ 保留。这通常不是你想要的效果——排查时容易误判。finally 只做清理,清理本身的失败要么吞掉(记日志)要么单独处理。
Q3:读取文件时到底该用 "r" 还是 "rb"?
A:看内容是否为文本。文本(人类可读、有编码概念:txt/csv/json/py/html)用 "r" + 显式 encoding。二进制(图片、音频、压缩包、pickle、任意字节协议)用 "rb"。判断标准是「换行符转换和编码解码对你有没有意义」——对 PNG 文件毫无意义,只会造成损坏。
Q4:pathlib 能完全取代 os.path 吗?
A:功能上基本可以,pathlib 覆盖了绝大部分 os.path 与部分 os/shutil 的能力。但三种情况仍需要别的工具:(a) shutil 的 rmtree、copytree、disk_usage 在 pathlib 里没有等价物;(b) 传给只接受 str 的第三方 C 扩展时需要 str(p);(c) os.walk 的「原地修改 dirnames 剪枝」在 Path.rglob 里没有直接对应。推荐默认用 pathlib,需要上述能力时再切回 os/shutil。
Q5:写 CSV 时为什么一定要 newline=""?
A:官方文档明确规定。csv 模块自己负责写入正确的行结束符(\r\n)。如果让文本层也做换行转换(Windows 上默认 \n → \r\n),就会产生 \r\r\n,表现为「每行之间多一个空行」。写入和读取都加 newline="" 最保险。
相关笔记
- Python-04-面向对象 ——
__enter__/__exit__、自定义异常类都依赖类与继承机制 - Python-03-函数与模块 —— 异常的传播路径就是调用栈,理解作用域与调用关系是前提
- Python-06-常用标准库 ——
pathlib、json、csv与标准库其他模块配合使用 - Python-07-进阶特性 —— 生成器与
yield是@contextmanager的实现基础 - 工具-07-调试技巧 —— 读懂回溯、二分定位错误是异常处理的实战延伸
参考来源
- Python 官方教程 · 错误和异常:https://docs.python.org/3/tutorial/errors.html
- 内置异常层次结构(完整继承树):https://docs.python.org/3/library/exceptions.html
contextlib· 上下文管理器工具:https://docs.python.org/3/library/contextlib.htmlio· 文本与二进制 IO、缓冲:https://docs.python.org/3/library/io.htmlpathlib· 面向对象的文件系统路径:https://docs.python.org/3/library/pathlib.htmlcsv· CSV 读写(含newline=""要求):https://docs.python.org/3/library/csv.htmljson· JSON 编解码:https://docs.python.org/3/library/json.htmltempfile· 临时文件与目录:https://docs.python.org/3/library/tempfile.htmlos.path· 常见路径操作:https://docs.python.org/3/library/os.path.html- PEP 343 · The "with" Statement:https://peps.python.org/pep-0343/
- PEP 3134 · Exception Chaining and Embedded Tracebacks:https://peps.python.org/pep-3134/
- PEP 3151 · Reworking the OS and IO exception hierarchy:https://peps.python.org/pep-3151/
- PEP 428 · The pathlib module:https://peps.python.org/pep-0428/
版本提示
海象运算符
:=需要 Python 3.8+;Path.unlink(missing_ok=True)需要 3.8+;shutil.copytree(dirs_exist_ok=)需要 3.8+;X | Y类型写法需要 3.10+。CPython 3.11 起异常的零开销处理机制有改进,具体性能特征以官方最新文档与 release notes 为准:https://docs.python.org/3/whatsnew/