Python on 纪伟的个人博客

Python 编程基础与工程实践（十）：性能分析、构建与交付

Wed, 08 Jul 2026 10:00:00 +0800

性能优化最危险的方式是凭感觉重写代码，交付最危险的方式是“把开发目录复制到服务器试试”。前者可能优化不存在的瓶颈，后者无法证明生产运行的代码就是测试过的代码。

本文是系列收官篇，以 Python 3.14 为基线，建立“定义目标—测量—定位—优化—回归”的性能闭环，并说明如何构建、验证和交付 Python 应用或库。

1. 先定义性能问题

“程序慢”至少可能指：

单次请求延迟高；
吞吐量不足；
P95/P99 尾延迟抖动；
启动时间过长；
内存峰值或常驻集过大；
CPU、磁盘、网络或数据库资源耗尽；
达到目标负载时错误率上升。

优化前先确定指标、输入规模、机器、解释器构建、依赖版本和并发度。微基准快 20% 不代表端到端请求更快：真正瓶颈可能在网络、数据库锁或下游限流。

一个可验证目标应类似：“在指定测试环境和固定数据集上，100 个并发请求下 P95 小于 200 ms，错误率低于 0.1%，进程内存峰值小于 512 MiB”，而不是“尽量快”。数字应来自项目约束，不应照抄别人的经验阈值。

2. 正确测量小段代码

timeit 会重复执行小段代码，适合比较局部实现：

1

python -m timeit -s "values = list(range(10000))" "sum(values)"

也可以在代码中使用：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


from timeit import repeat


results = repeat(
 "sum(values)",
 setup="values = list(range(10000))",
 repeat=5,
 number=1000,
)
print(min(results))

取最小值有助于观察较少受系统干扰的一次，但完整分布也有价值。微基准要注意：

包含必要初始化，排除不相关启动成本；
防止比较双方做了不同工作；
使用具有代表性的数据规模和分布；
多次运行，记录解释器、硬件和系统负载；
不从纳秒级差异推导生产结论。

端到端基准应使用单独压测工具和接近生产的依赖环境，并同时观察错误率和资源使用。

3. 用 `cProfile` 找热点

标准库推荐大多数用户使用 cProfile 做确定性分析：

1
2


python -m cProfile -o profile.pstats -m temperature_service.cli
python -m pstats profile.pstats

进入 pstats 后可按累计时间排序：

1
2


sort cumulative
stats 30

关注：

tottime：函数自身消耗时间；
cumtime：函数及其调用链累计时间；
调用次数：是否存在意外的 N+1 或重复解析；
调用路径：热点究竟来自业务代码、序列化还是外部库。

Profiler 本身会引入开销，尤其会让 Python 级代码和 C 扩展的相对表现失真。它适合定位热点，不适合充当精确基准；优化前后仍要回到独立测量。

4. 从算法和数据结构开始

通常最有价值的优化不是把循环换成晦涩表达式，而是减少工作量：

1
2
3
4
5


# 每次在线性列表中查找
allowed_list = [f"ID-{index}" for index in range(100_000)]

# 如果语义是频繁成员检查，预先构造集合
allowed_set = set(allowed_list)

集合平均成员检查通常比列表线性扫描更适合这一任务，但集合需要额外内存，且最坏情况与实际常数仍受实现和数据影响。先按语义选结构，再用真实数据验证。

常见高收益方向：

消除重复 I/O、重复解析和 N+1 查询；
批量处理，减少跨进程、网络和数据库往返；
使用字典或集合建立索引；
把循环不变量移出热路径；
避免无意义的中间容器；
给缓存设置容量、过期和一致性策略。

缓存会用内存和一致性复杂度换时间。没有失效策略、命中率和容量边界的缓存，不是免费的性能优化。

5. 惰性处理与内存占用

生成器能避免一次加载全部数据：

1
2
3
4
5
6
7
8
9


from collections.abc import Iterator
from pathlib import Path


def read_values(path: Path) -> Iterator[float]:
 with path.open(encoding="utf-8") as file:
 for line in file:
 if text := line.strip():
 yield float(text)

但生成器会把错误和资源生命周期推迟到消费时。不要返回一个依赖已关闭文件的生成器，也不要在需要多次遍历时误以为它能自动重放。

sys.getsizeof() 只报告对象本身直接占用的大小，不会递归计算它引用的整个对象图，也属于实现相关信息：

1
2
3
4
5


import sys


values = [1, 2, 3]
print(sys.getsizeof(values))

因此不能把这个数字当成列表及全部整数的总内存。

6. 用 `tracemalloc` 定位 Python 分配

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import tracemalloc


tracemalloc.start()

before = tracemalloc.take_snapshot()
result = build_report() # 以你的待测函数为例
after = tracemalloc.take_snapshot()

for statistic in after.compare_to(before, "lineno")[:10]:
 print(statistic)

tracemalloc 跟踪 Python 内存分配及其调用位置，适合比较快照和发现持续增长的分配点。它不等于进程总内存监控：原生库、内存映射、分配器保留和操作系统页面都可能不完整地反映在其中。

诊断内存要区分：

暂时峰值；
仍被 Python 引用的对象；
已释放给 Python 分配器但未归还操作系统的内存；
C 扩展或外部进程分配；
无界缓存、队列和任务积压。

不要通过频繁手工 gc.collect() 掩盖对象仍被引用的问题；先找持有路径和增长来源。

7. 解释器、扩展与并行策略

性能不足时可按成本逐层选择：

改算法、数据访问和批处理方式；
使用标准库或成熟库中已由 C、C++、Rust 等实现的向量化操作；
对 CPU 热点采用进程并行，评估序列化成本；
在依赖兼容且共享状态正确时评估 Python 3.14 自由线程构建；
最后才考虑编写原生扩展或更换实现，并承担构建、安全和跨平台维护成本。

不要假设“用 NumPy”“去掉 GIL”或“改成异步”必然更快。数据规模太小时，转换与调度开销可能占主导；I/O 系统受限时，提高 CPU 并行度也没有帮助。

8. 构建 wheel 与源码发行包

在包含 pyproject.toml 的项目根目录安装构建前端并构建：

1
2


python -m pip install --group build
python -m build

通常会在 dist/ 生成：

wheel（.whl）：构建好的安装发行格式，安装时通常不必再执行项目构建；
source distribution（sdist，通常是 .tar.gz）：包含可用于构建的源代码发行包。

构建应从干净版本控制检出执行，避免把本地未跟踪文件、旧生成物或凭据意外打包。实际包含哪些文件受构建后端配置影响，必须查看产物内容而不是猜测。

验证闭环：

1
2
3
4
5


python -m build
python -m venv .verify-venv
.\.verify-venv\Scripts\python.exe -m pip install dist\temperature_service_example-0.1.0-py3-none-any.whl
.\.verify-venv\Scripts\python.exe -c "import temperature_service; print(temperature_service.__file__)"
.\.verify-venv\Scripts\temperature-service.exe

wheel 文件名由规范化发行名、版本、Python/ABI/平台标签决定，不能在自动化中永久硬编码示例文件名。真实脚本应先列出或由构建元数据确定唯一产物，并在发现零个或多个候选时失败。

9. 发布库与部署应用是两件事

发布库的目标是让其他项目安装并解析依赖：

提供稳定公共 API、版本和兼容范围；
构建 wheel 与 sdist；
在干净环境测试产物；
发布到 PyPI 或内部索引；
不把开发依赖和本地秘密写入元数据。

部署应用的目标是复现一套完整运行环境：

锁定经测试的直接与传递依赖；
固定 Python 特性版本、操作系统和必要原生库；
提供配置、秘密注入、健康检查和回滚；
将同一构建产物逐级提升到测试和生产；
记录产物与源提交、构建过程的关联。

库倾向声明兼容范围，应用倾向锁定具体解析结果。把两者混在一起，要么让库依赖过度严格，要么让生产环境不可复现。

10. 安全发布

PyPA 对受支持 CI/CD 平台推荐使用 PyPI Trusted Publishing，通过短期身份联合发布，避免长期 API Token。具体平台配置应以 PyPI 当前官方文档为准。

无论采用何种发布方式，都应：

保护包索引账户并启用多因素认证；
把发布权限限制到专用环境和受保护分支/标签；
先验证发行名、版本和产物内容；
不在日志中输出令牌；
不从拉取请求中的不受信任代码直接触发带凭据发布；
发布已经测试过的产物，不在发布步骤重新构建另一份。

手工发布可使用 Twine，但不要使用已弃用且不安全的 python setup.py upload。所有直接执行 setup.py 的命令都已弃用；现代构建应通过 PEP 517/518 兼容前端调用声明的构建后端。

11. 部署后的性能闭环

实验室结果不等于生产结果。上线后至少观察：

请求量、延迟分位数和错误率；
CPU、内存、文件描述符、线程和任务队列；
外部依赖调用的耗时与失败；
缓存命中、队列积压和限流；
版本、配置和部署批次。

优化发布应小步进行，并保留快速回滚路径。一次只改变关键变量，比较同一负载条件下的指标；如果业务流量不可控，使用灰度、对照组或可重复回放降低误判。

性能退化要转化为自动化保护：为关键算法建立可重复基准，为请求链路设置服务级目标，为资源增长设置观测与告警。但基准阈值要容忍共享 CI 机器的合理噪声，避免把偶发抖动当回归。

12. 系列总结

这十篇文章形成了一条完整路径：

确认 CPython 3.14 解释器与隔离环境；
用名称绑定和对象模型理解基础语法；
按语义选择容器并管理可变性；
用函数、迭代器和上下文协议构建抽象；
用类、数据类与组合表达领域模型；
建立异常、资源、模块、配置和日志边界；
用类型标注增强静态契约；
按 CPU/I/O 特性选择线程、进程或 asyncio；
用测试、pyproject.toml 和 CI 保证可重建；
以测量驱动优化，并交付已验证的同一产物。

Python 的易学来自表达简洁，工程可靠性则来自边界清晰、事实可验证和失败路径完整。写出第一个脚本只需几分钟，把程序长期维护好，依靠的是这套持续闭环。

参考资料

Python 编程基础与工程实践（九）：测试、pyproject.toml 与工程化

Mon, 06 Jul 2026 10:00:00 +0800

能运行的脚本与可维护的项目之间，差的不只是目录数量。可靠项目要让新环境可以重建，让测试证明关键行为，让构建产物来自干净源码，并让本地与 CI 执行同一组命令。

本文以 Python 3.14 为基线，使用 PyPA 标准定义 pyproject.toml，以 pytest 展示测试方法。具体工具可以替换，但项目边界、依赖语义和验证闭环应保持稳定。

1. 从一个可安装项目开始

推荐的基础结构：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


temperature-service/
├── README.md
├── pyproject.toml
├── src/
│ └── temperature_service/
│ ├── __init__.py
│ ├── domain.py
│ └── cli.py
└── tests/
 ├── test_domain.py
 └── test_cli.py

src 布局把可导入包与仓库根目录分开。这样测试更容易针对“已安装的项目”运行，不会因为当前目录恰好在 sys.path 中而导入一份部署时不存在的代码。

包名和发行项目名不是同一个概念：发行名可包含连字符，例如 temperature-service；导入包通常使用下划线，例如 temperature_service。

2. `pyproject.toml` 的三层职责

一个可构建项目的最小配置可以是：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


[build-system]
requires = ["hatchling>=1.26"]
build-backend = "hatchling.build"

[project]
name = "temperature-service-example"
version = "0.1.0"
description = "A small temperature conversion service"
readme = "README.md"
requires-python = ">=3.14"
dependencies = []

[project.scripts]
temperature-service = "temperature_service.cli:main"

[tool.hatch.build.targets.wheel]
packages = ["src/temperature_service"]

三类表不能混为一谈：

[build-system] 告诉构建前端要安装哪个后端来生成发行包；
[project] 是会进入项目元数据的名称、版本、运行时依赖等标准字段；
[tool.<name>] 保存某个工具自己的配置，语义由该工具定义。

Hatchling、Setuptools、Flit 等构建后端都可以生成标准产物。这里选择 Hatchling 只是为了给出完整示例，不代表它是唯一标准。

当前示例的发行名规范化后是 temperature_service_example，与导入包 temperature_service 不同，因此显式告诉 Hatchling 从 src/temperature_service 构建 wheel。若省略这段后端专用配置，Hatchling 的默认名称推断无法找到要打包的目录。其他构建后端有各自的包发现规则，切换后端时要同步调整配置。

脚本入口指向的 src/temperature_service/cli.py 至少要提供对应函数：

1
2
3


