Python函数-常用内置模块&开发规范 • Lostman

一、常用内置模块—os

1、os 模块是什么？

1.1、概念

os 是 Python 标准库中与操作系统交互的“总管”。它把 POSIX/Linux、Windows、macOS 等底层系统调用包装成统一的 Python 接口，让你用同一套代码管理文件、目录、进程、环境变量等。

1.2、导入方式

import os

2、常用方法（按功能分组）

2.1、目录/文件路径操作

方法	作用	常用参数	返回值
`os.getcwd()`	获取当前工作目录	无	`str`，绝对路径
`os.chdir(path)`	切换工作目录	path: `str`, 目标目录	无
`os.listdir(path='.')`	列出目录内容	path: `str` 或 `bytes`	`list[str]`
`os.walk(top, topdown=True, onerror=None, followlinks=False)`	按目录树自顶向下或自底向上遍历文件夹	top: 起始目录 topdown=True：先父后子；设 False 则先子后父 followlinks=False：是否跟进软链接（默认 False，避免死循环）	生成器，每次 yield 一个三元组：(当前目录路径, 子目录列表, 文件列表)
`os.mkdir(path, mode=0o777)`	创建单级目录	path: `str`; mode: Unix 权限	无
`os.makedirs(name, mode=0o777, exist_ok=False)`	递归创建多级目录	name: `str`; exist_ok: 若 True 已存在不抛异常	无
`os.rmdir(path)`	删除空目录	path: `str`	无
`os.removedirs(name)`	递归删空目录链	name: `str`	无
`os.remove(path)`	删除单个文件	path: `str`	无
`os.rename(src, dst)`	重命名或移动文件/目录	src, dst: `str`	无
`os.path.exists(path)`	判断路径是否存在	path: `str`	`bool`
`os.path.isfile(path)`	判断是否为普通文件	path: `str`	`bool`
`os.path.isdir(path)`	判断是否为目录	path: `str`	`bool`
`os.path.join(a, *p)`	拼接路径	任意多个 `str`	`str`（带平台分隔符）

2.2、环境变量与进程

方法	作用	常用参数	返回值
`os.getenv(key, default=None)`	读取环境变量	key: `str`; default: 默认值	`str`、`None`
`os.environ`	环境变量映射	可读写 dict-like	`os._Environ`
`os.system(command)`	在子 shell 中执行命令	command: `str`	`int`（退出码）
`os.getpid()`	当前进程 PID	无	`int`
`os.kill(pid, sig)`	发信号给进程（Unix）	pid: `int`; sig: `int`	无

2.3、文件描述符/权限

方法	作用	常用参数	返回值
`os.open(path, flags, mode=0o777)`	低层打开文件，返回描述符	path: `str`; flags: `int`	`int`，fd
`os.close(fd)`	关闭文件描述符	fd: `int`	无
`os.chmod(path, mode)`	修改权限	path: `str`; mode: `int`	无
`os.stat(path)`	获取文件元信息	path: `str`	`os.stat_result` 命名元组

2.4、路径字符串高级工具（os.path 子模块）

语法	作用	常用参数	返回值
`os.path.abspath(path)`	转绝对路径	path: `str`	`str`
`os.path.dirname(p)`	取目录部分，若 `p` 已是目录，则返回其上一级目录	p: `str`	`str`
`os.path.basename(p)`	取文件名部分	p: `str`	`str`
`os.path.splitext(p)`	拆分“文件名+扩展名”	p: `str`	`tuple[str, str]`

3、快速对照示例

import os

# 1. 目录相关
os.makedirs('tmp/sub', exist_ok=True)   # 递归建目录
print(os.listdir('tmp'))                # ['sub']

# 2. 环境变量
path = os.getenv('PATH')
print(path.split(os.pathsep))           # PATH 列表

# 3. 文件描述符
fd = os.open('tmp/demo.txt', os.O_WRONLY | os.O_CREAT)
os.write(fd, b'hello os\n')
os.close(fd)

