w wyl123ly 的博客
MD

Python-05-异常与文件IO

56 KB 2026.10.11 原文件

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(作为异常抛出时使用)

从这棵树能读出三条设计意图:

  1. LookupError 同时罩住 IndexError 和 KeyError,所以 except LookupError 能一次抓住「索引越界」和「键不存在」。
  2. OSError 是平台错误的统一门面。PEP 3151 之前,文件不存在会抛 IOError 或 OSError 且带 errno,非常难写可移植代码;现在统一成 FileNotFoundError 等具体类型。
  3. 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总是(先执行)放「可能失败」的代码,只放必要的行
excepttry 中抛出匹配异常时处理错误
elsetry 中没有抛出异常时放「只有成功后才该做」的代码
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 条经验规则:

  1. 从 Exception(或其子类)派生,不要从 BaseException 派生。
  2. 继承一个项目自己的基类,调用方才有统一的兜底选择。
  3. __init__ 里调用 super().__init__(message),否则 str(e) 是空字符串。
  4. 不要只为了「多个名字」而建子类:如果两个异常的处理方式完全一样,用一个即可。
  5. 异常类名以 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)
对比项assertraise
语义内部不变量(程序员假设)契约违约(调用方错误)
编译优化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_typeNone异常类按类型决定是否压制
exc_valueNone异常实例读取消息
tracebackNone回溯对象记录现场
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"
读到的类型strbytes
是否做编码转换✅ 按 encoding 解码❌ 原始字节
换行符通用换行(\r\n → \n)原样保留
能否 seek只能在 tell() 返回值处 seek任意位置
适用文本文件(txt/csv/json/py)图片、音视频、压缩包、pickle、需要精确控制字节时
缓冲区类型TextIOWrapper → BufferedWriterBufferedReader
# 二进制:读写图片等非文本数据必须用 "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 localeutf-8正常
Windows 中文版(旧 Python)cp936(GBK)写出的文件在 UTF-8 环境里乱码
Windows(Python 3.15 起计划改为 UTF-8)变化中跨版本行为不一致
Docker 容器未设 localeascii 或 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() 直接删文件,都不进回收站。写这类脚本时先 print 出将要删除的绝对路径,确认无误后再执行 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 的类型映射与限制:

PythonJSON注意
dictobject键必须是 str/int/float/bool/None
list / tuplearray读回来都是 list(元组不保留)
strstring—
int / floatnumber大整数可能丢精度(JS 侧只保证 53 位)
True / Falsetrue / false—
Nonenull—
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()。


六、练习题

  1. 基础题:写一个函数 safe_int(s, default=0),把字符串转成 int,失败时返回 default。要求捕获具体异常(ValueError),并思考为什么不捕获 Exception。
  1. 基础题:下面的函数返回什么?先手算再运行验证,并解释原因。

```python

def tricky():

try:

return "A"

except Exception:

return "B"

else:

return "C"

finally:

return "D"

```

  1. 进阶题:实现一个 safe_write(path, text) 函数,要求:(a) 用临时文件 + os.replace 保证原子性;(b) 目录不存在时自动创建;(c) 写入失败时清理临时文件并抛出带根因的自定义异常 WriteError;(d) 用 with 保证句柄关闭。写出完整代码与关键行注释。
  1. 进阶题:写一个统计大日志文件的函数,找出出现次数最多的前 5 个 IP 地址(日志每行格式形如 2026-10-11 10:00:01 INFO 192.168.1.7 GET /index)。要求:(a) 内存占用与文件大小无关;(b) 文件不存在时给出清晰错误;(c) 编码异常有专门提示;(d) 写出时间与空间复杂度(用 LaTeX),其中 是行数、 是不同 IP 数。
  1. 思考题:为什么 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.html
  • io · 文本与二进制 IO、缓冲:https://docs.python.org/3/library/io.html
  • pathlib · 面向对象的文件系统路径:https://docs.python.org/3/library/pathlib.html
  • csv · CSV 读写(含 newline="" 要求):https://docs.python.org/3/library/csv.html
  • json · JSON 编解码:https://docs.python.org/3/library/json.html
  • tempfile · 临时文件与目录:https://docs.python.org/3/library/tempfile.html
  • os.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/