def main() -> int:
 print("temperature service ready")
 return 0

3. 运行时依赖、可选依赖和开发依赖

运行项目必需的库放在 project.dependencies：

1
2
3
4


[project]
dependencies = [
 "httpx>=0.28,<1",
]

版本范围应表达已验证的兼容边界。库通常不应把所有传递依赖精确钉死，否则会妨碍宿主解析安全更新；应用为了可重复部署，则需要在单独的锁定结果中确定完整环境。

用户可选择的功能依赖使用 extras：

1
2


[project.optional-dependencies]
cli = ["rich>=15,<16"]

开发、测试和文档依赖不应成为安装库时的运行时依赖。标准化的依赖组可写为：

1
2
3
4
5
6
7


[dependency-groups]
test = [
 "pytest>=9,<10",
 "coverage>=7,<8",
 "mypy>=2,<3",
]
build = ["build>=1,<2"]

依赖组不会写入构建产物的项目依赖元数据。当前 pip 支持从项目根目录安装指定组：

1

python -m pip install --group test --group build

依赖组格式是标准，但不同工具的命令行能力和最低版本仍需核对。面向较旧工具链时，可继续使用 requirements 文件或工具自身的环境管理方案，并在项目文档中写明唯一入口。

4. 建立本地开发环境

从全新检出开始：

1
2
3
4


python -m venv .venv
.\.venv\Scripts\python.exe -m pip install --upgrade pip
.\.venv\Scripts\python.exe -m pip install --group test --group build
.\.venv\Scripts\python.exe -m pip install --editable .

macOS/Linux 把解释器路径换为 .venv/bin/python。可编辑安装让导入指向工作区源码，适合开发；发布验证还要安装并测试真正构建出来的 wheel。

不要把 .venv/、构建目录、缓存或覆盖率文件提交到 Git。应提交的是声明和锁定信息，使环境能够重建。

5. 第一个 pytest 测试

生产代码 src/temperature_service/domain.py：

1
2
3
4


def celsius_to_fahrenheit(celsius: float) -> float:
 if celsius < -273.15:
 raise ValueError("温度不能低于绝对零度")
 return celsius * 9 / 5 + 32

测试 tests/test_domain.py：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


import pytest

from temperature_service.domain import celsius_to_fahrenheit


@pytest.mark.parametrize(
 ("celsius", "expected"),
 [
 (0.0, 32.0),
 (100.0, 212.0),
 (-40.0, -40.0),
 ],
)
def test_celsius_to_fahrenheit(celsius: float, expected: float) -> None:
 assert celsius_to_fahrenheit(celsius) == pytest.approx(expected)


def test_rejects_temperature_below_absolute_zero() -> None:
 with pytest.raises(ValueError, match="绝对零度"):
 celsius_to_fahrenheit(-273.16)

脚本入口也要有最小行为测试。tests/test_cli.py：

1
2
3
4
5
6
7
8


import pytest

from temperature_service.cli import main


def test_main(capsys: pytest.CaptureFixture[str]) -> None:
 assert main() == 0
 assert capsys.readouterr().out == "temperature service ready\n"

运行：

1

python -m pytest

测试名称应表达行为和条件，不要只写 test_1。浮点计算使用 pytest.approx() 表达容差语义，而不是对所有浮点数强行精确比较。

6. Fixture 管理准备与清理

Fixture 适合创建每个测试所需的上下文：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


from collections.abc import Iterator
from pathlib import Path

import pytest


@pytest.fixture
def config_file(tmp_path: Path) -> Iterator[Path]:
 path = tmp_path / "config.toml"
 path.write_text('endpoint = "http://localhost"', encoding="utf-8")
 yield path

tmp_path 为测试提供独立临时目录。yield 后可以写额外清理，但由 tmp_path 管理的目录通常无需手工删除。

Fixture 应按真实生命周期选择作用域。把可变数据库连接、缓存或容器盲目设为 session 级，可能让测试相互污染；每个测试都重建昂贵环境又会拖慢套件。优化前先确认隔离要求和耗时来源。

7. 测试替身与 patch 的边界

最稳定的测试替身来自显式依赖：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


from typing import Protocol


class Clock(Protocol):
 def now(self) -> float: ...


class ExpirationService:
 def __init__(self, clock: Clock) -> None:
 self._clock = clock

测试可传入固定时钟，而不必修改全局时间函数。

确实需要修改环境变量或第三方调用时，pytest 的 monkeypatch 会在测试结束后恢复。假设 config.py 提供 load_settings，从环境变量读取超时设置：

1
2
3
4
5
6
7
8
9


import pytest

from temperature_service.config import load_settings


def test_reads_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
 monkeypatch.setenv("APP_TIMEOUT_SECONDS", "3")
 settings = load_settings()
 assert settings.timeout_seconds == 3.0

Patch 应作用于“被测模块实际查找的名称”，而不是机械修改原始定义位置。如果模块写了 from api import send，就 patch 该模块中的 send 引用。过多 patch 往往说明依赖隐藏在全局状态中，应优先改善设计。

8. 单元测试、集成测试与端到端测试

不同层级回答不同问题：

单元测试：一个函数或对象的规则是否正确；
集成测试：数据库、文件格式、消息系统或 HTTP 适配是否真正兼容；
端到端测试：从外部入口到关键结果的主链路是否可用。

Mock 成功只能证明“代码按模拟器设定运行”，不能证明真实数据库方言、网络超时或序列化格式正确。关键适配器要有集成测试，并在可控环境中验证真实依赖。

测试还应覆盖失败路径：非法输入、部分成功、超时、重试后重复副作用、取消以及清理失败。只覆盖顺利路径的高覆盖率仍可能给出虚假信心。

9. 覆盖率是发现盲区，不是质量分数

使用 coverage.py 记录分支覆盖：

1
2


python -m coverage run --branch -m pytest
python -m coverage report --show-missing

配置可以放在 pyproject.toml：

1
2
3
4
5
6
7


[tool.coverage.run]
branch = true
source = ["temperature_service"]

[tool.coverage.report]
show_missing = true
fail_under = 85

阈值应防止明显倒退，而不是鼓励没有断言价值的测试。覆盖过的代码仍可能断言错误结果；未覆盖的异常分支也可能正是生产风险最高的部分。

10. 统一工具入口

pytest 的稳定 TOML 配置形式是：

1
2
3


[tool.pytest.ini_options]
addopts = "-ra --strict-markers"
testpaths = ["tests"]

开发机和 CI 应运行相同命令：

1
2
3
4
5


python -m pytest
python -m mypy src tests
python -m coverage run --branch -m pytest
python -m coverage report --show-missing
python -m build

构建后还应在新虚拟环境安装 dist/ 中生成的 wheel，再运行至少一组导入和命令行冒烟测试。这能发现包数据遗漏、入口点错误和“只有可编辑安装能工作”的问题。

CI 至少固定：

支持的 Python 版本和操作系统矩阵；
安装依赖的声明或锁定输入；
测试、类型检查和构建命令；
缓存键中的 Python 与依赖文件版本；
产物来源的提交和构建日志。

不要因为依赖缓存命中就跳过依赖解析与环境验证，也不要让发布任务重新构建一份未经测试的不同产物。

11. 依赖锁定的准确边界

project.dependencies 表达项目运行所需的抽象范围，锁文件表达某些目标环境中解析出的具体版本，两者职责不同。

Python 生态已经标准化 pylock.toml（PEP 751）格式，但具体锁定、同步命令以及工具支持范围仍需查阅所选工具文档。项目可以使用标准锁文件，也可能因既有工具链保留专用锁文件；关键要求是：

锁文件由声明生成，不手工拼凑传递依赖；
应用部署使用受控、可重现的具体集合；
库发布保留合理兼容范围，不把开发环境全部精确版本强加给使用者；
自动化更新后重新执行测试和安全审查；
锁定不等于安全，仍需处理撤回版本、漏洞和包索引信任。

12. 小结

src 布局让测试和构建更接近真实安装结果。
pyproject.toml 分别承载构建系统、项目元数据和工具配置，三者语义不同。
运行时依赖、extras、开发依赖组和锁定结果解决不同问题。
pytest 的参数化、Fixture 和 monkeypatch 应服务于行为验证与隔离，而不是堆砌技巧。
覆盖率只能暴露未执行区域，不能证明断言和需求正确。
CI 应测试一次、构建一次，并发布那份已经验证的产物。

最后一篇将把项目带入性能分析和交付：如何先测量、再优化，并正确构建 wheel、部署应用或发布库。

参考资料

Python 编程基础与工程实践（八）：线程、进程、asyncio 与 GIL

Sat, 04 Jul 2026 10:00:00 +0800

并发问题最容易被一句“Python 有 GIL”讲坏：有人因此认为线程毫无用处，也有人误以为 GIL 会自动保证数据安全。Python 3.14 又让情况多了一层——自由线程构建已经获得官方支持，但仍不是默认构建。

本文以 CPython 3.14 为基线，先按任务性质选择工具，再解释线程、进程、asyncio、取消和 GIL 的准确边界。

1. 并发、并行和异步不是同义词

并发（Concurrency）：多个任务的生命周期重叠，可以交替推进；
并行（Parallelism）：多个任务在同一时刻由不同计算资源执行；
异步（Asynchrony）：调用方发起操作后不必阻塞等待，以事件或可等待对象继续协调。

选择方案先看瓶颈：

任务	常见首选	原因
阻塞式文件、网络、设备 I/O	`threading` / `ThreadPoolExecutor`	能复用同步库，等待期间可推进其他线程
高并发异步网络 I/O	`asyncio`	单线程事件循环可管理大量协作式任务
纯 Python CPU 密集计算	`multiprocessing` / `ProcessPoolExecutor`	默认 CPython 中绕开进程内 GIL，利用多核
可隔离、可序列化的 CPU 任务	`InterpreterPoolExecutor`	每个工作线程使用独立解释器和独立 GIL，可在单进程内利用多核
支持自由线程的 CPU 工作负载	自由线程 CPython + `threading`，经实测决定	可并行执行 Python 代码，但生态与同步设计需验证

这只是起点。数据复制成本、第三方库是否释放 GIL、部署平台和故障隔离也会改变结论，最终要用真实工作负载测量。

2. 默认 CPython 的 GIL 到底保证什么

全局解释器锁（Global Interpreter Lock，GIL）在默认 CPython 构建中，通常只允许一个线程在同一时刻执行 Python 字节码并操作 Python 对象。线程在阻塞 I/O 时会释放 GIL，部分 C 扩展也会在长时间本地计算时主动释放它。

GIL 不等于：

整个 Python 语句都是原子的；
多步业务操作天然线程安全；
容器复合操作不会竞态；
内存可见性和事务一致性已经得到业务层保证。

下面的“先检查再写入”由多个步骤组成：

1
2


if key not in cache:
 cache[key] = load_value(key)

两个线程可能都发现键不存在，然后重复加载并覆盖。正确方案取决于语义：可以用锁保护复合不变量，也可以使用允许重复计算但结果幂等的设计。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


from threading import Lock


cache: dict[str, str] = {}
cache_lock = Lock()


def load_value(key: str) -> str:
 return key.upper()


def get_or_load(key: str) -> str:
 with cache_lock:
 if key not in cache:
 cache[key] = load_value(key)
 return cache[key]

这个版本在锁内执行加载，能避免重复加载，却也让慢 I/O 阻塞其他键。生产代码可能使用每键锁、Future 占位或锁外加载后再合并，必须围绕业务不变量权衡。

3. Python 3.14 的自由线程构建

CPython 3.13 开始提供可禁用 GIL 的自由线程构建；Python 3.14 根据 PEP 779 进入“官方支持但可选”的阶段。它并没有取代默认构建，也不意味着所有扩展和程序自动获得线性加速。

可以检查当前运行时：

1
2
3
4
5
6
7
8


import sys
import sysconfig


supports_free_threading = sysconfig.get_config_var("Py_GIL_DISABLED") == 1
gil_enabled = sys._is_gil_enabled()

print(supports_free_threading, gil_enabled)

sys._is_gil_enabled() 在 Python 3.14 可报告当前进程是否启用了 GIL。自由线程构建仍可在运行时启用 GIL；导入未声明兼容自由线程的 C 扩展时，也可能自动重新启用 GIL 并给出警告。

自由线程不取消同步需求，恰恰会让真实并行下的数据竞争更容易暴露。迁移前要检查：

第三方二进制扩展是否提供兼容构建；
共享可变状态是否有明确所有权或锁；
代码是否依赖“看起来原子”的 CPython 偶然行为；
单线程性能、内存开销和扩展兼容性是否可接受；
基准是否覆盖真实请求、数据规模和硬件。