# 4. 路径工具
full = os.path.abspath('tmp/demo.txt')  # 绝对路径
root, ext = os.path.splitext(full)      # ('/…/tmp/demo', '.txt')

二、常用内置模块—shutil

1、shutil 模块是什么？

1.1、概念

shutil（shell utilities 的缩写）是 Python 标准库中 高级文件与目录操作 模块，用来弥补 os 模块在“复制、压缩、递归删除”等高阶功能上的不足。它封装了底层系统调用，支持一次性操作整个目录树、跨平台归档、压缩等。

1.2、导入方式

import shutil

2、常用方法（按功能分组）

2.1、复制相关

语法	作用	常用参数	返回值
`shutil.copy(src, dst, *, follow_symlinks=True)`	复制文件内容+权限（不含元数据）	src, dst: `str` / `Path`；follow_symlinks: 是否跟随符号链接	`str`，目标路径
`shutil.copy2(src, dst, *, follow_symlinks=True)`	复制文件内容+权限+元数据（含时间戳）	同上	`str`，目标路径
`shutil.copyfile(src, dst, *, follow_symlinks=True)`	仅复制内容（无权限/元数据）	同上	`str`，目标路径
`shutil.copymode(src, dst, *, follow_symlinks=True)`	仅复制权限位	同上	无
`shutil.copystat(src, dst, *, follow_symlinks=True)`	仅复制权限位+元数据（不含内容）	同上	无
`shutil.copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2, dirs_exist_ok=False)`	递归复制整个目录树	src, dst: `str` / `Path`；dirs_exist_ok: 允许目标已存在；其余见文档	`str`，目标路径

2.2、移动 / 删除

语法	作用	常用参数	返回值
`shutil.move(src, dst, copy_function=copy2)`	移动文件或目录（跨文件系统自动复制+删除）	src, dst: `str` / `Path`；copy_function: 拷贝函数	`str`，目标路径
`shutil.rmtree(path, ignore_errors=False, onerror=None)`	递归删除整个目录树	path: `str` / `Path`；onerror: 回调处理删除失败	无

2.3、磁盘使用

语法	作用	常用参数	返回值
`shutil.disk_usage(path)`	查询磁盘空间	path: `str` / `Path`	`namedtuple(total, used, free)`，单位字节

2.4、归档 / 压缩

语法	作用	常用参数	返回值
`shutil.make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0, dry_run=False, owner=None, group=None, logger=None)`	创建压缩归档（zip/tar/gztar/bztar/xztar）	base_name: 不含扩展名；format: `'zip'` 等；root_dir: 打包根目录	`str`，生成的归档文件完整路径
`shutil.unpack_archive(filename, extract_dir=None, format=None)`	解压缩归档	filename: `str`；extract_dir: 解压目录；format: 自动推断或显式指定	无
`shutil.get_archive_formats()`	获取当前系统支持的归档格式列表	无	`list[tuple[str, str]]`
`shutil.get_unpack_formats()`	获取支持的解压格式列表	无	`list[tuple[str, str, str]]`

3、快速对照示例

import shutil, os, pathlib

# 1. 复制文件
shutil.copy2('data/report.txt', 'backup/report.txt')

# 2. 递归复制目录
dst = shutil.copytree('src', 'src_backup', dirs_exist_ok=True)

# 3. 移动目录
shutil.move('src_backup', 'archive/src_2025')

# 4. 删除目录
shutil.rmtree('tmp/cache')

# 5. 磁盘空间
usage = shutil.disk_usage('/')
print(usage.free / 2**30, 'GiB free')

# 6. 打包
zip_path = shutil.make_archive('project', 'zip', root_dir='.')
print('created', zip_path)

# 7. 解包
shutil.unpack_archive('project.zip', 'unpacked')

三、常用内置模块—sys

1、sys 模块是什么？

1.1、概念

sys 是 Python 解释器自带的系统级接口模块，提供与当前进程运行环境交互的变量和函数，如命令行参数、模块搜索路径、标准 I/O 和退出控制。是调试、部署和跨平台脚本中不可或缺的“解释器管家”。

1.2、导入方式

import sys

2、常用方法（按功能分组）

2.1、命令行与环境信息

语法	作用	参数	返回值
`sys.argv`	以列表形式存放启动脚本时的命令行参数，`argv[0]` 为脚本名	无	`List[str]`
`sys.executable`	当前 Python 解释器的绝对路径	无	`str`
`sys.path`	模块搜索路径列表（可修改）	无	`List[str]`
`sys.prefix`	当前 Python 安装前缀（虚拟环境时为虚拟环境根目录）	无	`str`

2.2、程序退出与异常

语法	作用	参数	返回值
`sys.exit([arg])`	立即终止解释器；`arg` 可为整数、字符串或对象	`arg=None`	无（进程结束）
`sys.exc_info()`	获取当前线程正在处理的异常三元组	无	`(type, value, traceback)`
`sys.last_type` / `sys.last_value` / `sys.last_traceback`	交互式解释器中最近一次未捕获异常信息	无	与 `exc_info()` 对应

2.3、标准 I/O 流重定向（文件对象）

语法	作用	参数	返回值
`sys.stdin`	标准输入流	无	`TextIOWrapper`
`sys.stdout`	标准输出流	无	`TextIOWrapper`
`sys.stderr`	标准错误流	无
`sys.__stdin__` / `__stdout__` / `__stderr__`	启动时的原始流备份	无	`TextIOWrapper`

2.4、模块加载与元数据

语法	作用	参数	返回值
`sys.modules`	已加载模块的字典（键为模块名，值为模块对象）	无	`Dict[str, Module]`
`sys.meta_path`	自定义导入机制的查找器列表	无	`List[MetaPathFinder]`
`sys.builtin_module_names`	解释器内置模块名称的元组	无	`Tuple[str, ...]`

2.5、解释器与运行时信息

语法	作用	参数	返回值
`sys.version`	解释器版本字符串	无	`str`
`sys.version_info`	版本号组成的命名元组（major, minor, micro, releaselevel, serial）	无	`sys.version_info`
`sys.platform`	平台标识符，如 `'win32'`、`'linux'`、`'darwin'`	无	`str`
`sys.implementation`	当前 Python 实现的信息命名元组	无	`SimpleNamespace`

2.6、引用计数与垃圾回收

语法	作用	参数	返回值
`sys.getrefcount(obj)`	返回对象的引用计数（+1，因形参本身）	`obj: Any`	`int`
`sys.getsizeof(obj[, default])`	返回对象占用内存字节数（CPython 实现）	`obj: Any, default=...`	`int`

2.7、递归/栈限制

语法	作用	参数	返回值
`sys.getrecursionlimit()`	获取当前最大递归深度	无	`int`
`sys.setrecursionlimit(limit)`	设置最大递归深度	`limit: int`	无

2.8、跟踪与性能分析

语法	作用	参数	返回值
`sys.settrace(func)`	安装全局跟踪函数，用于调试/性能分析	`func: TraceFunc \| None`	无
`sys.gettrace()`	获取当前全局跟踪函数	无	`TraceFunc \| None`
`sys.setprofile(func)`	安装性能分析函数	`func: ProfileFunc \| None`	无
`sys.getprofile()`	获取当前性能分析函数	无	`ProfileFunc \| None`

2.9、字节序与整数信息

语法	作用	参数	返回值
`sys.byteorder`	本机字节序，`'little'` 或 `'big'`	无	`str`
`sys.maxsize`	平台最大 `Py_ssize_t` 值（列表索引上限）	无	`int`

2.10、其他实用工具