4. 线程：适合阻塞 I/O 和同步库

高层接口 ThreadPoolExecutor 比手工管理线程更适合一批独立任务：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


from concurrent.futures import ThreadPoolExecutor, as_completed
from urllib.request import urlopen


def fetch_length(url: str) -> tuple[str, int]:
 with urlopen(url, timeout=5) as response:
 return url, len(response.read())


urls = [
 "https://www.python.org/",
 "https://docs.python.org/3/",
]

with ThreadPoolExecutor(max_workers=4) as executor:
 futures = [executor.submit(fetch_length, url) for url in urls]
 for future in as_completed(futures):
 try:
 url, length = future.result()
 except OSError as error:
 print(f"请求失败：{error}")
 else:
 print(url, length)

注意边界：

future.result() 会重新抛出工作线程异常；
超时要传给实际 I/O API，不能只给等待 Future 的调用加超时；
线程池大小不是越大越好，受远端限流、连接数、内存和调度影响；
关闭执行器默认会等待任务结束，进程不会靠“忘记引用”可靠退出。

共享数据使用 Lock、RLock、Condition、Semaphore、Event 或线程安全队列协调。优先通过队列传递数据、缩小共享状态，而不是给每个字段随手加锁。

5. 进程：隔离地址空间并利用多核

ProcessPoolExecutor 把可序列化任务提交给子进程：

 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


from concurrent.futures import ProcessPoolExecutor


def count_primes(limit: int) -> int:
 def is_prime(value: int) -> bool:
 if value < 2:
 return False
 divisor = 2
 while divisor * divisor <= value:
 if value % divisor == 0:
 return False
 divisor += 1
 return True

 return sum(1 for value in range(limit) if is_prime(value))


def main() -> None:
 limits = [50_000, 55_000, 60_000]
 with ProcessPoolExecutor() as executor:
 print(list(executor.map(count_primes, limits)))


if __name__ == "__main__":
 main()

入口保护是跨平台进程代码的必要习惯。提交的函数、参数和返回值通常需要可 pickle；REPL 中定义的局部函数、lambda、打开的连接和锁通常不适合直接传递。

Python 3.14 之后，fork 不再是任何平台的默认启动方式。支持通过 Unix 管道传递文件描述符的 POSIX 平台（如 Linux）默认使用 forkserver，macOS 和 Windows 默认使用 spawn。不要假设所有系统都使用同一种方式，库也不应擅自全局设置启动方式。确需指定时，由应用入口通过上下文显式选择，并验证第三方库兼容性。

进程有序列化、启动和数据复制成本。很小的任务可能比单进程更慢；把工作分成足够大的批次，并避免在进程间来回搬运巨量对象。

6. Python 3.14 的子解释器执行器

Python 3.14 新增 InterpreterPoolExecutor。它是 ThreadPoolExecutor 的子类，但每个工作线程运行在独立解释器中；每个解释器拥有独立 GIL，因此默认构建也能让纯 Python 任务在不同 CPU 核上并行：

1
2
3
4
5
6
7
8
9


from concurrent.futures import InterpreterPoolExecutor


def square(value: int) -> int:
 return value * value


with InterpreterPoolExecutor() as executor:
 print(list(executor.map(square, range(5))))

隔离是它的核心边界：不同解释器拥有各自的模块、sys、内置对象和运行时状态，不能直接共享普通可变对象。执行器会使用 pickle 传递初始化器、任务参数和返回值，因此函数必须可导入、数据必须可序列化，传输成本也不会消失。

与进程池相比，子解释器仍处于同一操作系统进程，故障隔离和扩展兼容性不同；与自由线程相比，它通过隔离减少共享状态，而不是让多个线程共同操作同一套对象。它是 Python 3.14 值得评估的新选择，不是对进程池或自由线程的全面替代。

7. `asyncio`：协作式并发

协程遇到 await 才把控制权交回事件循环：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


import asyncio


async def worker(name: str, delay: float) -> str:
 await asyncio.sleep(delay)
 return f"{name} done"


async def main() -> None:
 async with asyncio.TaskGroup() as group:
 first = group.create_task(worker("A", 0.2))
 second = group.create_task(worker("B", 0.1))

 print(first.result(), second.result())


if __name__ == "__main__":
 asyncio.run(main())

TaskGroup 提供结构化并发：离开上下文前等待所有任务；某个任务以普通异常失败时，会取消其余任务，并在清理后以异常组传播失败。它比创建一批无人持有、无人等待的后台任务更容易管理生命周期。

async 函数调用只创建协程对象，不会自动执行：

1

coroutine = worker("A", 1.0)

需要 await coroutine、创建 Task，或由 asyncio.run() 驱动顶层协程。

8. 不要阻塞事件循环

下面的同步休眠会阻塞整个事件循环线程：

1
2
3
4


# 错误示例
async def bad() -> None:
 import time
 time.sleep(1)

异步等待应使用：

1
2


async def good() -> None:
 await asyncio.sleep(1)

无法替换的短期阻塞 I/O 可以交给线程：

1
2
3
4
5
6


import asyncio
from pathlib import Path


async def read_text(path: Path) -> str:
 return await asyncio.to_thread(path.read_text, encoding="utf-8")

to_thread() 主要用于不会长时间占用 GIL 的阻塞调用。默认 GIL 构建下，把纯 Python CPU 密集函数扔给线程通常不会获得多核并行。

9. 超时、取消和清理

1
2
3
4
5
6


import asyncio


async def load_with_timeout() -> bytes:
 async with asyncio.timeout(2.0):
 return await load_bytes()

这里的 load_bytes() 代表项目提供的异步 I/O 函数；超时必须包住真正的等待操作。

超时通过取消当前任务实现。协程应使用 try/finally 释放资源，并在捕获 asyncio.CancelledError 后完成必要清理再重新抛出。这里的 acquire() 与 resource 代表项目中的异步资源获取与句柄操作：

1
2
3
4
5
6
7
8
9


async def consumer() -> None:
 resource = await acquire()
 try:
 await resource.run()
 except asyncio.CancelledError:
 await resource.stop()
 raise
 finally:
 await resource.close()

CancelledError 是 BaseException 的直接子类。结构化并发组件依赖取消工作；吞掉取消又不调用相应的取消状态处理，会造成任务组和超时行为异常。

超时也不等于底层操作一定已停止。线程中的阻塞函数不能被 Python 强行安全终止，远端请求也可能已经产生副作用。幂等性、底层超时和补偿策略仍需单独设计。

10. 背压与有界并发

一次创建百万个任务会消耗大量内存并压垮下游。使用有界队列或信号量限制在途任务：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


import asyncio
from collections.abc import Iterable


async def fetch_all(urls: Iterable[str], limit: int = 20) -> list[bytes]:
 semaphore = asyncio.Semaphore(limit)

 async def bounded_fetch(url: str) -> bytes:
 async with semaphore:
 return await fetch(url)

 async with asyncio.TaskGroup() as group:
 tasks = [group.create_task(bounded_fetch(url)) for url in urls]

 return [task.result() for task in tasks]

这里的 fetch() 代表异步 HTTP 客户端提供的请求函数。这个版本限制同时执行的 fetch 数量，但仍一次创建所有 Task。输入规模不受控时应进一步使用固定数量消费者和有界 asyncio.Queue，让生产者在队列满时等待，形成真正背压。

11. 如何做选择

可以按以下顺序判断：

先确认瓶颈是 CPU、I/O、锁竞争还是外部限流；
已有同步库且并发量适中，优先线程池；
整条调用链已有异步 API 且需要大量在途 I/O，考虑 asyncio；
默认 CPython 下的纯 Python CPU 密集任务，考虑进程池；
任务可序列化且适合解释器隔离时，评估 3.14 的 InterpreterPoolExecutor；
自由线程构建只有在依赖兼容、共享状态正确且基准受益时才采用；
无论哪种模型，都设置有界并发、超时、取消、错误聚合和关闭流程。

并发模型不是架构身份。一个服务可以在事件循环中管理网络连接，把阻塞调用交给线程，把大块 CPU 计算交给进程，但每跨一层都增加调度、序列化和故障处理成本。

12. 小结

GIL 限制默认 CPython 中 Python 字节码的线程并行，不保证复合业务操作线程安全。
Python 3.14 的自由线程构建已受支持但仍可选；扩展兼容和显式同步仍是前提。
线程适合同步阻塞 I/O，进程适合较粗粒度 CPU 任务，子解释器提供隔离的单进程多核方案，asyncio 适合协作式高并发 I/O。
Python 3.14 不再在任何平台默认使用 fork；Linux 等平台通常使用 forkserver，macOS 和 Windows 使用 spawn，跨平台代码不要依赖隐含默认值。
取消、超时、有界并发和资源关闭是正确性的组成部分，不是上线前再补的优化。

下一篇将把代码组织成可测试、可构建的项目，统一 pyproject.toml、依赖和 CI。

参考资料

Python 编程基础与工程实践（七）：类型标注与静态检查

Thu, 02 Jul 2026 10:00:00 +0800

Python 是动态类型语言，但动态类型不等于“没有类型”。每个运行时对象都有类型，只是名称不被永久绑定到某一种类型。类型标注在此基础上提供一套供静态分析器、编辑器和读者使用的契约语言。

本文以 Python 3.14 为基线，使用现代泛型语法，并特别说明 3.14 的注解延迟求值变化。目标不是把 Python 写成静态语言，而是在重要边界获得更早反馈。

1. 类型标注不负责运行时强制

1
2
3
4
5


def add(left: int, right: int) -> int:
 return left + right


print(add("a", "b")) # 运行时仍得到 'ab'

CPython 不会因为标注而自动拦截这个调用。类型检查器可以在运行前报告问题，IDE 可以提供补全和重构支持，读者也能看到函数契约，但运行时行为仍由代码决定。

类型标注的主要价值包括：

暴露错误的数据流和不可达分支；
记录公共 API 的输入输出；
支持安全重命名、补全和导航；
让模块之间的契约不必依赖口头约定。

它不能证明业务逻辑正确、输入已经校验、线程安全或网络调用一定成功。

2. 从函数边界开始标注

1
2
3
4
5
6
7


def normalize_name(name: str, *, fallback: str | None = None) -> str:
 cleaned = name.strip()
 if cleaned:
 return cleaned
 if fallback is None:
 raise ValueError("名称不能为空")
 return fallback

现代 Python 使用 | 表示联合类型，str | None 表示值可以是字符串或 None。容器直接使用内置泛型：

1
2
3
4


def average(values: list[float]) -> float:
 if not values:
 raise ValueError("values 不能为空")
 return sum(values) / len(values)

如果函数只需要遍历，不要无谓要求调用者提供列表：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from collections.abc import Iterable


def average(values: Iterable[float]) -> float:
 total = 0.0
 count = 0
 for value in values:
 total += value
 count += 1
 if count == 0:
 raise ValueError("values 不能为空")
 return total / count

选择最窄的能力接口，而不是最具体的实现类型。

3. `Any`、`object` 与 `Never`

Any 会选择性关闭静态检查：它既可赋给任意类型，也可接收任意类型。object 则表示“某个未知对象”，使用前必须收窄：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


from typing import Any


def unsafe(value: Any) -> str:
 return value.not_checked() # 类型检查器通常放行


def safe(value: object) -> str:
 if isinstance(value, str):
 return value.upper()
 return repr(value)

第三方无标注库、动态 JSON 边界等地方可能暂时需要 Any，但它应停留在边界，解析后尽快转成已知类型。

永不正常返回的函数可以标注 Never：

1
2
3
4
5


from typing import Never


def fail(message: str) -> Never:
 raise RuntimeError(message)

4. 类型收窄

类型检查器会理解常见运行时判断：

1
2
3
4
5
6


def length(value: str | bytes | None) -> int:
 if value is None:
 return 0
 if isinstance(value, str):
 return len(value)
 return len(value)

复杂检查可用 TypeIs 封装。它在真、假两个分支都能帮助收窄，且目标类型必须与输入类型兼容：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


from typing import TypeIs


def is_string(value: object) -> TypeIs[str]:
 return isinstance(value, str)


def format_value(value: str | int) -> str:
 if is_string(value):
 return value.upper()
 return f"{value:,}"

用户自定义收窄函数必须真实验证它声称的条件。错误的 TypeIs 或 TypeGuard 会欺骗类型检查器，形成比缺少标注更危险的假保证。

5. 现代泛型语法

Python 3.12 起可以直接在函数和类声明中定义类型参数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


def first[T](values: list[T]) -> T:
 if not values:
 raise ValueError("values 不能为空")
 return values[0]


class Box[T]:
 def __init__(self, value: T) -> None:
 self.value = value

 def get(self) -> T:
 return self.value

类型别名也有专用语法：

1
2


type DeviceId = str
type Pair[T] = tuple[T, T]

别名不会在运行时创建新的名义类型。如果要防止把两个底层都是字符串的标识混用，可以使用 NewType：

1
2
3
4
5


from typing import NewType


DeviceId = NewType("DeviceId", str)
UserId = NewType("UserId", str)

NewType 主要影响静态检查，运行时调用开销很小，也不会获得完整的新类行为。

6. `Protocol`：为鸭子类型补上静态契约

Python 运行时常按行为而不是继承树判断对象是否可用。Protocol 把这种结构化子类型写成静态契约：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from typing import Protocol


class Writer(Protocol):
 def write(self, message: str) -> None: ...


class ConsoleWriter:
 def write(self, message: str) -> None:
 print(message)


def publish(writer: Writer, message: str) -> None:
 writer.write(message)


publish(ConsoleWriter(), "done")

ConsoleWriter 无需显式继承 Writer，只要成员类型兼容即可。Protocol 适合依赖注入和第三方适配，但接口应保持小而稳定。

默认的 Protocol 不能用于 isinstance()。添加 @runtime_checkable 后只能在运行时检查属性是否存在，不会核对完整方法签名：

1
2
3
4
5
6


from typing import Protocol, runtime_checkable


@runtime_checkable
class Closable(Protocol):
 def close(self) -> None: ...

因此运行时检查不能替代真正的输入验证或静态分析。

7. `TypedDict` 与结构化字典

外部 JSON 常以字典进入程序。TypedDict 可以描述固定键结构：

1
2
3
4
5
6
7


from typing import NotRequired, TypedDict


class DevicePayload(TypedDict):
 device_id: str
 value: float
 unit: NotRequired[str]

它仍是普通字典，运行时不会自动验证网络输入：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


def parse_payload(raw: object) -> DevicePayload:
 if not isinstance(raw, dict):
 raise ValueError("payload 必须是对象")

 device_id = raw.get("device_id")
 value = raw.get("value")
 if not isinstance(device_id, str):
 raise ValueError("device_id 必须是字符串")
 if not isinstance(value, int | float) or isinstance(value, bool):
 raise ValueError("value 必须是数字")

 return {"device_id": device_id, "value": float(value)}

边界数据必须先校验，再告诉类型检查器它是什么。直接 cast(DevicePayload, raw) 只改变静态观点，不检查任何运行时内容。

8. 回调、装饰器与 `ParamSpec`

为了保留装饰器的调用签名，可以用参数规格变量：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


from collections.abc import Callable
from functools import wraps
from typing import ParamSpec, TypeVar


P = ParamSpec("P")
R = TypeVar("R")


def logged(func: Callable[P, R]) -> Callable[P, R]:
 @wraps(func)
 def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
 print(f"calling {func.__name__}")
 return func(*args, **kwargs)

 return wrapper

这里沿用兼容性良好的 ParamSpec/TypeVar 声明；现代类型参数语法同样支持参数规格，但是否采用要考虑项目最低 Python 版本和工具链支持。

9. Python 3.14 的注解延迟求值

Python 3.14 默认采用 PEP 649/749 的延迟求值语义：注解表达式通常在访问注解时才求值，而不是定义函数或类时立即求值。

1
2
3
4
5
6


def handle(item: Item) -> None:
 print(item)


class Item:
 pass

在默认 Python 3.14 语义下，定义 handle 时不要求 Item 已存在；访问求值后的注解时，Item 必须能够解析。使用 from __future__ import annotations 的模块仍采用字符串化语义，不能把两者混为一谈。

框架若需要读取注解，应使用 3.14 新增的 annotationlib.get_annotations()，并根据用途选择 VALUE、FORWARDREF 或 STRING 格式，而不是假设 __annotations__ 永远包含已求值对象或字符串。还要注意：求值注解表达式可能执行代码，不能把反射不受信任模块的注解当成安全解析。

普通业务代码只用注解给静态检查器看时，通常不需要直接操作这些反射 API。

10. 建立可持续的检查策略

类型检查器是外部工具，团队需要在项目中固定选择和配置。以 mypy 为例，可以在虚拟环境安装并运行：

1
2


python -m pip install mypy
python -m mypy src tests

配置可放入 pyproject.toml：

1
2
3
4


[tool.mypy]
python_version = "3.14"
strict = true
warn_unused_ignores = true

不同检查器在未完全规定的收窄、插件和诊断规则上可能不同。项目应选定一套工具与版本，在 CI 中执行同样命令；不要为了让告警消失而大量引入 Any、cast() 或无说明的忽略注释。

采用类型标注可以循序渐进：

先标注公共函数和模块边界；
对新代码启用较严格规则；
把无类型外部数据集中在适配层；
用测试验证运行时行为；
逐步减少 Any，而不是一次性追求百分之百覆盖。

11. 小结

Python 保持动态类型；类型标注默认不执行运行时校验。
object 要求先收窄，Any 会传播并削弱检查，应限制在边界。
现代泛型语法、Protocol 和 TypedDict 能表达常见工程契约。
cast() 只影响静态分析，不能验证 JSON 或其他外部输入。
Python 3.14 默认延迟求值注解，反射工具应使用 annotationlib 并考虑求值风险。
静态检查、运行时校验和自动化测试解决不同问题，缺一不可。

下一篇将讨论线程、进程和 asyncio，并准确解释 Python 3.14 中 GIL 与自由线程构建的边界。

参考资料

Python 编程基础与工程实践（六）：异常、资源与模块系统

Tue, 30 Jun 2026 10:00:00 +0800

可靠程序不是“从不出错”，而是能区分哪些错误可以恢复、哪些必须向上传播，并保证失败时资源仍被正确释放。与此同时，模块边界决定依赖方向，日志和配置决定程序能否被运维。

本文以 CPython 3.14 为基线，把异常、上下文管理、模块、包、导入、日志和配置组织成一套工程方法。

1. 异常是控制流，不是返回值替代品

Python 使用异常表示无法按契约完成操作：

1
2
3
4
5
6
7
8
9


def parse_port(raw: str) -> int:
 try:
 port = int(raw)
 except ValueError as error:
 raise ValueError(f"端口不是整数：{raw!r}") from error

 if not 1 <= port <= 65_535:
 raise ValueError(f"端口超出范围：{port}")
 return port

这里既保留原始异常，又补充业务上下文。raise ... from error 建立显式异常链，日志能同时展示转换失败的根因和更高层语义。

不要用异常处理正常且高频的分支，如果一个结果本来就可能缺失，返回 None 或明确的结果对象可能更合适；反过来，也不要用魔法值 -1 隐藏真正错误。

2. 精确捕获，保持异常边界

1
2
3
4


try:
 config = load_config(path)
except FileNotFoundError:
 config = default_config()

只捕获你能处理的异常。下面的写法会掩盖退出信号以外的几乎所有异常，包括大量本应暴露的程序错误：

1
2
3
4
5


# 反例
try:
 run_job()
except Exception:
 pass

except Exception 在应用最外层用于记录失败、转换协议响应或隔离单个任务时可以合理，但通常要记录完整堆栈并决定是否重新抛出。不要捕获 BaseException，除非你明确知道如何处理 KeyboardInterrupt、SystemExit 等控制异常。

try 语句的四部分职责不同：

1
2
3
4
5
6
7
8


try:
 value = parse_value(raw)
except ValueError as error:
 report(error)
else:
 persist(value)
finally:
 release_temporary_state()

except 处理匹配异常；
else 只在 try 正常完成时执行，能缩小被捕获代码范围；
finally 无论成功、异常或提前返回都会执行，适合清理；
finally 中不要随意 return，否则可能压制原异常或返回值。Python 3.14 会对从 finally 代码块跳出的 return、break 或 continue 发出 SyntaxWarning；这些写法在未来版本或其他实现中可以成为语法错误。

3. 自定义异常表达领域语义

1
2
3
4
5
6
7
8


class DeviceError(Exception):
 """设备操作失败的基类。"""


class DeviceOfflineError(DeviceError):
 def __init__(self, device_id: str) -> None:
 super().__init__(f"设备离线：{device_id}")
 self.device_id = device_id

调用方可以捕获稳定的领域异常，而不依赖底层串口、Socket 或驱动库的具体异常类型。转换时保留异常链：

1
2
3
4


try:
 transport.send(command)
except OSError as error:
 raise DeviceOfflineError(device_id) from error

异常类型应能帮助调用者决定处理策略。仅仅为了改一段消息而建立几十个没有语义差异的异常类，反而增加负担。

4. 多个并发错误：`ExceptionGroup`

并发任务可能同时失败。Python 3.11 引入 ExceptionGroup 和 except*，允许按类型拆分处理：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


errors = ExceptionGroup(
 "批处理失败",
 [ValueError("坏数据"), TimeoutError("超时")],
)

try:
 raise errors
except* ValueError as group:
 print(f"数据错误：{len(group.exceptions)}")
except* TimeoutError as group:
 print(f"超时错误：{len(group.exceptions)}")

except* 不是按顺序只选一个分支；一个异常组可被拆分后由多个分支处理。日常代码通常通过 asyncio.TaskGroup 等结构化并发 API 间接遇到它，不必手工把所有异常都包装成组。

5. 资源释放优先使用上下文管理器

文件、锁、事务和临时目录都有生命周期。相比手写 try/finally，with 更直接：

1
2
3
4
5
6


from pathlib import Path


path = Path("config.json")
with path.open("r", encoding="utf-8") as file:
 content = file.read()

多个资源可以写在同一个 with 中：

1
2
3


with source.open("rb") as input_file, target.open("wb") as output_file:
 while chunk := input_file.read(64 * 1024):
 output_file.write(chunk)

动态数量的资源使用 ExitStack：

1
2
3
4
5
6


from contextlib import ExitStack


with ExitStack() as stack:
 files = [stack.enter_context(path.open(encoding="utf-8")) for path in paths]
 contents = [file.read() for file in files]

资源所有权要明确：谁创建，谁关闭。函数若接收调用者提供的文件对象，通常不应擅自关闭它；函数自己打开的文件则应在返回前关闭。

6. 模块与包如何组织代码

一个 .py 文件通常是一个模块；包是可包含子模块的组织单元。推荐的小型项目结构：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


temperature-service/
├── pyproject.toml
├── src/
│ └── temperature_service/
│ ├── __init__.py
│ ├── domain.py
│ ├── config.py
│ ├── service.py
│ └── cli.py
└── tests/
 └── test_domain.py

src 布局能降低测试误用仓库根目录源码、而不是已安装包的风险。它不是语言强制要求，但适合可发布包和中大型项目。

导入模块会经历查找、创建模块对象和执行模块顶层代码。成功导入后通常会缓存在 sys.modules 中，因此同一进程里的普通重复导入不会每次重新执行模块。

1

from temperature_service.domain import Measurement

包内可使用显式相对导入：

1

from .domain import Measurement

应用入口和公共代码通常优先绝对导入，关系更清楚。采用 src 布局时，包不会仅因终端位于项目根目录就自动变得可导入；需要先把项目以普通或可编辑方式安装到当前环境。完成安装后，再从项目根目录使用 python -m temperature_service.cli，不要通过直接运行包内部文件来绕过导入模型。

7. `init.py` 与公共 API

常规包通常包含 __init__.py。没有它时也可能形成命名空间包，但那是为跨多个目录分发同一逻辑包等场景设计的，不应因为漏文件偶然触发。

__init__.py 可以重导出稳定接口：

1
2
3


from .domain import Measurement

__all__ = ["Measurement"]

保持包初始化轻量。不要在导入时连接数据库、启动线程或读取远程配置；导入副作用会影响测试发现、命令行工具和子进程启动。

循环导入通常说明模块职责或依赖方向不清晰。可选修法包括：

把共享抽象移到更底层模块；
在应用装配层连接对象；
仅为类型检查的导入放进 if TYPE_CHECKING:；
必要时在函数内部延迟导入，但不要用它长期掩盖结构问题。

8. 配置：把来源与领域模型分开

环境变量适合部署时注入少量字符串配置，但读取后必须解析和验证：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


from dataclasses import dataclass
import os


@dataclass(frozen=True, slots=True)
class Settings:
 endpoint: str
 timeout_seconds: float