语法	作用	参数	返回值
`sys.intern(string)`	将字符串驻留（intern），减少重复对象	`string: str`	`str`
`sys.getdefaultencoding()`	获取当前默认字符串编码	无	`str`

3、快速对照示例

import sys, os, pathlib

# 1. 命令行参数
print(sys.argv)                       # ['demo.py', '--verbose', '42']

# 2. 解释器路径
print(sys.executable)                 # /usr/bin/python3.11

# 3. 模块搜索路径（添加自定义目录）
sys.path.insert(0, './my_pkgs')

# 4. 版本信息
print(sys.version)                    # 3.11.4 (main, Jun  6 2023, 00:00:00) ...

# 5. 退出程序并返回状态码
# sys.exit(0)                         # 正常退出

# 6. 标准输入逐行读取
for line in sys.stdin:
    sys.stdout.write(line.upper())

# 7. 刷新缓冲区
sys.stdout.flush()

四、常用内置模块—random

1、random 模块是什么？

1.1、概念

random 基于 Mersenne Twister 伪随机数生成器，为仿真、抽样、加密强度以下的一般随机需求提供快速实现。

1.2、导入方式

import random

2、常用方法（按功能分组）

2.1、初始化与状态管理

语法	作用	参数	返回值
`random.seed(a=None, version=2)`	用可哈希对象 a 初始化随机状态；None → 系统时间	`a`: int/str/bytes/None `version`: 2 或 1	`None`
`random.getstate()`	获取当前随机数生成器状态（可恢复）	无	`tuple`（状态对象）
`random.setstate(state)`	恢复先前保存的状态	`state`: `tuple`	`None`
`random.getrandbits(k)`	生成 k 位（二进制位）随机整数	`k`: int ≥ 0	`int`

2.2、区间随机整数

语法	作用	参数	返回值
`random.randrange(stop)` `random.randrange(start, stop[, step])`	从 `range(start, stop, step)` 中随机返回一个整数	同 `range()`	`int`
`random.randint(a, b)`	闭区间 `[a, b]` 内随机整数	`a, b`: int	`int`

2.3、区间随机浮点数

语法	作用	参数	返回值
`random.random()`	`[0.0, 1.0)` 之间的随机浮点数	无	`float`
`random.uniform(a, b)`	`[a, b]`（或 `[b, a]`）之间的随机浮点数	`a, b`: float	`float`
`random.triangular(low, high, mode)`	三角分布随机数，`mode` 为峰值	`low, high, mode`: float	`float`
`random.betavariate(alpha, beta)`	Beta(α, β) 分布	α, β > 0	`float`
`random.expovariate(lambd)`	指数分布，λ 为率参数	`lambd`: float > 0	`float`
`random.gammavariate(alpha, beta)`	Gamma(α, β) 分布	α, β > 0	`float`
`random.gauss(mu, sigma)`	高斯（正态）分布	`mu, sigma`: float	`float`
`random.normalvariate(mu, sigma)`	高斯分布（线程安全实现）	`mu, sigma`: float	`float`
`random.lognormvariate(mu, sigma)`	对数正态分布	`mu, sigma`: float	`float`
`random.vonmisesvariate(mu, kappa)`	von Mises（圆周正态）分布	`mu`: float（弧度） `kappa`: float ≥ 0	`float`
`random.paretovariate(alpha)`	帕累托分布	`alpha`: float > 0	`float`
`random.weibullvariate(alpha, beta)`	威布尔分布	`alpha, beta`: float > 0	`float`

2.4、序列随机操作

语法	作用	参数	返回值
`random.choice(seq)`	从非空序列中随机返回一个元素	`seq`: Sequence	元素
`random.choices(population, weights=None, *, cum_weights=None, k=1)`	有放回抽样，可带权重	`population`: Sequence `weights/cum_weights`: Sequence[float]	None `k`: int、`List[Any]`
`random.sample(population, k, *, counts=None)`	无放回抽样 k 个不同元素	`population`: Sequence `k`: int ≤ len(population) `counts`: Sequence[int]	None、`List[Any]`
`random.shuffle(x[, random])`	就地打乱可变序列	`x`: MutableSequence `random`: 可调用随机源	`None`