def load_settings() -> Settings:
 endpoint = os.environ.get("APP_ENDPOINT", "http://localhost:8080")
 raw_timeout = os.environ.get("APP_TIMEOUT_SECONDS", "5")

 try:
 timeout = float(raw_timeout)
 except ValueError as error:
 raise ValueError("APP_TIMEOUT_SECONDS 必须是数字") from error

 if timeout <= 0:
 raise ValueError("APP_TIMEOUT_SECONDS 必须大于零")

 return Settings(endpoint=endpoint, timeout_seconds=timeout)

不要在业务模块导入时到处读取环境变量；集中加载后传入依赖，测试更容易控制。密钥不应写入源码、默认配置或日志。复杂配置格式要选择明确的解析器，并在边界转换为有约束的领域对象。

9. 日志：记录事件，不拼接秘密

标准库 logging 支持级别、处理器和格式化：

1
2
3
4
5
6
7
8


import logging


logger = logging.getLogger(__name__)


def process(device_id: str) -> None:
 logger.info("processing device_id=%s", device_id)

库代码只获取命名 logger，不应擅自调用 basicConfig() 改变宿主应用配置。应用入口统一配置：

1
2
3
4
5
6
7
8


import logging


def configure_logging() -> None:
 logging.basicConfig(
 level=logging.INFO,
 format="%(asctime)s %(levelname)s %(name)s %(message)s",
 )

使用参数化日志而不是先拼 f-string，能让未启用的日志级别避免不必要的字符串格式化，也便于日志系统保留结构。记录异常堆栈可使用：

1
2
3
4
5


try:
 run_job()
except DeviceError:
 logger.exception("job failed")
 raise

不要记录密码、访问令牌、完整连接串或不必要的个人数据。日志级别也不是越高越好：可恢复的预期输入错误不一定需要 ERROR，无法继续的系统故障也不应只记 DEBUG。

10. 一个清晰的应用边界

 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


import logging

from .config import load_settings
from .service import ApplicationService


logger = logging.getLogger(__name__)


def main() -> int:
 try:
 settings = load_settings()
 service = ApplicationService(settings)
 service.run()
 except ValueError as error:
 logger.error("invalid configuration: %s", error)
 return 2
 except OSError:
 logger.exception("infrastructure failure")
 return 1
 return 0


if __name__ == "__main__":
 raise SystemExit(main())

这个入口把配置解析、对象装配、异常到退出码的转换放在边界，领域模块不需要知道命令行退出码或日志配置。

11. 小结

只捕获能够处理的异常，转换层级时使用 raise ... from ... 保留根因。
清理放进上下文管理器或 finally，并明确资源所有权。
模块导入会执行顶层代码；包初始化应轻量，避免连接外部资源等副作用。
集中加载、解析和校验配置，再把设置对象传入业务层。
库获取 logger，应用配置日志；任何层都不应泄露秘密。

下一篇将为这些模块和接口补上现代类型标注，解释静态检查能证明什么、又不能证明什么。

参考资料

Python 编程基础与工程实践（五）：对象模型、类与 dataclass

Sun, 28 Jun 2026 10:00:00 +0800

Python 的类语法很短，但它背后的模型并不简单：属性可以来自实例、类、基类或描述符；特殊方法把对象接入运算符和容器协议；dataclass 能生成样板代码，却不能替代领域约束。

本文以 CPython 3.14 为基线，解释类、继承、组合、属性、特殊方法和数据类，并给出适合工程代码的边界。

1. 类对象与实例对象

类语句执行后会创建类对象，调用类对象通常会创建实例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class Sensor:
 unit = "°C"

 def __init__(self, name: str, value: float) -> None:
 self.name = name
 self.value = value

 def display(self) -> str:
 return f"{self.name}: {self.value:.1f}{self.unit}"


sensor = Sensor("chamber", 24.5)
print(sensor.display())

unit 是类属性，默认由所有实例共享；name 和 value 是实例属性。方法通过描述符绑定成为“绑定方法”，调用 sensor.display() 时，实例会作为第一个参数 self 传入。

self 只是约定名称，不是关键字，但偏离约定会降低可读性。

2. 类属性与实例属性不要混淆

可变类属性会被所有未覆盖它的实例共享：

1
2
3
4
5
6
7
8


class BadRegistry:
 items: list[str] = []


first = BadRegistry()
second = BadRegistry()
first.items.append("A")
assert second.items == ["A"]

如果每个实例需要独立列表，应在 __init__ 中创建：

1
2
3


class Registry:
 def __init__(self) -> None:
 self.items: list[str] = []

属性查找会沿实例、类和方法解析顺序等路径进行，但数据描述符等机制会影响具体优先级。工程中不必靠记忆所有细节写“聪明代码”；避免同名属性在多个层级承担不同含义，接口会更稳健。

3. 实例方法、类方法与静态方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class Temperature:
 def __init__(self, celsius: float) -> None:
 self.celsius = celsius

 @classmethod
 def from_fahrenheit(cls, value: float) -> "Temperature":
 return cls((value - 32) * 5 / 9)

 @staticmethod
 def is_valid(value: float) -> bool:
 return value >= -273.15

实例方法接收 self，操作具体对象；
类方法接收 cls，常用于替代构造函数，并能正确构造子类；
静态方法不接收隐式实例或类，适合与类型概念紧密相关、但不依赖状态的函数。

如果一个函数与类的概念没有内聚关系，把它保留为模块级函数通常更清楚。

4. 封装靠接口与约定

Python 没有与某些静态语言完全相同的私有字段机制：

_name 表示“非公开实现细节”的约定；
__name 会触发名称改写，主要用于避免子类意外覆盖，并非安全边界；
调用者在运行时仍可通过反射或改写后的名称访问对象。

封装的价值不在于阻止恶意访问，而在于给维护者稳定的公共接口。使用属性可以在保持访问语法的同时加入约束：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class Progress:
 def __init__(self, value: float = 0.0) -> None:
 self.value = value

 @property
 def value(self) -> float:
 return self._value

 @value.setter
 def value(self, new_value: float) -> None:
 if not 0 <= new_value <= 100:
 raise ValueError("进度必须位于 0 到 100")
 self._value = new_value

不要把昂贵 I/O 或不可预期副作用藏进普通属性读取；调用者通常预期属性访问轻量且稳定，此时显式方法更合适。

5. 特殊方法把对象接入语言协议

双下划线包围的特殊方法由语言协议调用。一个不可变的二维向量：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


from dataclasses import dataclass
from math import hypot


@dataclass(frozen=True, slots=True)
class Vector:
 x: float
 y: float

 def __add__(self, other: object) -> "Vector":
 if not isinstance(other, Vector):
 return NotImplemented
 return Vector(self.x + other.x, self.y + other.y)

 def __abs__(self) -> float:
 return hypot(self.x, self.y)

返回 NotImplemented 不是抛异常，它让 Python 尝试右操作数的反向运算，若双方都不支持再抛 TypeError。不要在不支持时返回 False 或随意转换类型。

常见协议包括：

__repr__：面向开发者的表示；
__str__：面向用户的文本；
__eq__、__hash__：相等性与哈希；
__len__、__iter__、__contains__：容器行为；
__enter__、__exit__：上下文管理；
__call__：可调用对象。

特殊方法通常由类型而不是实例属性解析，因此不应试图给单个实例临时挂一个 __len__ 来改变 len(obj)。

6. `dataclass` 生成什么

数据类根据类型标注字段生成 __init__、__repr__、比较方法等样板代码：

1
2
3
4
5
6
7
8


from dataclasses import dataclass, field


@dataclass(slots=True)
class Batch:
 batch_id: str
 values: list[float] = field(default_factory=list)
 enabled: bool = True

可变默认值使用 default_factory，确保每个实例获得新列表。直接写 values: list[float] = [] 这类不可哈希的可变默认值会被 dataclass 拒绝，但仍应理解 default_factory 创建的每个对象归单个实例所有。

常用选项：

frozen=True：阻止普通字段赋值，适合值对象；它不是深度不可变，字段指向的可变对象仍可改变；
slots=True：生成槽位，通常减少实例字典开销，并限制随意增加属性；不要在未测量时承诺固定节省比例；
order=True：生成顺序比较，前提是字段顺序确实代表业务排序；
kw_only=True：让字段只能按关键字传入，降低构造函数参数错位风险。

派生字段和跨字段校验放到 __post_init__()：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


from dataclasses import dataclass


@dataclass(frozen=True, slots=True)
class Range:
 lower: float
 upper: float

 def __post_init__(self) -> None:
 if self.lower > self.upper:
 raise ValueError("lower 不能大于 upper")

数据类不负责自动验证类型标注，也不会自动把嵌套字典转为领域对象。

7. 相等性、哈希与可变性必须一致

对象作为字典键或集合元素时，其哈希值必须在驻留期间稳定，并满足“相等对象具有相同哈希值”。

dataclass 会根据 eq、frozen 和 unsafe_hash 决定是否生成 __hash__。不要为了塞进集合而盲目设置 unsafe_hash=True：若参与比较的字段可变，修改后对象可能再也无法从集合中正确找到。

适合作为值对象的类型通常具有：

由全部有效字段定义的相等性；
构造后不可变；
稳定哈希；
创建新值而非原地修改的操作。

8. 继承、MRO 与 `super()`

继承表达“是一个”关系：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Device:
 def __init__(self, device_id: str) -> None:
 self.device_id = device_id

 def start(self) -> None:
 print(f"start {self.device_id}")


class Camera(Device):
 def __init__(self, device_id: str, exposure_ms: float) -> None:
 super().__init__(device_id)
 self.exposure_ms = exposure_ms

super() 不简单等于“调用父类”，而是按当前类的方法解析顺序（MRO）继续查找。多重继承中，参与协作的方法应使用兼容签名并继续调用 super()，否则调用链可能断裂。

可以检查解析顺序：

1

print(Camera.mro())

多重继承适合小型、正交的 mixin；复杂业务复用通常优先组合。

9. 组合往往比继承更稳定

组合表达“拥有一个”关系，并把依赖显式放入构造函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


from dataclasses import dataclass
from typing import Protocol


class Writer(Protocol):
 def write(self, message: str) -> None: ...


@dataclass(slots=True)
class AlarmService:
 writer: Writer

 def raise_alarm(self, message: str) -> None:
 self.writer.write(f"ALARM: {message}")

AlarmService 不关心写入器的具体继承树，只依赖所需行为。测试时可以传入内存实现，生产中传入日志、消息队列或数据库适配器。这里的 Protocol 会在类型系统一篇深入解释。

10. 一个完整的小型领域模型

 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


from dataclasses import dataclass, field
from datetime import datetime, timezone


@dataclass(frozen=True, slots=True)
class Measurement:
 name: str
 value: float
 unit: str
 captured_at: datetime = field(
 default_factory=lambda: datetime.now(timezone.utc)
 )

 def __post_init__(self) -> None:
 if not self.name.strip():
 raise ValueError("name 不能为空")
 if self.captured_at.tzinfo is None:
 raise ValueError("captured_at 必须包含时区")

 def converted(self, factor: float, target_unit: str) -> "Measurement":
 return Measurement(
 name=self.name,
 value=self.value * factor,
 unit=target_unit,
 captured_at=self.captured_at,
 )

这个模型把有效性约束放在构造边界，用带时区时间避免含糊的本地时间，并通过创建新实例保持值对象不变。frozen=True 依旧不是安全边界，但它清晰表达了设计意图。

11. 小结

类属性由实例共享，可变状态通常应在 __init__ 或 default_factory 中创建。
属性适合轻量约束；昂贵操作和副作用使用显式方法。
特殊方法是语言协议的一部分，不支持二元运算时应返回 NotImplemented。
dataclass 减少样板代码，但不会自动提供类型验证、深度不可变或正确领域模型。
super() 沿 MRO 协作；复用业务能力时通常优先组合与窄接口。

下一篇将讨论异常边界、资源释放、模块与包的组织，以及日志和配置如何进入工程结构。

参考资料

Python 编程基础与工程实践（四）：函数、装饰器与迭代协议

Fri, 26 Jun 2026 10:00:00 +0800

Python 的函数不只是“把几行代码包起来”。函数本身也是对象，可以被传递、返回和装饰；for、生成器和 with 看似不同，背后也都建立在明确的协议之上。

本文以 CPython 3.14 为基线，讲清参数模型、作用域、闭包、装饰器、迭代器、生成器和上下文管理器。理解这些机制后，很多“Python 魔法”会变成普通的方法调用。

1. 函数是对象

1
2
3
4
5
6
7


def add(left: int, right: int) -> int:
 """返回两个整数之和。"""
 return left + right


operation = add
print(operation(2, 3)) # 5