2.5、字节级随机

语法	作用	参数	返回值
`random.randbytes(n)`	生成 n 个随机字节	`n`: int ≥ 0	`bytes`

2.6、线程安全扩展（random.Random）

语法	作用	参数	返回值
`random.Random([seed])`	创建独立随机实例，线程隔离	`seed`: 同 `seed()`	`Random` 实例
`random.SystemRandom()`	基于操作系统熵源，加密安全	无	`SystemRandom` 实例（无 `setstate` 等）

2.7、3.12+ 新增（可选）

语法	作用	参数	返回值
`random.binomialvariate(n, p)`	二项分布	`n`: int ≥ 0 `p`: 0 ≤ float ≤ 1	`int`

3、快速对照示例

import random

# 初始化
random.seed(42)

# 整数
print(random.randint(1, 6))          # 骰子
print(random.randrange(0, 100, 10))  # 0~90 步长 10

# 浮点数
print(random.uniform(1.5, 2.5))

# 序列
cards = ['A', 'K', 'Q', 'J']
random.shuffle(cards)
print(cards)

# 带权重抽样
print(random.choices(['red', 'green', 'blue'], weights=[5, 2, 1], k=5))

五、常用内置模块—hashlib

1、hashlib 模块是什么？

1.1、概念

hashlib 是一个面向消息摘要（哈希）算法的统一接口，支持 SHA-1、SHA-2、SHA-3、BLAKE2、MD5 等安全散列与加密散列算法。

1.2、导入方式

import hashlib

2、常用方法（按功能分组）

2.1、一次性哈希（快捷函数）

语法	作用	参数	返回值
`hashlib.new(name, data=b'', *, usedforsecurity=True)`	按算法名 name 创建哈希对象；支持 OpenSSL 扩展	`name`: str `data`: bytes-like	`hash object`
`hashlib.md5(data=b'')`	MD5 散列	`data`: bytes-like	`hash object`
`hashlib.sha1(data=b'')`	SHA-1 散列	`data`: bytes-like	`hash object`
`hashlib.sha224(data=b'')`	SHA-224 散列	`data`: bytes-like	`hash object`
`hashlib.sha256(data=b'')`	SHA-256 散列	`data`: bytes-like	`hash object`
`hashlib.sha384(data=b'')`	SHA-384 散列	`data`: bytes-like	`hash object`
`hashlib.sha512(data=b'')`	SHA-512 散列	`data`: bytes-like	`hash object`
`hashlib.sha3_224(data=b'')`	SHA-3-224 散列	`data`: bytes-like	`hash object`
`hashlib.sha3_256(data=b'')`	SHA-3-256 散列	`data`: bytes-like	`hash object`
`hashlib.sha3_384(data=b'')`	SHA-3-384 散列	`data`: bytes-like	`hash object`
`hashlib.sha3_512(data=b'')`	SHA-3-512 散列	`data`: bytes-like	`hash object`
`hashlib.shake_128(data=b'')`	SHAKE-128 可扩展输出	`data`: bytes-like	`shake object`
`hashlib.shake_256(data=b'')`	SHAKE-256 可扩展输出	`data`: bytes-like	`shake object`
`hashlib.blake2b(data=b'', *, digest_size=64, key=b'', salt=b'', person=b'')`	BLAKE2b 可变输出	同上 + 可选 key/salt/person	`blake2b object`
`hashlib.blake2s(data=b'', *, digest_size=32, key=b'', salt=b'', person=b'')`	BLAKE2s 可变输出	同上	`blake2s object`

2.2、哈希对象通用方法（所有算法对象共享）

语法	作用	参数	返回值
`h.update(data)`	追加更多数据到哈希上下文	`data`: bytes-like	`None`
`h.digest()`	返回二进制摘要	无	`bytes`
`h.hexdigest()`	返回十六进制字符串摘要	无	`str`
`h.copy()`	创建当前哈希对象的浅拷贝	无	`hash object`
`h.digest_size`	摘要字节长度（只读）	无	`int`
`h.block_size`	算法块大小（只读）	无	`int`
`h.name`	算法名称（只读）	无	`str`

2.3、SHAKE 可变长度输出对象（额外方法）

语法	作用	参数	返回值
`s.digest(length)`	生成指定字节长度的摘要	`length`: int	`bytes`
`s.hexdigest(length)`	生成指定长度的十六进制摘要	`length`: int	`str`

2.4、BLAKE2 对象特有可调属性（读写）

语法	作用	参数	返回值
`b.digest_size = n`	修改/查看 BLAKE2 输出字节数	`n`: int (blake2b: 1-64, blake2s: 1-32)	`int`
`b.key = key`	设置/查看密钥（仅创建后一次性设置有效）	`key`: bytes-like	`bytes`
`.salt` / `.person`	设置/查看 salt 或 personalization	同上	`bytes`

2.5、安全常量与辅助查询

语法	作用	参数	返回值
`hashlib.algorithms_available`	当前解释器可用的全部算法名集合	无	`set[str]`
`hashlib.algorithms_guaranteed`	所有平台都保证可用的算法名集合	无	`set[str]`

2.6、基于密码的密钥派生（PBKDF2）

语法	作用	参数	返回值
`hashlib.pbkdf2_hmac(hash_name, password, salt, iterations, dklen=None)`	使用 PBKDF2-HMAC 派生密钥	`hash_name`: str `password`: bytes-like `salt`: bytes-like `iterations`: int `dklen`: int	None、`bytes`

3、快速对照示例

import hashlib

# 1. 一次性
md5_hex = hashlib.md5(b'hello').hexdigest()

# 2. 分块处理大文件
sha256 = hashlib.sha256()
with open('big.iso', 'rb') as f:
    for chunk in iter(lambda: f.read(1 << 20), b''):
        sha256.update(chunk)
print(sha256.hexdigest())

# 3. PBKDF2 密钥派生
dk = hashlib.pbkdf2_hmac('sha256', b'password', b'salt', 100000)

六、常用内置模块—configparser

1、configparser 模块是什么？

1.1、概念

configparser 用来读写 Windows INI 风格（也可自定义分隔符）的配置文件，支持节（section）、键值对、插值、类型转换、默认值、嵌套节等功能。

1.2、导入方式

import configparser

2、常用方法（按功能分组）

2.1、读取与解析

语法	作用	参数	返回值
`configparser.ConfigParser(*, defaults=None, dict_type=dict, allow_no_value=False, delimiters=('=', ':'), comment_prefixes=('#', ';'), inline_comment_prefixes=None, strict=True, empty_lines_in_values=True, default_section='DEFAULT', interpolation=BasicInterpolation(), converters={})`	创建解析器实例	见左侧完整关键字形参	`ConfigParser` 实例
`cfg.read(filenames, encoding=None)`	依次读取文件/路径/文件对象列表，解析配置	`filenames`: str、Path、file-like、list thereof `encoding`: str	None、list[str]（成功读取的文件名）
`cfg.read_file(f, source=None)`	从文件对象读取	`f`: file-like `source`: str（用于错误提示）	`None`
`cfg.read_string(string, source='<string>')`	从字符串读取	`string`: str	`None`
`cfg.read_dict(mapping, source='<dict>')`	从 dict（可嵌套）读取	`mapping`: dict-like	`None`

2.2、写回与保存

语法	作用	参数	返回值
`cfg.write(fileobject, space_around_delimiters=True)`	将当前配置全部写回文件对象	`fileobject`: file-like `space_around_delimiters`: bool	`None`