名称 add 绑定到一个函数对象，因此它可以像其他对象一样保存到容器、传给另一个函数或作为返回值。

类型标注不会自动阻止错误调用：

1

print(add("a", "b")) # 运行时得到 'ab'

标注主要服务于静态分析、编辑器和读者。真正的运行时约束仍来自函数体执行的操作；类型系统会在第七篇详细讨论。

2. Python 的参数模型

函数定义可以明确哪些参数只能按位置传入，哪些只能按关键字传入：

1
2
3
4
5
6
7
8
9


def connect(
 host: str,
 port: int = 5432,
 /,
 *,
 timeout: float = 5.0,
 use_tls: bool = True,
) -> str:
 return f"{host}:{port}, timeout={timeout}, tls={use_tls}"

/ 之前是仅限位置参数；
* 之后是仅限关键字参数；
中间区域可按位置或关键字传入。

调用方式：

1

connect("db.example.com", 5432, timeout=2.0)

仅限关键字参数能让布尔值和多个同类型参数更易读，也为以后添加可选参数留下空间。

可变参数收集额外实参：

1
2
3
4
5
6
7


def summarize(*values: float, precision: int = 2) -> str:
 average = sum(values) / len(values)
 return f"{average:.{precision}f}"


options = {"precision": 3}
print(summarize(1.0, 2.0, 3.0, **options))

*values 得到元组，**kwargs 得到字典。它们适合转发参数和开放扩展点，但不应代替清晰的接口；业务函数如果所有参数都藏在 **kwargs 里，类型检查和调用文档都会变差。

3. 传参是对象共享，不是按引用传变量

调用函数时，形参名称绑定到实参对象。函数可以修改传入的可变对象，但在函数内重新绑定形参不会改变调用者的名称：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


def append_item(items: list[int]) -> None:
 items.append(3)


def replace_list(items: list[int]) -> None:
 items = [99]


values = [1, 2]
append_item(values)
assert values == [1, 2, 3]

replace_list(values)
assert values == [1, 2, 3]

与其争论“值传递还是引用传递”，更准确的说法是：实参对象被绑定到新的局部名称。接口设计时还应明确函数是否会修改传入对象。

4. 作用域与闭包

名称查找常用 LEGB 概括：Local、Enclosing、Global、Builtins，即局部、外层函数、模块全局和内置作用域。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from collections.abc import Callable


def make_counter() -> Callable[[], int]:
 count = 0

 def increment() -> int:
 nonlocal count
 count += 1
 return count

 return increment

这里 increment() 闭包保留了外层的 count。nonlocal 表示重新绑定最近的外层函数作用域名称；global 则绑定模块全局名称。大量依赖可变全局状态会让测试和并发控制困难，通常应把状态封装到对象或显式依赖中。

闭包捕获的是名称，不是定义时的值。循环中创建函数要特别留意晚绑定：

1
2
3
4
5
6
7


# 错误示例：三个函数最终都读取同一个 i
bad = [lambda: i for i in range(3)]
assert [func() for func in bad] == [2, 2, 2]

# 默认参数在定义时求值，可用于冻结当前值
good = [lambda i=i: i for i in range(3)]
assert [func() for func in good] == [0, 1, 2]

这里利用默认参数是有意保存快照，与无意共享可变默认值是两种不同场景。

5. 高阶函数与装饰器

接收或返回函数的函数称为高阶函数：

1
2
3
4
5
6
7
8


from collections.abc import Callable


def apply_twice(operation: Callable[[int], int], value: int) -> int:
 return operation(operation(value))


assert apply_twice(lambda x: x + 1, 10) == 12

装饰器是在函数定义后替换绑定对象的语法糖：

1
2
3


@trace
def calculate() -> int:
 return 42

大致等价于：

1
2
3
4
5


def calculate() -> int:
 return 42


calculate = trace(calculate)

一个保留元数据的计时装饰器：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from collections.abc import Callable
from functools import wraps
from time import perf_counter
from typing import Any


def timed(func: Callable[..., Any]) -> Callable[..., Any]:
 @wraps(func)
 def wrapper(*args: Any, **kwargs: Any) -> Any:
 started = perf_counter()
 try:
 return func(*args, **kwargs)
 finally:
 elapsed = perf_counter() - started
 print(f"{func.__name__}: {elapsed:.6f}s")

 return wrapper

functools.wraps 会复制名称、文档等元数据，并通过 __wrapped__ 保留原函数链。更精确地保留参数类型需要 ParamSpec，将在类型系统一篇介绍。

装饰器在函数定义执行时应用，不是每次调用时重新创建。带参数的装饰器则是“返回装饰器的函数”，不要把它和被装饰函数的调用参数混在一起。

6. 可迭代对象与迭代器

for 的核心不是下标，而是迭代协议：

对目标调用 iter(obj) 获得迭代器；
反复调用 next(iterator)；
捕获 StopIteration 后正常结束。

1
2
3
4
5
6


values = [10, 20, 30]
iterator = iter(values)

print(next(iterator)) # 10
print(next(iterator)) # 20
print(next(iterator)) # 30

列表是可重复迭代的容器，每次 iter(values) 可产生新迭代器；迭代器通常是一次性的，并保存当前进度。

自定义倒计时迭代器：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class Countdown:
 def __init__(self, start: int) -> None:
 self.current = start

 def __iter__(self) -> "Countdown":
 return self

 def __next__(self) -> int:
 if self.current <= 0:
 raise StopIteration
 value = self.current
 self.current -= 1
 return value

不过大多数顺序生成任务使用生成器更简单。

7. 生成器：把状态机交给语言

函数体中出现 yield 时，调用它会返回生成器对象，而不是立即执行到结束：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from collections.abc import Iterator


def countdown(start: int) -> Iterator[int]:
 current = start
 while current > 0:
 yield current
 current -= 1


for value in countdown(3):
 print(value)

每次 next() 会从上次 yield 后继续，局部状态自动保留。生成器适合流式读取、管道处理和大数据集，但也有边界：

通常只能消费一次；
错误可能推迟到迭代时才发生；
打开的外部资源必须明确关闭；
惰性管道若从不消费，就不会执行其中逻辑。

yield from 可以委托另一个可迭代对象：

1
2
3


def flatten(groups: list[list[int]]) -> Iterator[int]:
 for group in groups:
 yield from group

它不等于任意层级递归展开，只是把当前子迭代器的值依次转发。

8. 上下文管理协议

with 用于表达“进入—执行—退出”的资源生命周期：

1
2


with open("data.txt", encoding="utf-8") as file:
 content = file.read()

对象通过 __enter__() 和 __exit__() 实现同步上下文管理协议。即使代码块抛出异常，__exit__() 仍会执行；它是否抑制异常取决于返回值。

简单场景可使用 contextlib.contextmanager：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from collections.abc import Iterator
from contextlib import contextmanager
from time import perf_counter


@contextmanager
def measure(name: str) -> Iterator[None]:
 started = perf_counter()
 try:
 yield
 finally:
 elapsed = perf_counter() - started
 print(f"{name}: {elapsed:.6f}s")


with measure("load"):
 sum(range(100_000))

yield 前是进入逻辑，yield 后是退出逻辑。清理必须放在 finally 中，否则代码块抛异常时可能跳过清理。

9. 组合一个惰性处理管道

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from collections.abc import Iterable, Iterator


def parse_numbers(lines: Iterable[str]) -> Iterator[float]:
 for line_number, line in enumerate(lines, start=1):
 text = line.strip()
 if not text or text.startswith("#"):
 continue
 try:
 yield float(text)
 except ValueError as error:
 raise ValueError(f"第 {line_number} 行不是数字：{text!r}") from error


with open("measurements.txt", encoding="utf-8") as file:
 values = parse_numbers(file)
 total = sum(values) # 实际项目计算均值还需同时记录数量

这段管道不会把整个文件读入内存，错误也保留了原始异常链。注意生成器消费发生在 with 内部；如果把 values 带出代码块后再迭代，文件已经关闭。

10. 小结

参数是新的局部名称绑定；修改共享可变对象与重新绑定形参是两回事。
/ 和 * 能把位置参数、关键字参数的接口边界写清楚。
闭包捕获名称，循环创建闭包时要理解晚绑定。
装饰器是重新绑定函数对象，编写包装器时使用 functools.wraps。
for 建立在迭代协议上，生成器用 yield 保存迭代状态。
with 建立在上下文管理协议上，清理逻辑必须覆盖异常路径。

下一篇将进入类、继承、组合、特殊方法和 dataclass，把对象模型用于领域建模。

参考资料

Python 编程基础与工程实践（三）：容器、可变性与数据处理

Wed, 24 Jun 2026 10:00:00 +0800

Python 很多表达力来自内置容器：列表保存有序数据，字典表达映射，集合处理唯一性，元组表示稳定结构。真正决定代码是否可靠的，不只是会调用方法，而是理解它们的可变性、别名、哈希与复制语义。

本文以 CPython 3.14 为基线，建立容器选型和数据处理的完整心智模型。

1. 先按语义选择容器

类型	是否有序	是否可变	是否允许重复元素	典型用途
`list`	是	是	是	动态序列、批量处理
`tuple`	是	否	是	固定记录、复合键、函数多返回值
`dict`	按插入顺序	是	键唯一	键值映射、结构化记录
`set`	不承诺业务顺序	是	否	去重、成员检查、集合运算
`frozenset`	不承诺业务顺序	否	否	不可变集合、可哈希集合键

“有序”指迭代语义，不代表所有位置操作都高效。list 适合尾部追加和按下标访问，却不适合频繁从头部删除；队列应考虑 collections.deque。

2. 列表：可变的动态序列

1
2
3
4
5
6


measurements = [10.2, 9.8, 10.5]
measurements.append(10.1)
measurements.extend([9.9, 10.0])

first = measurements[0]
last = measurements[-1]

切片返回一个新的列表：

1
2
3


window = measurements[1:4]
every_other = measurements[::2]
reversed_copy = measurements[::-1]

新列表只复制元素引用，不递归复制元素。若元素本身可变，两个列表仍可能共享内部对象。

排序要区分原地修改和返回新值：

1
2
3
4
5
6
7


records = [
 {"name": "B", "score": 92},
 {"name": "A", "score": 92},
 {"name": "C", "score": 88},
]

ordered = sorted(records, key=lambda item: (-item["score"], item["name"]))

sorted() 接受任意可迭代对象并返回新列表；list.sort() 原地排序并返回 None。不要写 records = records.sort()，否则名称会被绑定到 None。

3. 元组：不可变的是结构，不一定是内部对象

1
2


point = (10, 20)
x, y = point

单元素元组依靠逗号，而不是括号：

1
2


single = (42,)
not_a_tuple = (42)

元组不能替换元素，但可以包含可变对象：

1
2


record = ("sensor-1", [10.1, 10.2])
record[1].append(10.3)

因此，“元组不可变”只表示元组保存的引用序列不能改变。一个元组能否作为字典键，还取决于其所有成员是否可哈希；上面的 record 包含列表，不能作为键。

解包可以让数据流更清楚：

1
2
3
4


head, *middle, tail = [1, 2, 3, 4, 5]
assert head == 1
assert middle == [2, 3, 4]
assert tail == 5

4. 字典：键到值的映射

1
2
3
4
5
6
7


device = {
 "id": "EQ-01",
 "online": True,
 "temperature": 24.5,
}

device["temperature"] = 25.0

从 Python 3.7 起，字典保持插入顺序是语言保证；但它仍是映射，不应把“第几个键”当成主要建模方式。

读取缺失键有三种常见策略：

1
2
3
4
5
6
7
8
9


# 缺失就是程序错误：抛出 KeyError
device_id = device["id"]

# 缺失可使用默认值
retry_count = device.get("retry_count", 0)

# 缺失时创建并保存默认值
groups: dict[str, list[int]] = {}
groups.setdefault("A", []).append(1)

批量分组时，defaultdict 通常更清晰：

1
2
3
4
5


from collections import defaultdict

groups: defaultdict[str, list[int]] = defaultdict(list)
for name, value in [("A", 1), ("B", 2), ("A", 3)]:
 groups[name].append(value)

遍历键值对使用 items()：

1
2


for key, value in device.items():
 print(key, value)

keys()、values() 和 items() 返回动态视图。字典变化后，已有视图也会反映变化；它们不是创建时的独立快照。

5. 集合：唯一性与集合代数

1
2
3
4
5
6
7


expected = {"A", "B", "C"}
actual = {"B", "C", "D"}

missing = expected - actual # {'A'}
unexpected = actual - expected # {'D'}
common = expected & actual # {'B', 'C'}，先后顺序不保证
all_names = expected | actual