2.3、访问与修改值

语法	作用	参数	返回值
`cfg.sections()`	返回所有节的名称（不含 DEFAULT）	无	list[str]
`cfg.has_section(section)`	判断节是否存在	`section`: str	bool
`cfg.add_section(section)`	新建空节	`section`: str	`None`，已存在则 `DuplicateSectionError`
`cfg.remove_section(section)`	删除节及其所有键值	`section`: str	bool（是否删除成功）
`cfg.options(section)`	返回某节的所有键（含 DEFAULT 继承）	`section`: str	list[str]
`cfg.has_option(section, option)`	判断键是否存在	`section, option`: str	bool
`cfg.get(section, option, *, raw=False, vars=None, fallback=_UNSET)`	获取字符串值	同上	str
`cfg.getint(section, option, *, raw=False, vars=None, fallback=_UNSET)`	获取整数值	同上	int
`.getfloat`	获取浮点值	同上	float
`.getboolean`	获取布尔值（识别 1/0, yes/no, true/false…）	同上	bool
`cfg.set(section, option, value)`	设置键值	`section, option, value`: str	`None`
`cfg.remove_option(section, option)`	删除键	`section, option`: str	bool（是否删除成功）

2.4、默认值与特殊节

语法	作用	参数	返回值
`cfg.defaults()`	返回 DEFAULT 节的 dict 视图	无	dict[str, str]
`cfg.default_section`	读写默认节名（常为 `'DEFAULT'`）	无 / str	str

2.5、插值（变量替换）

语法	作用	参数	返回值
`configparser.BasicInterpolation()`	默认插值器：支持 `%(key)s`	无	插值器实例
`configparser.ExtendedInterpolation()`	跨节插值器：支持 `${section:key}`	无	插值器实例
构造时通过 `interpolation=` 参数设置	指定插值器	插值器实例	—

2.6、转换器（类型扩展）

语法	作用	参数	返回值
`cfg.converters['name'] = func`	注册自定义转换器，之后可用 `.getname()`	`func`: str → T	dict
`cfg.converters['list'] = lambda s: s.split(',')`	使用 `cfg.getlist(section, option)`	—	—

2.7、错误类（均在 configparser 命名空间）

名称	作用
`NoSectionError`	访问不存在的节
`DuplicateSectionError`	重复添加节
`NoOptionError`	访问不存在的键
`InterpolationError` 及其子类	插值失败

3、快速对照示例

[DEFAULT]
server = localhost
port   = 5432

[db]
user   = alice
password = secret
port     = 3306   ; 覆盖 DEFAULT

import configparser, pathlib

cfg = configparser.ConfigParser()
cfg.read(pathlib.Path('example.ini'))

# 访问
print(cfg.get('db', 'user'))            # alice
print(cfg.getint('db', 'port'))         # 3306
print(cfg.get('db', 'server'))          # localhost（继承 DEFAULT）

# 修改
cfg.set('db', 'ssl', 'true')
with open('example.ini', 'w') as f:
    cfg.write(f)

七、常用内置模块—xml

1、xml 模块是什么？

1.1、概念

1.2、导入方式

2、常用方法（按功能分组）

2.1、轻量读写：xml.etree.ElementTree（ET）

语法	作用	参数	返回值
`ET.parse(source, parser=None)`	把文件/路径/文件对象解析成 `ElementTree`	`source`: str、Path、file-like `parser`: XMLParser	`ElementTree`
`ET.fromstring(text, parser=None)`	把字符串解析成根 `Element`	`text`: str/bytes	`Element`
`ET.tostring(element, encoding='unicode', method='xml', *, short_empty_elements=True)`	把元素序列化成字符串	`element`: Element	str/bytes
`ET.Element(tag, attrib={}, **extra)`	新建元素	`tag`: str `attrib`: dict	`Element`
`ET.SubElement(parent, tag, attrib={}, **extra)`	在父节点下新建子元素	同上	`Element`
`ET.dump(elem)`	调试：直接把元素打印到 stdout	`elem`: Element	`None`