空集合必须写成 set()；{} 创建的是空字典。

集合迭代顺序不应作为业务契约。即使某次运行看起来稳定，也可能受哈希随机化、元素变化或实现差异影响。需要稳定输出时显式排序：

1
2


for name in sorted(all_names):
 print(name)

集合元素和字典键必须可哈希。常见可哈希对象包括整数、字符串、字节和成员均可哈希的元组；列表、字典、普通集合不可哈希，因为可变对象在作为键期间改变会破坏查找语义。

6. 推导式：把映射和筛选写在一起

1
2
3
4
5


raw = [1, 2, 3, 4, 5]
squares_of_even = [value * value for value in raw if value % 2 == 0]

lookup = {value: value * value for value in raw}
unique_lengths = {len(str(value)) for value in raw}

推导式适合一层映射和简单筛选。出现多层嵌套、异常处理或复杂分支时，普通循环更容易阅读和调试。

生成器表达式使用圆括号，按需产生元素：

1

total = sum(value * value for value in range(1_000_000))

它避免先构造一个包含一百万个平方值的列表，但“惰性”不保证一定更快；它主要改变内存占用和求值时机。

7. 浅拷贝、深拷贝与别名

赋值不复制对象：

1
2


original = [[1, 2], [3, 4]]
alias = original

浅拷贝创建新的外层容器，内部元素仍共享：

1
2
3
4
5
6


shallow = original.copy()
shallow[0].append(99)

assert original[0] == [1, 2, 99]
assert shallow is not original
assert shallow[0] is original[0]

深拷贝会递归复制对象图，并使用备忘录处理共享引用和循环引用：

1
2
3
4
5
6
7


from copy import deepcopy

original = [[1, 2], [3, 4]]
deep = deepcopy(original)
deep[0].append(99)

assert original[0] == [1, 2]

deepcopy() 不是“安全按钮”。文件句柄、数据库连接、锁和外部资源通常不能通过复制获得合理语义；大型对象图也可能代价很高。更好的做法是先明确所有权，只复制真正需要独立修改的数据。

8. 可变默认值为何危险

函数默认参数在函数定义执行时求值一次，不是每次调用重新创建：

1
2
3
4


# 错误示例：多次调用共享同一个列表
def collect_bad(value: int, bucket: list[int] = []) -> list[int]:
 bucket.append(value)
 return bucket

正确做法是使用 None 作为哨兵：

1
2
3
4
5
6
7
8
9


def collect(value: int, bucket: list[int] | None = None) -> list[int]:
 if bucket is None:
 bucket = []
 bucket.append(value)
 return bucket


assert collect(1) == [1]
assert collect(2) == [2]

同样的问题也会出现在类属性、缓存和全局容器中。关键不是机械记忆“不要用列表”，而是先问：这个可变对象应该由所有调用共享，还是每次调用独占？

9. 不要在遍历时随意修改容器

遍历字典或集合时改变其大小会抛出运行时错误。需要删除元素时，可以遍历快照或构造新容器：

1
2
3
4
5
6
7


scores = {"A": 80, "B": 45, "C": 90}

filtered = {
 name: score
 for name, score in scores.items()
 if score >= 60
}

遍历列表时删除元素未必抛错，却可能跳过元素，因为后续下标发生移动：

1
2


values = [1, 2, 3, 4]
values = [value for value in values if value % 2 != 0]

如果确实需要保持原列表对象，可使用切片赋值：

1

values[:] = [value for value in values if value % 2 != 0]

10. 一个数据清洗示例

下面把容器选择、解析和聚合组合起来：

 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


from collections import defaultdict

rows = [
 ("A", "10.2"),
 ("B", "invalid"),
 ("A", "9.8"),
 ("B", "11.0"),
]

grouped: defaultdict[str, list[float]] = defaultdict(list)
errors: list[tuple[str, str]] = []

for name, raw_value in rows:
 try:
 value = float(raw_value)
 except ValueError:
 errors.append((name, raw_value))
 continue
 grouped[name].append(value)

averages = {
 name: sum(values) / len(values)
 for name, values in grouped.items()
}

print(averages) # {'A': 10.0, 'B': 11.0}
print(errors) # [('B', 'invalid')]

这段代码没有默默丢弃坏数据，而是把失败记录保留下来，便于后续告警或人工处理。容器不只是存放数据，也是在表达错误策略和所有权。

11. 小结

按业务语义选容器：序列、固定记录、映射和集合是不同抽象。
元组不可改变自身结构，但内部对象仍可能可变；可哈希性要递归判断。
字典保持插入顺序，集合不提供可依赖的业务顺序。
赋值不复制，浅拷贝共享内部元素，深拷贝也不是所有对象的通用方案。
推导式适合简单映射与筛选；复杂控制流应回到普通循环。

下一篇将把“可迭代”背后的协议展开，并学习函数参数、闭包、装饰器、生成器和上下文管理器。

参考资料

Python 编程基础与工程实践（二）：语法、名称绑定与基础类型

Mon, 22 Jun 2026 10:00:00 +0800

Python 语法简洁，但“看得懂”不等于理解它的运行方式。尤其是变量、赋值和对象，如果沿用其他语言中的直觉，很容易在可变参数、复制和并发代码里踩坑。

本文以 CPython 3.14 为基线，从名称绑定开始讲清基础类型、表达式和控制流。读者只需完成上一篇的解释器与虚拟环境准备。

1. 缩进是语法，不是装饰

Python 使用缩进划分代码块，不使用花括号：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


temperature = 26.5

if temperature >= 30:
 level = "hot"
elif temperature >= 20:
 level = "comfortable"
else:
 level = "cold"

print(level)

同一代码块必须保持一致缩进。工程中通常使用 4 个空格，不要混用 Tab 和空格。冒号表示即将开始一个代码块，常见于 if、for、while、def、class、try、with 和 match。

较长表达式应借助括号自然换行：

1
2
3
4
5


total = (
 subtotal
 + shipping_fee
 - discount
)

不要依赖反斜杠拼接复杂表达式；括号内换行更稳健，也更容易被格式化工具处理。

2. 变量更准确地说是“名称”

在 Python 中，赋值把名称绑定到对象：

1
2
3
4
5
6


first = [1, 2]
second = first
second.append(3)

print(first) # [1, 2, 3]
print(first is second) # True

这里没有复制列表。first 和 second 指向同一个对象，所以通过任一名称修改列表，都能从另一个名称观察到。

每个对象都有类型、标识和值：

1
2
3
4


value = 42

print(type(value))
print(id(value))

type(value) 返回对象的类型；
id(value) 返回对象在当前生命周期内唯一的标识；
is 比较对象标识，== 比较值是否相等。

因此，判断空值应写：

1
2


if result is None:
 print("没有结果")

不要用 is 比较普通数字或字符串。CPython 可能复用某些对象，但那是实现细节，不是业务语义。

3. 数值类型与除法

常用内置数值类型包括：

int：任意精度整数，大小主要受可用内存限制；
float：通常对应平台的双精度二进制浮点数；
complex：复数；
bool：逻辑值，是 int 的子类，但业务代码应把它当布尔类型使用。

1
2
3
4
5


count = 1_000_000
ratio = 3 / 2 # 1.5，真除法
quotient = 7 // 3 # 2，向下取整除法
remainder = 7 % 3 # 1
power = 2 ** 10 # 1024

// 是向负无穷方向取整，不是简单“截掉小数”：

1
2


assert -7 // 3 == -3
assert -7 % 3 == 2

二进制浮点不能精确表示所有十进制小数：

1

print(0.1 + 0.2) # 0.30000000000000004

这不是 Python 独有问题。金额等需要确定十进制语义的场景可使用 decimal.Decimal，但必须从字符串构造，避免先引入浮点误差：

1
2
3
4
5


from decimal import Decimal

price = Decimal("0.10")
tax = Decimal("0.20")
assert price + tax == Decimal("0.30")

4. 文本 `str` 与字节 `bytes`

Python 3 的 str 表示 Unicode 文本，bytes 表示 0 到 255 的字节序列。两者不能直接拼接：

1
2
3
4
5


message = "温度正常"
payload = message.encode("utf-8")

assert payload == b"\xe6\xb8\xa9\xe5\xba\xa6\xe6\xad\xa3\xe5\xb8\xb8"
assert payload.decode("utf-8") == message

字符串是不可变对象。所谓“修改字符串”实际会创建新字符串并重新绑定名称：

1
2
3


name = "python"
name = name.capitalize()
print(name) # Python

常用格式化方式是 f-string：

1
2
3


product = "sensor"
price = 12.3456
print(f"{product=}, price={price:.2f}")

输出为 product='sensor', price=12.35。格式说明符控制的是展示，不会改变原始数值。

Python 3.14 还新增了模板字符串字面量（t-string）。它使用类似 f-string 的语法，但结果不是 str，而是保留静态片段与插值信息的 string.templatelib.Template：

1
2
3
4
5
6
7
8
9


from string.templatelib import Template


name = "sensor"
template = t"Device: {name}"

assert isinstance(template, Template)
assert template.strings == ("Device: ", "")
assert template.values == ("sensor",)

t-string 供模板引擎、HTML 转义或领域专用处理器检查插值后再渲染，本身不会自动完成转义，也不能当普通字符串直接交给所有 API。普通展示继续使用 f-string；只有接收方明确支持 Template 时才使用 t-string。

处理文件和网络数据时，应该在系统边界明确编码：内部尽量使用 str，读写时显式使用 UTF-8。

5. `None`、布尔值与真值判断

None 表示缺少值，它不是空字符串、零或 False。函数没有显式 return 时会返回 None。

下列对象在布尔上下文中为假：

False 和 None；
数值零；
空字符串和空容器；
自定义类型通过 __bool__() 或 __len__() 定义的假值。

1
2
3
4


items: list[str] = []

if not items:
 print("列表为空")

但是“没有值”和“值恰好为零”可能代表不同业务状态：

1
2
3
4


def display_count(count: int | None) -> str:
 if count is None:
 return "尚未统计"
 return f"数量：{count}"

不要把这里写成 if not count，否则合法的 0 会被误判为缺失。

逻辑运算符 and 和 or 会短路，并返回参与运算的对象，不保证返回 bool：

1
2
3


configured_name = ""
name = configured_name or "default"
assert name == "default"

这个习惯写法适合“所有假值都等价”的场景；若空字符串和 None 含义不同，仍要显式判断。

6. 比较、成员检查与链式比较

1
2
3
4
5


age = 25

assert 18 <= age < 65
assert "py" in "cpython"
assert 3 not in {1, 2}

链式比较 18 <= age < 65 只求值中间表达式一次，语义接近 18 <= age and age < 65。不同类型通常不能随意排序，例如 1 < "2" 会抛出 TypeError，这能避免隐式转换掩盖数据问题。

7. `if`、`for` 与 `while`

Python 的 for 遍历可迭代对象，不是传统 C 风格计数循环：

1
2
3
4


temperatures = [21.5, 23.0, 25.2]

for index, value in enumerate(temperatures, start=1):
 print(index, value)

同时遍历多个序列可使用 zip()：

1
2
3
4
5


names = ["A", "B"]
values = [10, 20]

for name, value in zip(names, values, strict=True):
 print(name, value)

strict=True 会在序列长度不一致时抛出 ValueError，适合长度不一致代表数据错误的场景。

while 适合由状态而非固定集合驱动的循环：

1
2
3
4
5


remaining = 3

while remaining > 0:
 print(remaining)
 remaining -= 1

break 退出当前循环，continue 跳到下一轮。循环还支持 else：只有循环正常结束、没有被 break 打断时才执行。

1
2
3
4
5
6
7
8


target = 7

for value in [2, 4, 6]:
 if value == target:
 print("found")
 break
else:
 print("not found")

8. 结构化模式匹配

match/case 不是简单的 switch，它可以按数据结构解构对象：

1
2
3
4
5
6
7
8


def describe(command: tuple[str, ...]) -> str:
 match command:
 case ("move", x, y):
 return f"移动到 ({x}, {y})"
 case ("stop",):
 return "停止"
 case _:
 return "未知命令"

模式中的裸名称通常是捕获变量，不是与同名常量比较。需要匹配枚举或常量时，应使用限定名称，例如 Color.RED。简单条件继续使用 if 更清楚；只有当数据形状本身就是分支依据时，模式匹配才真正有价值。

9. 输入、转换与错误边界

input() 始终返回字符串：

1
2


raw = input("请输入数量：")
count = int(raw)

int() 遇到非法文本会抛出 ValueError，实际程序需要定义错误处理策略：