2.2、ElementTree 对象：遍历与修改

语法	作用	参数	返回值
`tree.getroot()`	获取根元素	无	`Element`
`tree.write(file, encoding='utf-8', xml_declaration=False)`	整树写回文件	`file`: str、Path、file-like	`None`

2.3、Element 对象：树形操作

语法	作用	参数	返回值
`elem.find(path, namespaces=None)`	按 XPath 找首个匹配子元素	`path`: str	`Element`、`None`
`elem.findall(path, namespaces=None)`	找所有匹配	`path`: str	list[Element]
`elem.iter(tag=None)`	深度优先迭代所有后代	`tag`: str	generator[Element]
`elem.get(key, default=None)`	取属性	`key`: str	str
`elem.set(key, value)`	设属性	`key`, `value`	`None`
`elem.text = "..."`	读写文本内容	—	str
`elem.append(sub)`	追加子节点	`sub`: Element	`None`
`elem.remove(sub)`	删除子节点	`sub`: Element	`None`

2.4、增量解析：xml.etree.ElementTree.XMLPullParser

语法	作用	参数	返回值
`ET.XMLPullParser(events=('start','end'))`	创建增量解析器	`events`: tuple[str]	`XMLPullParser`
`parser.feed(data)`	增量喂入数据	`data`: bytes/str	`None`
`parser.read_events()`	返回已解析事件生成器	无	generator[tuple[event,elem]]

2.5、DOM 树：xml.dom.minidom

语法	作用	参数	返回值
`minidom.parse(file)`	文件→DOM 树	`file`: str、Path、file-like	`Document`
`minidom.parseString(string)`	字符串→DOM 树	`string`: str/bytes	`Document`
`doc.toxml(encoding=None)`	DOM→XML 字符串	`encoding`: str	str
`doc.writexml(writer, indent='', addindent='', newl='')`	DOM→文件	`writer`: file-like	`None`

2.6、SAX 流式解析：xml.sax

语法	作用	参数	返回值
`sax.make_parser()`	创建 SAX 解析器	无	`xmlreader.XMLReader`
`sax.parse(source, handler)`	一次性解析文件	`source`: str、Path `handler`: ContentHandler	`None`
`sax.parseString(string, handler)`	解析字符串	同上	`None`

2.7、SAX 事件处理器基类

语法	作用	参数	返回值
`class MyHandler(sax.ContentHandler)`	自定义事件处理器	无	—
`def startElement(self, name, attrs)`	遇到开始标签回调	同上	`None`
`def characters(self, content)`	文本数据回调	`content`: str	`None`
`def endElement(self, name)`	遇到结束标签回调	`name`: str	`None`

2.8、低级 Expat 解析器：xml.parsers.expat

语法	作用	参数	返回值
`xml.parsers.expat.ParserCreate(encoding=None, namespace_separator=None)`	创建 Expat 解析器	同上	`xmlparser`
`parser.Parse(data, isfinal=False)`	解析数据块	`data`: bytes/str `isfinal`: bool	无（事件通过回调）

2.9、XPath 工具：xml.etree.ElementTree.ElementPath（简化）

语法	作用	参数	返回值
`elem.iterfind(path, namespaces=None)`	生成器版 findall	同上	generator[Element]
`elem.findtext(path, default=None, namespaces=None)`	直接取文本	同上	str

2.10、命名空间支持

语法	作用	参数	返回值
`ET.register_namespace(prefix, uri)`	全局注册命名空间前缀	`prefix, uri`: str	`None`
`elem.tag = '{uri}local'`	读写 Clark 记号	—	str

2.11、实用快捷工具

语法	作用	参数	返回值
`ET.indent(tree, space=' ')`	3.9+ 自动格式化缩进	`tree`: Element、ElementTree `space`: str	`None`