1
2
3
4
5
6
7
8


raw = input("请输入数量：")

try:
 count = int(raw)
except ValueError:
 print("数量必须是整数")
else:
 print(f"已记录：{count}")

不要使用 eval(input(...)) 解析用户输入。eval 会执行任意表达式，无法替代正常的格式解析与校验。

10. 小结

Python 赋值是名称绑定，不会自动复制对象；is 比较标识，== 比较值。
str 是 Unicode 文本，bytes 是字节；编码和解码应发生在系统边界。
真值判断很方便，但不能混淆 None、零和空字符串的业务含义。
for 面向可迭代对象，zip(strict=True) 能主动发现长度错位。
match 适合按数据结构分支，不应机械替代 if。

下一篇将学习列表、元组、字典和集合，并深入解释可变性、哈希与复制。

参考资料

Python 编程基础与工程实践（一）：运行模型、版本与开发环境

Sat, 20 Jun 2026 10:00:00 +0800

Python 看起来很容易上手：安装解释器，写一句 print("Hello") 就能运行。但真正进入项目后，常见问题往往不是语法，而是“我运行的到底是哪一个 Python”“包装到哪里了”“Python 2 和 3 为什么不能混用”。

本文是系列起点，面向第一次系统学习 Python、或只写过零散脚本的读者。全文以 CPython 3.14 为验证基线（验证版本 3.14.7）；Python 3.15 在本文写作时仍处于预发布阶段，不作为生产教程的基线。

1. Python、CPython 和解释器是什么关系

Python 首先是一门语言：它定义语法、对象模型和标准库接口。CPython 是 Python 官方维护、使用最广泛的实现，因主要以 C 编写而得名。除此之外还有 PyPy、Jython 等实现，它们可能采用不同的执行技术或面向不同平台。

日常说“安装 Python”，多数时候指安装 CPython。执行一个 .py 文件时，可以先用下面这个简化模型理解：

1
2
3
4
5


源代码（.py）
 ↓ 解析与编译
字节码（code object，可缓存为 .pyc）
 ↓ CPython 虚拟机执行
程序结果

“解释型语言”不等于逐字逐句直接执行源码。CPython 会先把源码编译为字节码，再由解释器执行；这些实现细节也不意味着 Python 代码永远不会经过即时编译或本地代码优化，其他实现可以采用不同策略。

可以在程序里确认当前解释器：

1
2
3
4
5
6


import platform
import sys

print(sys.version)
print(sys.executable)
print(platform.python_implementation())

其中 sys.executable 很重要：它告诉你当前进程实际使用哪个解释器，而不是你以为终端会找到哪个解释器。

2. Python 2 和 Python 3 是一次断代

Python 3.0 不是 Python 2 的普通小升级，而是有意清理历史设计的一次不兼容演进。Python 2.7 是 2.x 的最后一个版本，已于 2020 年 1 月 1 日停止官方支持；最终发行版 2.7.18 只是汇集停更前的修复，不代表支持期延长。

今天的新项目应直接使用 Python 3。阅读旧代码时，最容易遇到这些差异：

主题	Python 2 典型行为	Python 3 现代行为
输出	`print "hello"` 是语句	`print("hello")` 是函数调用
整数除法	`5 / 2` 得到 `2`	`5 / 2` 得到 `2.5`，整除使用 `5 // 2`
文本模型	`str` 默认是字节序列，另有 `unicode`	`str` 表示 Unicode 文本，`bytes` 表示字节
输入	`raw_input()` 读取文本，`input()` 会求值	`input()` 始终返回文本
序列工具	`range()` 直接构造列表	`range()` 返回惰性的范围对象
字典遍历	`dict.keys()` 等通常返回列表	返回动态视图对象
异常语法	可见 `except E, e` 等旧写法	使用 `except E as e`

真正棘手的通常是文本与字节边界。网络、文件和压缩数据是字节，用户看到的是文本；Python 3 强制程序明确进行编码和解码：

1
2
3
4
5
6
7


text = "半导体设备"
payload = text.encode("utf-8")
restored = payload.decode("utf-8")

assert isinstance(text, str)
assert isinstance(payload, bytes)
assert restored == text

不要为了兼容早已停更的 Python 2，在新项目中继续采用旧语法或“双版本兼容”技巧。确有遗留系统时，应把迁移作为独立工程：先建立测试，再借助静态扫描和分阶段替换处理 Unicode、依赖与行为差异。

3. 安装后先确认命令指向哪里

从 Python 官网安装当前稳定版后，先新开一个终端检查版本。Windows 通常可以使用：

1
2
3


python --version
python -c "import sys; print(sys.executable)"
Get-Command python

macOS 或 Linux 发行版经常把 Python 3 命名为 python3：

1
2
3


python3 --version
python3 -c 'import sys; print(sys.executable)'
command -v python3

不同操作系统、安装方式和 PATH 配置可能产生不同命令名，文章后面统一写 python。如果你的环境只有 python3，请对应替换。不要通过删除系统自带解释器来“修复”命令冲突；先用上述发现命令确认路径，再调整用户级 PATH 或使用解释器绝对路径。

还要区分下面三个版本：

1
2
3


python --version
python -m pip --version
python -c "import sys; print(sys.prefix, sys.base_prefix, sep='\n')"

第一条确认语言运行时版本；
第二条同时显示 pip 版本及其安装位置，可判断它是否属于当前解释器；
第三条用于观察当前环境与基础解释器的位置。

优先写 python -m pip，而不是裸用 pip。前者明确要求“由这个 Python 运行它所关联的 pip 模块”，多解释器并存时更不容易装错环境。

4. 用虚拟环境隔离每个项目

虚拟环境不是虚拟机，也不会复制完整操作系统。它在一个目录中记录基础解释器，并为项目提供独立的可执行入口和 site-packages。标准库模块 venv 足以创建它：

1
2
3


mkdir python-demo
cd python-demo
python -m venv .venv

在 Windows PowerShell 中可以激活：

1
2


.\.venv\Scripts\Activate.ps1
python --version

若本机策略不允许执行激活脚本，不必为了一个项目修改全局执行策略。激活本质上只是把虚拟环境目录提前放进 PATH，可以直接使用完整路径：

1
2


.\.venv\Scripts\python.exe -m pip --version
.\.venv\Scripts\python.exe app.py

在 Bash 中对应为：

1
2
3


python3 -m venv .venv
source .venv/bin/activate
python --version

激活后验证：

1
2
3
4
5


import sys

print(sys.prefix)
print(sys.base_prefix)
print(sys.prefix != sys.base_prefix)

输出 True 表示当前解释器运行在虚拟环境中。.venv/ 应加入版本控制忽略列表；虚拟环境被设计成可删除、可重建，也不应复制到另一台机器。

5. REPL、脚本和模块入口

直接运行 python 会进入交互式解释器（REPL），适合验证表达式：

1
2
3
4


>>> 5 / 2
2.5
>>> "py" * 3
'pypypy'

业务代码应保存为脚本。例如 app.py：

1
2
3
4
5
6


def main() -> None:
 print("Hello, Python 3.14")


if __name__ == "__main__":
 main()

然后执行：

1

python app.py

当文件被直接执行时，模块名 __name__ 是 "__main__"；当它被别的模块导入时，__name__ 是实际模块名。因此入口保护能避免“导入函数时顺便启动程序”。

对于包中的模块，更推荐从项目根目录通过模块名启动：

1

python -m my_app.cli

-m 会按导入系统定位模块，并正确建立包上下文；直接运行包内部某个文件，容易造成相对导入失败或产生两套不同的导入路径。

6. 一个可重复的最小工作流

第一次建立项目时，可以遵循下面的闭环：

1
2
3
4


mkdir temperature-converter
cd temperature-converter
python -m venv .venv
.\.venv\Scripts\python.exe -m pip --version

创建 converter.py：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


def celsius_to_fahrenheit(celsius: float) -> float:
 return celsius * 9 / 5 + 32


def main() -> None:
 value = float(input("摄氏温度："))
 print(f"华氏温度：{celsius_to_fahrenheit(value):.1f}")


if __name__ == "__main__":
 main()

先做语法编译检查，再运行：

1
2


.\.venv\Scripts\python.exe -m py_compile converter.py
.\.venv\Scripts\python.exe converter.py

py_compile 只能证明语法能够编译，不能证明业务逻辑正确。后续文章会逐步加入类型检查、自动化测试和项目配置，把“能运行”提升为“能维护”。

7. 小结

Python 是语言，CPython 是最常用的官方实现；本文系列锁定 CPython 3.14.7。
Python 2 已停止支持，Python 3 的文本模型、除法和标准库语义与它存在实质差异。
遇到环境问题，先检查 sys.executable 和 python -m pip --version，不要凭命令名猜测。
每个项目使用独立 .venv，并把环境视为可重建产物。
脚本用入口保护，包内程序优先通过 python -m ... 启动。

下一篇将进入 Python 的核心：名称如何绑定对象、基础类型如何工作，以及控制流怎样组织程序。

Python on 纪伟的个人博客

Python 编程基础与工程实践（十）：性能分析、构建与交付

1. 先定义性能问题

2. 正确测量小段代码

3. 用 cProfile 找热点

4. 从算法和数据结构开始

5. 惰性处理与内存占用

6. 用 tracemalloc 定位 Python 分配

7. 解释器、扩展与并行策略

8. 构建 wheel 与源码发行包

9. 发布库与部署应用是两件事

10. 安全发布

11. 部署后的性能闭环

12. 系列总结

参考资料

Python 编程基础与工程实践（九）：测试、pyproject.toml 与工程化

1. 从一个可安装项目开始

2. pyproject.toml 的三层职责

3. 运行时依赖、可选依赖和开发依赖

4. 建立本地开发环境

5. 第一个 pytest 测试

6. Fixture 管理准备与清理

7. 测试替身与 patch 的边界

8. 单元测试、集成测试与端到端测试

9. 覆盖率是发现盲区，不是质量分数

10. 统一工具入口

11. 依赖锁定的准确边界

12. 小结

参考资料

Python 编程基础与工程实践（八）：线程、进程、asyncio 与 GIL

1. 并发、并行和异步不是同义词

2. 默认 CPython 的 GIL 到底保证什么

3. Python 3.14 的自由线程构建

4. 线程：适合阻塞 I/O 和同步库

5. 进程：隔离地址空间并利用多核

6. Python 3.14 的子解释器执行器

7. asyncio：协作式并发

8. 不要阻塞事件循环

9. 超时、取消和清理

10. 背压与有界并发

11. 如何做选择

12. 小结

参考资料

Python 编程基础与工程实践（七）：类型标注与静态检查

1. 类型标注不负责运行时强制

2. 从函数边界开始标注

3. Any、object 与 Never

4. 类型收窄

5. 现代泛型语法

6. Protocol：为鸭子类型补上静态契约

7. TypedDict 与结构化字典

8. 回调、装饰器与 ParamSpec

9. Python 3.14 的注解延迟求值

10. 建立可持续的检查策略

11. 小结

参考资料

Python 编程基础与工程实践（六）：异常、资源与模块系统

1. 异常是控制流，不是返回值替代品

2. 精确捕获，保持异常边界

3. 自定义异常表达领域语义

4. 多个并发错误：ExceptionGroup

5. 资源释放优先使用上下文管理器

6. 模块与包如何组织代码

7. __init__.py 与公共 API

8. 配置：把来源与领域模型分开

9. 日志：记录事件，不拼接秘密

10. 一个清晰的应用边界

11. 小结

参考资料

Python 编程基础与工程实践（五）：对象模型、类与 dataclass

1. 类对象与实例对象

2. 类属性与实例属性不要混淆

3. 实例方法、类方法与静态方法

4. 封装靠接口与约定

5. 特殊方法把对象接入语言协议

6. dataclass 生成什么

7. 相等性、哈希与可变性必须一致

8. 继承、MRO 与 super()

9. 组合往往比继承更稳定

10. 一个完整的小型领域模型

3. 用 `cProfile` 找热点

6. 用 `tracemalloc` 定位 Python 分配

2. `pyproject.toml` 的三层职责

7. `asyncio`：协作式并发

3. `Any`、`object` 与 `Never`

6. `Protocol`：为鸭子类型补上静态契约

7. `TypedDict` 与结构化字典

8. 回调、装饰器与 `ParamSpec`

4. 多个并发错误：`ExceptionGroup`

7. `init.py` 与公共 API

6. `dataclass` 生成什么

8. 继承、MRO 与 `super()`

4. 文本 `str` 与字节 `bytes`

5. `None`、布尔值与真值判断

7. `if`、`for` 与 `while`