ORTHANT · 技术知识库

Miniconda 安装与使用

Sun, 11 Oct 2026 20:21:11 +0800

1. venv、Miniconda 与 Anaconda

方案	包含什么	适合什么情况
`venv`	Python 自带的环境工具，使用已有解释器，通常配合 pip	已有 Python，只需隔离项目依赖
Miniconda	Python、Conda 和必要依赖，其他包按需安装	轻量安装，管理多版本 Python
Anaconda Distribution	Python、Conda、图形工具和大量预装包	希望直接获得数据科学工具集

Miniconda 和 Anaconda 都用 Conda 管理环境，主要差别是预装内容。 Conda 能安装指定版本的 Python，venv 不负责下载另一个 Python。见发行方案比较与 venv 文档。

Miniconda 更轻量，不代表默认软件源没有商业使用限制。 defaults 仓库仍适用对应条款，换成镜像也不改变上游授权条件。下文新环境使用社区 conda-forge，其不适用该仓库的付费要求，仍须遵守服务条款与包许可证。见官方授权说明。

后文只讲 Miniconda，以 Linux Bash 为命令主线。 日常 conda、pip 用法也适用于 macOS，安装器、校验命令和 shell 初始化有所不同。示例使用 Python 3.13、环境名 demo-env；版本与路径因环境而异。

配图说明：除第 5.2 节的 Rich 输出图外，其余配图来自连接本机 macOS Bash 的终端界面，命令均在临时环境中真实执行；版本和路径因环境而异。正文仍以 Linux Bash 为主线。

2. 安装与初始化

2.1 Linux

以下适用于 Linux x86-64。先核对系统要求；ARM 设备须选择受支持的 aarch64 安装器，不能直接使用下面的文件。

第一步：下载并计算校验值。

代码块 Bash

1
2
3


curl -o Miniconda3-latest-Linux-x86_64.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
sha256sum Miniconda3-latest-Linux-x86_64.sh
# 结果：当前目录生成安装脚本，并输出 SHA-256 值与文件名。

将结果与官方列表中同名文件的 SHA-256 比较。校验值不一致时不要安装。

第二步：校验通过后运行安装器。

代码块 Bash

1
2


bash Miniconda3-latest-Linux-x86_64.sh
# 结果：进入协议、安装目录和初始化的交互式安装流程。

阅读协议，确认同意后输入 yes。
确认安装目录，默认通常为 ~/miniconda3；已有安装时不要直接覆盖。
询问是否初始化时输入 yes。
关闭并重新打开终端。

第三步：验证安装。

代码块 Bash

1
2
3


conda --version
# 示例输出：
# conda 25.11.1

latest 会随官方发布变化，不是固定版本。完整步骤见 Linux 安装说明。

2.2 macOS

Apple Silicon（M 系列）：下载 MacOSX-arm64.sh，校验命令改用 shasum -a 256：

代码块 Bash

1
2
3


curl -o Miniconda3-latest-MacOSX-arm64.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh
shasum -a 256 Miniconda3-latest-MacOSX-arm64.sh
# 结果：下载安装脚本，并输出 SHA-256 值；与官方同名文件比较。

校验通过后执行 bash Miniconda3-latest-MacOSX-arm64.sh，其余交互步骤同上。见 macOS 安装说明。

Intel Mac：默认仓库自 2025 年 8 月 15 日起停止构建 osx-64 新包；历史安装器仍可下载，但不是持续更新的最新版。此变化不等于 conda-forge 同时停止支持。见官方说明。

2.3 Windows

按官方安装说明下载并运行 Windows-x86_64.exe：

个人安装通常选 Just Me，确认安装路径。
不勾选 Add to PATH，避免干扰已有 Python。
安装后打开 Anaconda Prompt，运行 conda --version 验证。这是 Miniconda 也会提供的终端入口名称。

2.4 初始化与 base

若 Linux 安装时跳过了初始化，按实际安装路径执行一次，然后重新打开终端：

代码块 Bash

1
2


~/miniconda3/bin/conda init bash
# 结果：检查并按需修改 Bash 启动配置；重新打开终端后生效。

macOS 默认 Zsh 则将末尾的 bash 换为 zsh。初始化让 shell 支持环境切换，不是创建项目环境。见 conda init 文档。

base 是 Miniconda 自带的基础环境，项目依赖另建环境安装。不想每次打开终端自动进入默认环境，可执行：

代码块 Bash

1
2


conda config --set auto_activate false
# 结果：保存配置，通常无输出；以后新终端不再自动激活默认环境。

此设置不退出当前环境；退出用 conda deactivate。旧名称 auto_activate_base 目前仍是别名，见配置说明。

3. 配置镜像

Conda 源与 pip 源是两套地址，不能混用。 各选一个即可；镜像可能有同步延迟，不要叠加所有镜像。

3.1 可复制的镜像地址

Conda：conda-forge 频道地址。下面是静态地址清单，不是执行命令：

代码块 Text

1
2
3
4
5
6
7
8


# 清华 TUNA
https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge
# 中科大 USTC
https://mirrors.ustc.edu.cn/anaconda/cloud/conda-forge
# 北外 BFSU
https://mirrors.bfsu.edu.cn/anaconda/cloud/conda-forge
# 南京大学 NJU
https://mirror.nju.edu.cn/anaconda/cloud/conda-forge

pip：PyPI 镜像地址：

代码块 Text

1
2
3
4
5
6
7
8


# 清华 TUNA
https://pypi.tuna.tsinghua.edu.cn/simple
# 中科大 USTC
https://mirrors.ustc.edu.cn/pypi/simple
# 北外 BFSU
https://mirrors.bfsu.edu.cn/pypi/web/simple
# 阿里云
https://mirrors.aliyun.com/pypi/simple/

临时使用示例：以下以清华镜像为例。Conda 命令只查询包；pip 命令请在第 4 节创建并激活项目环境后执行：

代码块 Bash

1
2
3
4
5


conda search requests --override-channels -c https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge
# 输出：该镜像中的 requests 版本列表；结果随镜像同步状态变化。

pip install rich -i https://pypi.tuna.tsinghua.edu.cn/simple
# 输出：从指定 PyPI 镜像查找并安装 rich；版本与日志因环境而异。

第 4 节创建并激活环境后，需要让当前用户默认使用清华 PyPI 镜像，可以保存用户级配置：

代码块 Bash

1
2


pip config --user set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
# 结果：写入用户级 pip 配置，通常显示已保存的配置文件路径和值。

这里的 --user 指配置文件作用域，会影响读取该用户配置的其他环境，不是 pip install --user。用 pip config debug 检查配置来源；用 pip config --user unset global.index-url 删除这项设置。见 pip 配置说明。

维护方说明：清华、中科大、北外、南京大学、阿里云。中科大的部分频道使用动态缓存，可能重定向到其他镜像站。

3.2 设置 Conda 镜像

先查看配置来源：

代码块 Bash

1
2


conda config --show-sources
# 输出：生效配置文件的路径与内容；结果取决于本机配置。

编辑 ~/.condarc；已有文件先备份，只调整相关项。以下静态配置使用清华 conda-forge，不加入 defaults：

代码块 Yaml

1
2
3
4


channels:
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge
channel_priority: strict
show_channel_urls: true

strict 表示严格频道优先级，show_channel_urls 显示包来源。

保存后查看实际生效的频道：

代码块 Bash

1
2
3
4


conda config --show channels
# 仅上述频道生效时，示例输出：
# channels:
# - https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge

若仍有 defaults 等非预期项，回到 --show-sources 检查其他配置文件；列表可能合并。后续命令以完成此配置为前提，详见 Conda 配置说明。

第 3.1 节临时查询中的 -c 添加频道，--override-channels 排除配置中的其他频道。仅加 -c 不等于只用这一来源。

4. 创建和使用环境

创建 demo-env，安装 Python 3.13 与 pip，再激活：

代码块 Bash

1
2
3


conda create -n demo-env python=3.13 pip
conda activate demo-env
# 结果：确认安装计划后创建环境；激活后提示符通常出现 (demo-env)。

-n 指定环境名，python=3.13 指定版本系列。激活只影响当前终端，不会切换项目目录；代码不要放进环境目录。

检查当前解释器：

代码块 Bash

1
2
3
4
5
6
7


python --version
python -c "import sys; print(sys.executable)"
pip --version
# Linux 示例输出；版本与路径因环境而异：
# Python 3.13.16
# /home/you/miniconda3/envs/demo-env/bin/python
# pip 26.2.1 from /home/you/miniconda3/envs/demo-env/lib/python3.13/site-packages/pip (python 3.13)

确认环境看解释器路径，不只看终端前缀。 pip --version 显示的位置也应属于 demo-env。下文完成核对后使用常见简写 pip；未激活环境或存在多个 Python 时，python -m pip 可将 pip 明确绑定到当前 python。

以下命令按需使用，不必依次执行：

命令	含义
`conda env list`	列出环境和路径，当前环境通常带 `*`
`conda info`	查看安装路径、当前环境和平台
`conda activate demo-env`	切换到指定环境
`conda deactivate`	退出当前激活层级，可能回到 base
`conda run -n demo-env python --version`	不先激活，直接在指定环境执行命令
`conda create --help`	查看参数说明，其他子命令也支持 `--help`

-p 路径 可代替 -n 名称 按路径指定环境；-y 跳过确认，未核对安装计划时不要添加。

5. 安装与管理包

Conda 管理环境、Python 版本和 Conda 包，pip 安装 PyPI 包。已配置 conda-forge 时，先用 Conda 安装频道中已有的依赖；频道中没有，或项目明确使用 PyPI 和 requirements.txt 时，再用 pip。

5.1 Conda 命令

激活目标环境，安装 requests，再验证版本：

代码块 Bash

1
2
3
4
5
6


conda activate demo-env
conda install requests
python -c "import requests; print(requests.__version__)"
# 结果：确认计划后安装 requests 及其依赖。
# 版本示例输出：
# 2.34.2

命令	含义
`conda search requests`	搜索可安装的版本
`conda list`	列出当前环境里的包
`conda list requests`	查询指定包
`conda install requests=2.32`	安装指定版本系列
`conda update requests`	更新一个包及必要依赖
`conda remove requests`	移除一个包，先核对连带变更

未激活目标环境时，可用 -n demo-env 显式指定环境，例如 conda list -n demo-env。

5.2 pip 命令

当 Conda 频道没有所需包，或项目使用 PyPI 依赖清单时，先激活环境，再用 pip 安装。

rich 是个很流行的终端美化库，专门用来让命令行输出变好看。

示例结果展示：

以下用 rich 演示：

代码块 Bash

1
2
3


conda activate demo-env
pip install rich
# 结果：在当前环境安装 rich；版本与日志因环境而异。

命令	含义
`pip list`	列出当前 Python 可识别的包
`pip show rich`	查看版本、位置和依赖
`pip install "rich==14.2.0"`	安装指定版本
`pip install --upgrade rich`	更新包
`pip uninstall rich`	卸载包
`pip check`	检查声明的依赖是否缺失或冲突

先 Conda、后 pip；不要用两者反复覆盖同一个包。 在 Conda 环境中执行 pip install 时不要加 --user。rich 仅用于演示 pip，并非只能用 pip 安装；混用后还需调整 Conda 依赖时，优先按清单重建。见官方混用建议。

6. 导出依赖与重建

导出的是清单，不是安装包文件。 重建时仍需下载依赖；下面两条路线选其一，不要重复灌入同一环境。

项目情况	使用清单
Miniconda 只提供 Python 和隔离环境，项目依赖都由 pip 管理	`requirements.txt`
Conda 管理 Python 和 Conda 包，pip 只补充其余依赖	`environment.yml`

> 和 --file 会覆盖同名文件，导出前确认路径。

6.1 pip：requirements.txt

以下用独立的 pip-demo-env 演示纯 pip 路线，不承接第 5 节同时使用 Conda 和 pip 的 demo-env。

创建原环境、安装依赖并导出：

代码块 Bash

1
2
3
4
5


conda create -n pip-demo-env python=3.13 pip
conda activate pip-demo-env
pip install rich
pip freeze > requirements.txt
# 结果：创建独立环境、安装 rich，并在当前目录写入 requirements.txt。

在目标机器进入清单所在目录，创建新环境并安装：

代码块 Bash

1
2
3
4
5
6
7


conda create -n pip-demo-env-copy python=3.13 pip
conda activate pip-demo-env-copy
pip install -r requirements.txt
pip check
# 结果：创建副本，按清单安装依赖；日志取决于清单内容。
# 未检测到依赖问题时，最后输出：
# No broken requirements found.

freeze 也可能列出 Conda 安装但 Python 能识别的包、间接依赖和本机路径；不是只导出 pip 安装的包，也不包含 Python 解释器。分享前检查清单。

-r 表示从文件读取依赖，即常见的 pip install -r requirements.txt。文件名可自定；检查通过后仍需运行项目验证。

6.2 Conda：environment.yml

第 5 节的 demo-env 同时包含 Conda 安装的 requests 和 pip 安装的 rich，应使用本节的混合清单。先导出主动安装的 Conda 依赖：

代码块 Bash

1
2


conda env export -n demo-env --from-history --file environment.yml
# 结果：生成 environment.yml，记录显式请求的 Conda 依赖。

--from-history 减少间接依赖的平台限制，但不是精确锁文件，也不能代替完整的 pip 清单。删除本机 prefix，核对频道并排除不需要的 defaults，补齐 pip 依赖。

将 environment.yml 整理并保存为下面的配置，不是直接沿用原始导出内容：

代码块 Yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


name: demo-env
channels:
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge
 - nodefaults
dependencies:
 - python=3.13
 - pip
 - requests
 - pip:
 - rich

pip: 列出交给 pip 安装的包。nodefaults 只放在 environment.yml，用于排除其他配置频道；不要放进 .condarc。

在该文件所在目录重建，-n 覆盖文件中的环境名，保留原环境：

代码块 Bash

1
2
3
4
5


conda env create -n demo-env-copy -f environment.yml
conda run -n demo-env-copy python --version
# 结果：创建 demo-env-copy，并安装清单中的 Conda 与 pip 依赖。
# 版本示例输出：
# Python 3.13.16

若需记录完整状态，使用 conda env export -n demo-env --file environment-full.yml。完整导出含具体版本、构建等信息，仍不保证跨平台重建；分享前检查路径、私有源与认证信息。见环境管理文档。

7. 删除环境与清理缓存

先用 conda env list 核对名称；如果正在副本环境内，先退出，再删除。以下以第 6.2 节的 demo-env-copy 为例：

代码块 Bash

1
2
3


conda deactivate
conda env remove -n demo-env-copy
# 结果：退出当前环境，确认后删除 demo-env-copy 及其中的包。

环境目录里的文件会一起删除，外部项目目录不受影响；不要删除 base。 同名环境已有其他用途时，不要执行上面的删除命令。

若使用第 6.1 节的 pip 路线，对应的副本环境名是 pip-demo-env-copy。

命令	含义
`conda clean --tarballs --dry-run`	预览可清理的缓存压缩包，不执行删除
`conda clean --tarballs`	确认后删除缓存压缩包；以后可能需要重新下载

8. 常见问题

现象	检查项
找不到 `conda`，或要求 `conda init`	是否安装、初始化当前 shell，并重新打开终端
安装后仍 `ModuleNotFoundError`	安装包与运行程序是否使用同一个 Python
`PackagesNotFoundError`	包名、版本、频道与架构是否匹配
`LibMambaUnsatisfiableError`	Python 版本、依赖约束或混源是否冲突
镜像下载失败	镜像是否同步完成、是否提供目标平台的包
终端能运行，编辑器或 Notebook 不能	解释器或内核是否指向 `demo-env`

排查导入错误，在实际报错的位置打印 sys.executable；另一个终端激活了环境，不代表编辑器或 Notebook 已经切换。

ORTHANT 博客技术架构详解

Sun, 11 Oct 2026 20:20:03 +0800

ORTHANT 是我一个人写、一个人维护的博客。搭它的时候我给自己定了三个条件：不维护常驻的服务器；文章用 Markdown 写、存在 Git 里，以后换写作工具也不用迁移；读者打开页面要快，评论、统计这些附加功能出了问题，也不影响读正文。

现在的结构基本就是照这三条拼出来的：文章在发布时提前生成成网页，放在 Cloudflare Pages 上；少数必须在访问时处理的事情，交给 Pages 自带的服务端函数；评论借用 GitHub 的讨论区。

1. 整体结构

整个网站由下面几部分组成：

部分	用的什么	负责什么
内容	Markdown + Git，托管在 GitHub 私有仓库	文章、图片、网站模板，以及它们的全部修改历史
生成	Hugo 和 Hextra 主题	把文章、导航和模板生成成网页，顺带生成搜索索引
托管	Cloudflare Pages	把生成好的网页发给读者
服务端	Pages Functions	站长登录、在线保存、阅读授权、浏览计数
数据库	Cloudflare D1	浏览次数，以及授权码的尝试记录
评论	giscus + GitHub Discussions	评论的显示和存储

串起来看，一篇文章的路径是：写好后提交到 GitHub，Cloudflare 发现有新提交，用 Hugo 重新生成整站，再部署上线。读者访问时拿到的是已经生成好的网页；登录、保存、授权和计数这几件事才会用到服务端函数。

文章正文只存在 Git 里。数据库和讨论区只放浏览数和评论，不放正文。

2. 一篇文章怎么发布

我可以在本地编辑器里写，可以在 GitHub 网页上改，也可以直接在博客里在线编辑。三种方式最后都是往同一个仓库提交，网站只认仓库里的那一份，所以不会出现几份正文互相同步的问题。

在线编辑这块换过几次。最早接的是 Pages CMS，后来换成自己部署的 Decap CMS。它们都有一个独立的后台，Decap 的草稿还要走单独的分支和合并请求，写一篇文章得在后台和 GitHub 之间来回几趟。现在改成在文章页里直接编辑：登录后点「编辑本文」，改完点「保存并发布」。

点下保存之后，大致经过这几步：

服务端确认是我本人在操作，并且对这个仓库有写权限。
检查这篇文章在我打开编辑页之后，有没有在别处被改过。如果改过，这次保存会停下来，提示我重新打开对比，不会把别处的修改覆盖掉。
把正文和这次新插入的图片放进同一次提交，免得文章上线了、图片还没跟上。
Cloudflare 发现仓库有新提交，用 Hugo 重新生成整站并部署。
编辑页等部署完成，确认线上已经是新版本，再提示「已上线」。

这里有两个时间点。「已保存」是内容进了仓库，「已上线」是读者能看到新页面，两者之间隔着一次构建。平时要等一会儿，构建排队或者失败时会更久。编辑页把这两个状态分开显示，我就不用再去 Cloudflare 后台确认。

文章上显示的「发布于」，取的是这篇文章第一次以正式状态进入主分支的时间；「更新于」取的是这个文件最后一次修改的时间。

3. 读者打开页面时

文章在发布时就已经生成好了。读者打开页面，服务器直接把现成的网页发过去，不需要临时去 GitHub 读文章，再拼成页面。

请求到达时会先经过服务端函数检查一下。普通文章直接放行；项目案例要先确认有没有阅读权限，没有的话返回的是授权码页面，正文根本不会发到浏览器里。检查过程出了错，就按没有权限处理，宁可暂时打不开，也不让案例意外公开。

页面显示出来以后，其余功能各自按需加载：浏览次数单独发一个请求；评论区快滚动到时才加载；搜索索引在第一次打开搜索时才下载；编辑器只有登录后才加载。这些部分出了问题，已经显示的正文照样能读。

4. 三种身份

站里的「登录」有三种，权限互不相通：

身份	怎么获得	能做什么
站长	用 GitHub 账号登录	写文章、看项目案例、管理评论
授权读者	输入阅读授权码	看项目案例和附件
评论者	在评论区用 GitHub 授权	在公开文章下评论

站长登录通过一个只授权给博客仓库的 GitHub App 完成。登录状态加密后保存在浏览器里，最长 8 小时，服务端不单独保存会话。每次保存文章，服务端都会重新向 GitHub 确认权限，页面上能看到编辑按钮，不等于就能写入。

阅读授权码是一个共享密码，验证通过后 8 小时内不用再输。它适合把案例给少数人看，但拿到授权码的人能看到全部案例，也能把内容复制走，所以案例在写的时候就要先脱敏。

评论登录由 giscus 单独处理，和前两种互不相干：能评论不代表能看案例，更不能改文章。

5. 搜索、评论和浏览统计

这三样都显示在文章页上，运行的位置和数据存放的地方却各不相同。

搜索在浏览器里完成。构建时 Hugo 会生成一份公开文章的索引，包括标题、章节、标签和正文。第一次搜索时浏览器把它下载下来，之后的查询都在本地进行，不用每输一个字就请求服务器。项目案例不放进这份索引，也就不会从搜索结果里漏出去。

评论放在 GitHub Discussions，通过 giscus 嵌进文章页。评论用的是一个单独的公开仓库，和存放文章的私有仓库分开。现成的账号和讨论功能拿来就能用，评论多了也不用重新构建网站；代价是发言需要 GitHub 账号，文章换地址时要手动迁移原来的讨论。

浏览统计存在 Cloudflare 的 D1 数据库里。同一个浏览器 30 分钟内反复打开同一篇文章只算一次，我自己登录后的访问和编辑预览不算。计数跟着文章的固定编号走，改标题、重新部署都不会清零。它统计的是去重后的浏览次数，和访客人数不是一回事。

6. 这样做的代价

这套结构适合一个人写、以阅读为主的博客，但有几件事要接受：

发布不是即时的。保存后要等一次构建，读者才能看到新内容。
依赖的平台比较多。Cloudflare、GitHub、giscus 任何一个出问题，对应的功能就用不了，好在正文只依赖 Cloudflare。各个平台的免费额度也有上限，访问量大了要留意。
数据分在三个地方。文章和图片在 Git 里，评论在讨论区，浏览数在数据库。Git 能找回文章的任何一个版本，但找不回评论和计数，这几样要分开备份。
权限比较粗。站长只有一个账号，案例只有一个共享授权码。以后如果需要按人授权、单独收回，就得换一套账号体系。

对现在的 ORTHANT 来说，这些代价都能接受。哪部分改了，我会回来更新这篇。

Python 3 易混淆点

Sun, 11 Oct 2026 18:27:06 +0800

版本：示例以 Python 3.13 为基线，涉及 3.14 的变化单独标注。每个 Python 代码块均可独立运行。

按问题查结论，不区分基础与进阶。语法查询见 Python 3 基础速查，完整机制示例见 Python 3 进阶速查。

对象与容器

1. 可变与不可变，究竟什么不能变？

答：指对象能否原地修改，不是变量名能否重新赋值。

类别	常见类型
可变	`list`、`dict`、`set`、`bytearray`
不可变	`int`、`float`、`bool`、`str`、`tuple`、`bytes`、`frozenset`

name = "A" 后再写 name = "B"，是让名字绑定到另一个字符串，不是修改原字符串。

元组固定的是它直接保存的对象引用，内部列表仍然可以修改：

代码块 Python

1
2
3
4
5


record = ([1, 2], "fixed")
record[0].append(3)
print(record)

# 输出：([1, 2, 3], 'fixed')

record[0] = [] 则是在替换元组中的引用，会触发 TypeError。见对象与可变性。

2. `==` 与 `is` 有什么区别？小整数缓存能当判断依据吗？

答：== 判断是否相等；is 判断是不是同一个对象。 相等规则由类型定义，不一定只是逐字段比较。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


left = [1, 2]
right = [1, 2]
alias = left
print(left == right)
print(left is right)
print(left is alias)

# 输出：
# True
# False
# True

值比较：数值、字符串等业务内容通常使用 ==。
单例判断：判断空值使用 value is None。
缓存误区：整数复用、字符串驻留可能让两个名字碰巧指向同一对象；具体表现受实现、版本和编译方式影响。

不要用一次整数或字符串的 is 结果，推导值相等的通用规则。 id() 在对象存活期间标识身份，对象销毁后其标识可能被复用。

3. 字典键为什么不能是列表？元组一定能当键吗？

答：字典键和集合元素要求可哈希，不是简单要求“看起来不可变”。

可哈希：哈希值在对象生命周期内保持稳定；相等对象必须有相同哈希值。
列表、字典、普通集合：不可哈希，不能直接当键。
元组：只有内部所有元素都可哈希，整个元组才可哈希。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


mapping = {(1, 2): "ok"}
print(mapping[(1, 2)])

try:
 hash(([1, 2],))
except TypeError as error:
 print(f"TypeError: {error}")

# 输出：
# ok
# TypeError: unhashable type: 'list'

哈希相同不等于对象相等，哈希冲突仍要继续判断相等性。普通自定义对象也可能按身份哈希，不能把可哈希与不可变完全画等号。见可哈希定义。

4. 赋值、浅拷贝、深拷贝分别复制了什么？

答：赋值只是多一个名字指向原对象；浅拷贝新建外层容器，内部对象仍共享；深拷贝还会复制内部可变对象。

以订单为例：status 是字符串，items 是商品列表。复制后，分别修改状态和商品：

代码块 Python

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


import copy

order = {"status": "new", "items": ["book"]}
alias = order
shallow = copy.copy(order)
deep = copy.deepcopy(order)

# 改浅拷贝字典里的状态，不会改原字典的状态。
shallow["status"] = "paid"
# 但两份字典里的 items 仍指向同一个列表。
shallow["items"].append("pen")

print(alias is order)
print(order)
print(shallow)
print(deep)

# 输出：
# True
# {'status': 'new', 'items': ['book', 'pen']}
# {'status': 'paid', 'items': ['book', 'pen']}
# {'status': 'new', 'items': ['book']}

赋值：alias 和 order 是同一份订单，不是两份副本。
浅拷贝：shallow 是另一个字典，所以替换 status 互不影响；但 items 列表没复制，追加商品会让原订单也看到 pen。
深拷贝：deep 连商品列表也单独复制了，因此仍只有 book。普通字典的 order.copy() 也是浅拷贝。

深拷贝不保证每个内部对象都重新创建，也不能复制任意文件或 socket 资源。 它还会保留副本内部原有的共享关系；是否需要它，取决于业务是否允许共享。见 copy。

5. 列表、字典、集合操作都是 O(1) 吗？

答：不是，要说清具体操作，以及平均、最坏还是摊销复杂度。 下表针对常见 CPython 实现，假设一次哈希或元素比较的成本为常数：

操作	常见复杂度
列表按索引读取	O(1)
列表尾部 `append()`	摊销 O(1)，扩容时可能 O(n)
列表头部插入、`pop(0)`	O(n)，需要移动后续元素
`item in list`	O(n)
字典按键查找、集合成员判断	平均 O(1)，最坏 O(n)
取长度为 k 的列表切片	O(k)，会创建新列表

字典中的 x in mapping 查的是键，不是值。两端频繁进出的队列可考虑 collections.deque，不要反复使用列表 pop(0)。见 CPython 操作复杂度与 deque。

函数与作用域

6. 为什么不要用 `items=[]` 作为常规默认参数？

答：默认值在函数定义时求值，不是每次调用时重新创建。 多次省略这个参数，会复用同一个默认列表。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


def collect(value, items=[]):
 items.append(value)
 return items


print(collect("A"))
print(collect("B"))

# 输出：
# ['A']
# ['A', 'B']

为什么第二次不是 ['B']？ 按执行顺序看：

执行 def 时创建默认列表 []，并把它保存在函数的默认参数中。
第一次调用 collect("A") 没传 items，使用这个列表；追加后，它变成 ['A']。
第二次调用 collect("B") 也没传 items，用的还是刚才的列表；继续追加，便得到 ['A', 'B']。

函数调用结束后，默认列表没有被清空；下次调用也不会重新执行参数位置的 []。

每次都需要新列表时，用 None 表示“没有传入”，把创建列表的语句放到函数体内：

代码块 Python

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


def collect(value, items=None):
 if items is None:
 items = []
 items.append(value)
 return items


print(collect("A"))
print(collect("B"))

# 输出：
# ['A']
# ['B']

这次每次省略 items 都会进入 if，执行 items = []，因此两次调用各有自己的列表。

不要用 items = items or [] 替代上面的判断：调用方传入空列表时，它也会被换掉。见默认参数。

7. `global` 与 `nonlocal` 有什么区别？

答：两者都能让函数内的赋值作用于外层名字，但指向的作用域不同。

global name：给当前模块的全局变量 name 赋值，不是修改外层函数的局部变量。
nonlocal name：给最近一层外部函数中已有的变量 name 赋值；不能指向模块全局变量，也不能凭空创建外层变量。

只读取这些变量时，通常不需要声明。见名称解析。

8. 循环创建的 lambda，为什么都返回最后一个值？

答：三个函数共享同一个外层变量；创建函数时没有保存当轮值，调用时才读取它。

代码块 Python

1
2
3
4
5
6
7
8


late = [lambda: i for i in range(3)]
bound = [lambda i=i: i for i in range(3)]
print([function() for function in late])
print([function() for function in bound])

# 输出：
# [2, 2, 2]
# [0, 1, 2]

lambda: i：循环结束时，共享的 i 是 2；之后三个函数都读取它。
lambda i=i: i：右边的 i 在创建函数时求值，分别存为参数默认值；调用时返回各自参数。

这是闭包的晚绑定现象，不是 lambda 独有；普通嵌套函数也会遇到。默认参数保存的是对象引用，不是深拷贝快照。见闭包常见问题。

9. `*args`、`**kwargs`、`/`、单独的 `*` 有什么区别？

答：前两者收集多余参数，后两者限制参数的传入方式。

定义中的写法	含义
`*args`	收集额外位置参数，得到元组
`**kwargs`	收集额外关键字参数，得到字典
`/` 前的参数	只能按位置传入
单独的 `*` 后的参数	只能按关键字传入

代码块 Python

1
2
3
4
5
6
7


def describe(name, /, *, enabled=True):
 return f"{name}: {enabled}"


print(describe("worker", enabled=False))

# 输出：worker: False

这里 name 不能写成关键字参数，enabled 不能按位置传入。调用时的 *values、**options 则是解包，不是收集。见特殊参数。

10. 装饰器做了什么？`wraps` 又有什么用？

答：装饰器接收原函数，返回一个替代它的对象；常见做法是返回包装函数，在原函数前后增加行为。

下面为问候函数加一条调用日志，原函数本身不需要写日志逻辑：

代码块 Python

 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 functools import wraps


def log_call(function):
 @wraps(function)
 def wrapper(name):
 print("正在生成问候语")
 return function(name)
 return wrapper


@log_call
def greet(name):
 """生成问候语。"""
 return f"你好，{name}！"


print(greet("小李"))
print(greet.__name__)
print(greet.__doc__)

# 输出：
# 正在生成问候语
# 你好，小李！
# greet
# 生成问候语。

分两步理解：

定义时包装：@log_call 相当于定义后执行 greet = log_call(greet)。原函数保存在 function 中，名字 greet 改为指向返回的 wrapper。
调用时执行：greet("小李") 实际先进入 wrapper，打印日志，再调用原函数，最后把问候语返回给外面的 print()。

wraps 保留的是原函数的名称、文档等信息，不负责调用原函数。 本例删掉 @wraps(function) 后，问候功能仍能运行，但 greet.__name__ 变成 wrapper，greet.__doc__ 变成 None。

示例只包装一个 name 参数；通用包装器常用 *args, **kwargs 转交参数。本例使用闭包，但装饰器并不必须用闭包实现。见 functools.wraps。

迭代与生成器

11. 可迭代对象、迭代器、生成器是什么关系？

答：可迭代对象能提供迭代器；迭代器记住下一项读到哪里；生成器是一种自动保存执行进度的迭代器。

先看列表与迭代器： 列表保存任务内容；iter(tasks) 创建一个读取它的迭代器，next() 每次取下一项。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


tasks = ["整理需求", "编写代码"]
iterator = iter(tasks)
print(next(iterator))
print(next(iterator))
print(next(iterator, "任务已读完"))

# 输出：
# 整理需求
# 编写代码
# 任务已读完

tasks 是可迭代对象，但不是迭代器：不能直接 next(tasks)，要先 iter(tasks)。
iterator 是迭代器：第一次取完“整理需求”，它记住位置，下一次继续取“编写代码”。读完后不会自动回到开头。

再看生成器： 不先写出整个列表，而是用 yield 描述每一步要交出什么。

代码块 Python

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


def make_tasks():
 yield "整理需求"
 yield "编写代码"


generator = make_tasks()
print(next(generator))
print(next(generator))
print(next(generator, "任务已读完"))

# 输出：
# 整理需求
# 编写代码
# 任务已读完

make_tasks 是生成器函数，调用后得到的 generator 才是生成器对象。每次 next() 运行到一个 yield 并暂停，下次从暂停处继续，不从函数开头重跑。

生成器是迭代器，迭代器也可迭代；但列表可迭代，不代表列表本身就是迭代器。

读完之后：不带默认值的 next() 会抛出 StopIteration；for 自动处理这个结束信号。列表可以重新 iter(tasks) 从头读，但同一个迭代器或生成器不能自动重置。见迭代器协议。

12. 列表推导式与生成器表达式，差别只是括号吗？

答：列表推导式立即构建结果列表；生成器表达式按需计算，结果流通常只能消费一次。

代码块 Python

1
2
3
4
5
6
7
8
9


squares = (number ** 2 for number in range(3))
print(next(squares))
print(list(squares))
print(list(squares))

# 输出：
# 0
# [1, 4]
# []

需要索引、长度或多次遍历：数据量允许时使用列表。
逐项处理、可能提前结束：可使用生成器，避免预先保存全部结果。
不能过度推断：惰性不保证更快、零内存或不持有大对象；保留的状态和资源同样占用内存。

生成器表达式也不是“创建时什么都不执行”：最左侧 for 的可迭代表达式会立即求值，并立即取得迭代器。见生成器表达式。

13. `yield` 与 `yield from` 的区别是什么？

答：yield value 把这个值整体交出去；yield from iterable 把其中的元素逐项交出去。 比如，一次交出“整份任务清单”，还是“一条任务”？

代码块 Python

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


def task_list():
 yield ["整理需求", "编写代码"]


def each_task():
 yield from ["整理需求", "编写代码"]


print("使用 yield：")
for item in task_list():
 print(item)

print("使用 yield from：")
for item in each_task():
 print(item)

# 输出：
# 使用 yield：
# ['整理需求', '编写代码']
# 使用 yield from：
# 整理需求
# 编写代码

yield：只交出 1 项，这一项是整个列表，所以外面的 for 只执行一次，打印列表。
yield from：依次交出 2 项，分别是两个字符串，所以外面的 for 执行两次，每次打印一条任务。

仅就上例逐项交出元素而言，也可以用 for 循环逐项 yield。但完整语义不只是循环简写，它还支持对子生成器的 send() 等操作进行委托。

yield from 接受可迭代对象，不只接受生成器；它不会自动递归展开任意嵌套。 完整委托规则见 PEP 380。

14. `next()` 与生成器的 `send()` 有什么区别？

答：next() 让生成器继续执行；send(value) 在继续执行的同时，还向上次暂停的位置传入一个值。 用“提出问题，再收到答案”来理解：

代码块 Python

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


def ask_name():
 name = yield "你叫什么名字？"
 yield f"你好，{name}！"


conversation = ask_name()
print(next(conversation))
print(conversation.send("小明"))

# 输出：
# 你叫什么名字？
# 你好，小明！

先提出问题：next(conversation) 执行到 yield "你叫什么名字？"，把问题交给外部并暂停，此时 name 还没赋值。
再收到答案：send("小明") 把“小明”送回暂停处，完成 name = "小明"，然后继续执行到下一个 yield，把“你好，小明！”交给外面的 print()。

yield 后面的内容是向外发出的值；send() 传入的内容是恢复执行时收到的值。两者不是一回事。

对生成器，next(generator) 相当于 generator.send(None)；本例第二次如果也用 next()，name 收到的就是 None，而不是姓名。

先启动，再发送答案：刚创建时要先用 next() 或 send(None)，不能直接发送“小明”。见生成器方法。

表达式与数据

15. `eval()` 与 `json.loads()` 能互相替代吗？

答：不能。一个求值 Python 表达式，一个解析 JSON 数据。

方法	用途	关键边界
`eval()`	求值 Python 表达式	可调用函数、执行代码，不能用于不可信输入
`json.loads()`	JSON 文本转 Python 对象	不执行 Python 表达式；结果不一定是字典
`ast.literal_eval()`	解析受限的 Python 字面量和容器	不支持任意表达式，也不是无条件安全的解析器

代码块 Python

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


import ast
import json

# 这里只演示写死的可信表达式，不接收用户输入。
print(eval("1 + 2"))
print(json.loads('{"enabled": true, "note": null}'))
print(ast.literal_eval("[1, (2, 3)]"))

# 输出：
# 3
# {'enabled': True, 'note': None}
# [1, (2, 3)]

语法不同：JSON 字符串和对象键使用双引号，布尔和空值写 true、false、null；Python 写 True、False、None。
用途不同：外部 JSON 数据使用 JSON 解析器；已知目标类型时使用 int()、float() 等，不要绕到 eval()。
安全边界：JSON 仍需限制输入大小并校验结构；literal_eval() 对恶意输入也可能耗尽内存、CPU 或栈。

“不执行 Python 表达式”不等于“任意输入都安全”。 见 eval、json与 literal_eval。

16. 为什么 `0.1 + 0.2 != 0.3`？换成 Decimal 就全精确了吗？

答：许多十进制小数不能被二进制浮点数精确表示；Decimal 也有运算精度和舍入规则。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import math
from decimal import Decimal

print(0.1 + 0.2 == 0.3)
print(math.isclose(0.1 + 0.2, 0.3))
print(Decimal("0.1") + Decimal("0.2") == Decimal("0.3"))

# 输出：
# False
# True
# True

近似比较：math.isclose() 根据相对容差和绝对容差判断是否足够接近；接近零时尤其要按业务设置 abs_tol。
十进制计算：优先从字符串构造 Decimal，避免先把 float 的误差带进去。
仍需规则：无限循环小数、除法和金额取舍仍涉及精度与舍入；不能承诺所有结果无限精确。

见浮点数说明、math.isclose与 decimal。

17. `if not value` 与 `value is None` 是一回事吗？

答：不是。前者判断假值，后者只判断是否为 None。

None、False、数值零和空容器通常都是假值；自定义对象还可以通过 __bool__() 或 __len__() 定义真值。

代码块 Python

1
2
3
4
5
6
7


value = 0
print(not value)
print(value is None)

# 输出：
# True
# False

当 0、空字符串或空列表也是合法输入时，不要用 if not value 统统当作“未传入”。见真值测试。

18. `and`、`or` 的返回值一定是布尔值吗？

答：不一定；它们短路求值，返回某个操作数本身。 not 才总是返回布尔值。

代码块 Python

1
2
3
4
5
6
7
8


print("" or "默认值")
print(0 and "不会取到这里")
print("已启用" and 7)

# 输出：
# 默认值
# 0
# 7

a or b：a 为真就返回 a，否则才求值并返回 b。
a and b：a 为假就返回 a，否则才求值并返回 b。

因此 value or default 会替换所有假值，不只替换 None；&、| 是另一组运算符，不能随意拿来替代短路逻辑。见布尔运算。

19. `list.sort()` 与 `sorted()` 有什么区别？排序稳定是什么意思？

答：sort() 原地修改列表并返回 None；sorted() 接受可迭代对象，返回新列表。

代码块 Python

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


values = [3, 1, 2]
ordered = sorted(values)
print(values)
print(ordered)
print(values.sort())
print(values)

# 输出：
# [3, 1, 2]
# [1, 2, 3]
# None
# [1, 2, 3]

稳定排序指排序键相等的元素，保持原来的相对次序。两者都稳定，也都支持 key=；不是说“无论输入怎样，整个输出顺序都不变”。见排序指南。

20. `str` 与 `bytes` 有什么区别？编码与解码怎么记？

答：str 表示 Unicode 文本，bytes 表示字节序列；编码是文本转字节，解码是字节转文本。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


text = "你好"
data = text.encode("utf-8")
print(len(text))
print(len(data))
print(data.decode("utf-8"))

# 输出：
# 2
# 6
# 你好

Python 3 的 str 没有 .decode()；文件或网络读到的字节则可以按对应编码解码。len(str) 数的是 Unicode 码点，不是字节数，也不保证等于屏幕上看到的字符个数。见 Unicode HOWTO。

类与异常

21. 类属性与实例属性有什么区别？为什么多个实例共用一个列表？

答：类属性放在类上；实例属性属于具体实例。 把可变默认数据直接放在类体里，多个实例可能通过类属性访问到同一个对象。

代码块 Python

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


class Bag:
 items = []


first = Bag()
second = Bag()
first.items.append("A")
print(second.items)

# 为 first 创建同名实例属性；不会替换类上的 items。
first.items = ["B"]
print(first.items)
print(second.items)

# 输出：
# ['A']
# ['B']
# ['A']

这里 append() 修改共享列表，赋值则为 first 建立同名实例属性。需要每个实例独立的列表时，在 __init__() 中写 self.items = []。 见类变量与实例变量。

22. `new()` 与 `init()` 都是构造函数吗？

答：__new__() 负责创建或取得实例，__init__() 负责初始化实例。

__new__(cls, ...)：先执行，通常创建新实例，也可以返回已有实例；定制不可变类型的子类时可能需要它。
__init__(self, ...)：在适当的实例创建后执行，设置属性；必须返回 None，不能返回另一个对象。
容易漏掉的条件：如果 __new__() 返回的不是所请求类的实例，就不会按通常流程调用该类的 __init__()。

日常业务类通常只实现 __init__()，不必为了“完整”同时重写两个方法。见对象创建与初始化。

23. `super()` 就是“调用父类”吗？MRO 是什么？

答：super() 沿 MRO 查找下一个实现，不一定是源码里直觉上的某个父类。 MRO 是方法解析顺序。

例如 B、C 都继承 A，D 按 B, C 的顺序继承两者，常见菱形结构的顺序是：D → B → C → A → object。

在这个结构中，B 的协作式方法调用 super()，下一站可能是 C，而不是 A。
参与同一调用链的方法应使用兼容的参数，并协作调用 super()；不要随意混入写死类名的调用，导致跳过或重复执行。
Python 使用 C3 方法解析顺序；无法形成一致顺序的继承关系，会在建类时出错。

继承不是代码复用的唯一方式：对象“拥有另一个对象”时，组合通常更直接。见 super与多重继承。

24. `@dataclass(frozen=True)` 就彻底不可变了吗？类型标注会自动校验吗？

答：都不是。frozen=True 阻止常规字段赋值，不会递归冻结字段指向的对象；类型标注通常不做运行时校验。

代码块 Python

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


from dataclasses import dataclass, field


@dataclass(frozen=True)
class Config:
 # 每个实例单独创建一个列表。
 ports: list[int] = field(default_factory=list)


config = Config()
config.ports.append(8000)
print(config.ports)

# 输出：[8000]

config.ports = [] 是替换字段，会触发 FrozenInstanceError；append() 修改的是内部列表，所以仍能执行。
list[int] 表达预期类型，不会自动拦截所有错误数据；外部输入仍需显式验证或使用验证工具。
数据类主要减少 __init__()、__repr__()、相等比较等重复代码；它不是自动的数据校验框架。

见 dataclasses与类型标注的运行时边界。

25. `try`、`except`、`else`、`finally` 按什么顺序执行？

答：try 放可能失败的操作，except 处理匹配异常，else 处理正常完成，finally 做退出前清理。

代码块 Python

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


def parse(text):
 try:
 value = int(text)
 except ValueError:
 print("转换失败")
 else:
 print(value + 1)
 finally:
 print("清理")


parse("2")
parse("x")

# 输出：
# 3
# 清理
# 转换失败
# 清理

else：try 正常执行到末尾时运行；异常或提前 return、break、continue 都会跳过它。
finally：正常离开、返回或异常传播前都会执行，但进程被强制终止等情况不在这套正常控制流保证内。
异常捕获：尽量捕获具体异常；裸 except: 还会接住 KeyboardInterrupt、SystemExit 等，不适合一概吞掉。

不要在 finally 中 return：它可能覆盖原返回值，甚至压掉原异常。 Python 3.14 还会对相关跳出 finally 的控制流发出 SyntaxWarning。见 try 语义与 3.14 变化。

26. `with` 只是自动关闭文件吗？会不会吞异常？

答：with 使用上下文管理协议；做什么清理、是否抑制异常，由具体管理器决定。

进入：调用 __enter__()，它的返回值交给 as 后面的变量。
退出：__enter__() 成功后，离开代码块时调用 __exit__()，并传入异常信息。
异常：__exit__() 返回真值可以抑制块内异常；不是所有 with 都会吞异常。

文件管理器会关闭文件，锁管理器会释放锁；数据库事务管理器则可能只提交或回滚，不一定关闭连接。

用 @contextmanager 简化实现时，通常编写一个正常路径恰好 yield 一次的生成器函数，不是给任意普通函数加装饰器就能使用。见官方 with 语句说明与 contextmanager。

27. 能用 `assert` 校验用户输入或权限吗？

答：不能把 assert 当成必须执行的校验。 使用 python -O 时，断言及其表达式可能被移除。

内部假设检查：开发阶段可以使用断言，帮助尽早暴露程序逻辑错误。
必需的业务校验：明确写条件判断，并使用 raise ValueError(...) 等异常报告问题。
副作用：不要把必须执行的写入、函数调用或状态变更放在断言表达式里。

测试框架有自己的断言机制，也不能据此推导线上 assert 永远有效。见 assert 语义。

运行时与并发

28. `del` 会立即释放对象吗？循环引用一定导致内存泄漏吗？

答：del name 删除名字绑定，不等于直接销毁对象；循环引用也不等于必然泄漏。

代码块 Python

1
2
3
4
5
6


data = [1]
alias = data
del data
print(alias)

# 输出：[1]

alias 还引用这个列表，所以它仍然可用。

常规 CPython：主要使用引用计数，并由循环垃圾检测处理引用环中的垃圾；仅靠引用计数无法处理所有环。
不要依赖时机：何时回收不是 Python 语言统一保证；调试器、全局容器等还可能继续持有引用。
资源另行管理：内存回收与文件、连接释放不是一回事，资源应使用 with 或显式关闭。

见垃圾回收接口。本题不要求背诵某个补丁版本的具体分代数量。

29. 有 GIL 为什么还要加锁？Python 3.13 以后没有 GIL 了吗？

答：GIL 不是业务原子性保证；升级版本也不代表默认关闭 GIL。

常规启用 GIL 的 CPython：同一解释器内，同一时刻通常只有一个线程执行 Python 字节码；I/O 等待和释放 GIL 的扩展计算是不同情况。
业务同步：检查库存再扣减等多步操作仍需保护；不要把 count += 1 或某次实验结果当作跨版本线程安全保证。
版本变化：3.13 提供实验性 free-threaded 构建；3.14 正式支持，但仍是可选构建，依赖库兼容性需要核对。

有无 GIL，都要根据共享数据的操作边界决定是否同步。 见线程与 GIL与 free-threaded 支持状态。

30. 线程、进程、协程怎么选？多进程会共享全局变量吗？

答：先判断瓶颈和接口类型，再选择并发方式；普通进程的全局变量不会自动同步。

场景	通常考虑	主要代价
阻塞 I/O 等待	线程池	共享状态同步、线程调度
可拆分的纯 Python CPU 计算	默认 CPython 下的进程池	启动、序列化、进程间通信
大量使用异步接口的 I/O 等待	`asyncio`	不能长时间阻塞事件循环

并发不等于并行，也不保证更快。 小任务可能被调度成本拖慢；会释放 GIL 的扩展计算也不必一概使用多进程。

进程启动方式还影响初始状态： spawn 启动新解释器，fork 从当前进程派生，forkserver 从专用服务器派生；无论哪种，子进程修改普通对象都不会自动更新父进程。

Windows、macOS 默认使用 spawn；Linux 等支持平台在 3.13 通常默认 fork，3.14 改为 forkserver。显式指定方式，统一的是启动机制，不是各平台性能。任务数据优先通过参数和返回值交换。见进程启动方式。

31. 写了 `async def` 和 `await`，任务就自动并发了吗？

答：没有。调用协程函数只得到协程对象；连续等待两个调用，通常仍是先后执行。

要让多个任务有机会并发推进，先调度它们。例如 Python 3.11 起可以使用 TaskGroup：

代码块 Python

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


import asyncio


async def label(name):
 # 仅模拟异步等待，不访问网络，也不做性能测试。
 await asyncio.sleep(0.01)
 return name


async def main():
 async with asyncio.TaskGroup() as group:
 first = group.create_task(label("A"))
 second = group.create_task(label("B"))
 # 两项均已完成，按固定顺序读取结果。
 print([first.result(), second.result()])


asyncio.run(main())

# 输出：['A', 'B']

await 不是强制切换开关：所等待对象实际挂起时，事件循环才有机会推进别的任务。
阻塞操作不会自动变异步：在事件循环中执行 time.sleep()、阻塞网络调用或长时间计算，仍会卡住其他任务。
运行环境：脚本用 asyncio.run()；已有事件循环的交互环境通常直接 await main()，不要嵌套启动。

见协程与任务。完整并发实践留给独立文章，本篇只保留面试辨析要点。

Python 3 进阶速查

Sun, 11 Oct 2026 15:02:24 +0800

版本：示例以 Python 3.13 为基线，3.14 的关键差异单独标注。每个 Python 代码块可独立运行；进程池示例需保存为 .py 文件。

基础语法、容器和文件操作见 Python 3 基础速查。这里重点复习语言机制、并发选型及网络通信边界，不展开框架部署和完整服务器实现。

1. 闭包：保留外层变量

函数也是对象，可以作为参数、返回值或回调。闭包让内部函数继续访问外层函数的变量，即使外层调用已经结束。

读取外层变量：通常不需要额外声明。
重新绑定外层变量：使用 nonlocal，目标必须是外层函数中已有的绑定。
返回内部函数：是保留闭包的常见方式，不是闭包定义的必要条件。

代码块 Python

 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


# 模块级变量，与 make_counter() 内部的 count 是两个不同的绑定。
count = 100


def make_counter(start=0):
 count = start

 def increment():
 # 更新外层 make_counter() 的 count，而不是模块级的 count。
 nonlocal count
 count += 1
 return count

 return increment


counter = make_counter(10)
print(counter())
print(counter())
print(count)

# 输出：
# 11
# 12
# 100

nonlocal 与 global 改的是哪一个变量？

声明	重新赋值的目标
`nonlocal count`	最近一层外部函数中已经存在的 `count`；本例是 `make_counter()` 中的计数
`global count`	当前模块的全局 `count`；本例是最上面的 `count = 100`

这里需要让计数器从 10 累加，因此使用 nonlocal，模块级的 count 仍为 100。

不声明：本例的 count += 1 会被当作局部赋值，但右侧又先读取这个尚未赋值的局部变量，因此触发 UnboundLocalError。
换成 global count：会修改模块级变量，不能用它代替 nonlocal 更新外层函数的状态。

nonlocal 在 Python 3.8～3.10 中同样适用，并非 3.13 的新写法。见作用域声明。

循环中的闭包为什么容易出错？

先分清：这里的列表装的是三个函数，不是三个计算结果。 列表推导式创建函数时，并没有执行 lambda 的函数体。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


functions = [lambda: i for i in range(3)]
print([function() for function in functions])

# 默认参数在创建函数时求值，用它保存每轮的整数值。
functions = [lambda i=i: i for i in range(3)]
print([function() for function in functions])

# 输出：
# [2, 2, 2]
# [0, 1, 2]

第一种：三个函数，读取的是同一个 i。

创建函数：第一行循环三次，创建三个不同的 lambda 函数。它们都关联同一个变量 i，没有把当轮的 0、1、2 分别保存下来。
循环结束：i 依次取过 0、1、2，最终停在 2；此时三个函数都还没被调用。
调用函数：第二行的 function() 才执行函数体。三个函数都去读取那个 i，读到的都是 2，所以结果是 [2, 2, 2]。

第二种：lambda i=i: i，用默认参数保存每轮的值。

= 左边的 i 是函数参数名；右边的 i 是创建函数时读取的当前循环值。
三个函数的默认参数分别是 0、1、2；冒号后的 i 返回各自的参数值。
function() 不传参数，就使用保存的默认值，因此得到 [0, 1, 2]。

回调需要“记住当时的值”时，要显式绑定，不能只看函数写在哪一轮循环里。 见官方闭包常见问题。

2. 装饰器：包装调用，而不改函数正文

@decorator 可以理解为：函数定义完成后，执行 function = decorator(function)。

装饰器接收被装饰对象，并用返回值重新绑定原名称。它不一定是闭包，也可以由类或可调用实例实现；日常先掌握函数写法即可。见函数定义与装饰器。

2.1 参数、返回值与元数据都要保留

代码块 Python

 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 functools import wraps


def trace(function):
 @wraps(function)
 def wrapper(*args, **kwargs):
 print(f"调用 {function.__name__}")
 return function(*args, **kwargs)

 return wrapper


@trace
def add(left, right=0):
 """返回两个数的和。"""
 return left + right


print(add(2, right=3))
print(add.__name__)
print(add.__doc__)

# 输出：
# 调用 add
# 5
# add
# 返回两个数的和。

*args, **kwargs：接收并转交位置参数和关键字参数。
return：把原函数的结果交还调用方；漏写会得到 None。
@wraps(function)：保留名称、文档等元数据，并通过 __wrapped__ 提供原函数引用；不会自动保证包装逻辑正确。见 functools.wraps。

如果只删除上例中的 @wraps(function)，其余代码不变，输出会变成：

代码块 Text

1
2
3
4


# 调用 add
# 5
# wrapper
# None

装饰后，名称 add 实际绑定到 wrapper。不使用 wraps 时，add.__name__ 和 add.__doc__ 展示的是包装函数自己的信息；本例的 wrapper 没写文档字符串，所以文档值是 None。

加法结果仍为 5：wraps 保留的是元数据，不是负责计算的部分。

这个例子面向普通同步函数。若要在异步函数实际执行前后添加逻辑，应使用 async def 包装器并 await 原函数。

2.2 带参数的装饰器与叠加顺序

@label("外层") 先调用 label() 得到装饰器，再把目标函数传给它。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


from functools import wraps


def label(name):
 def decorate(function):
 @wraps(function)
 def wrapper(*args, **kwargs):
 print(f"进入{name}")
 result = function(*args, **kwargs)
 print(f"离开{name}")
 return result

 return wrapper

 return decorate


@label("外层")
@label("内层")
def greet():
 return "你好"


print(greet())

# 输出：
# 进入外层
# 进入内层
# 离开内层
# 离开外层
# 你好

装饰时由内向外组合，相当于 label("外层")(label("内层")(greet))。

调用时的顺序由包装器决定：本例先进入外层，返回时先离开内层。不要把“装饰顺序”和“函数调用顺序”混为一谈。

2.3 `call` 与类实现的装饰器

类实现 __call__() 后，它的实例也能像函数一样调用。下面用一个实例保存原函数和调用次数：

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


from functools import update_wrapper


class CountCalls:
 def __init__(self, function):
 update_wrapper(self, function)
 self.function = function
 self.calls = 0

 def __call__(self, *args, **kwargs):
 self.calls += 1
 return self.function(*args, **kwargs)


@CountCalls
def add(left, right=0):
 return left + right


print(add(2, right=3))
print(add(4, 5))
print(add.calls)
print(add.__name__)

# 输出：
# 5
# 9
# 2
# add

装饰时：@CountCalls 相当于 add = CountCalls(add)，创建实例并保存原函数；此时还没有执行加法。
调用时：add(2, right=3) 调用这个实例的 __call__()，先累计次数，再转交参数并返回计算结果。
保存信息：update_wrapper() 保留原函数的名称、文档等元数据，与前面 wraps 的用途相同。

这里是用类来装饰函数，不是给类加装饰器。相比闭包写法，把调用次数等状态放在实例属性上更便于访问。

本例用于普通同步函数；这个可调用实例不会像普通函数那样，在作为类属性访问时自动绑定业务对象的 self，不能直接照搬来装饰实例方法。见 __call__、方法绑定与 update_wrapper。

3. property：让属性访问带上逻辑

property 适合计算属性或需要校验的赋值。普通字段不需要为了形式完整而再写一套 getter/setter。

3.1 装饰器写法

代码块 Python

 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


class Stock:
 def __init__(self, quantity):
 self.quantity = quantity

 @property
 def quantity(self):
 return self._quantity

 @quantity.setter
 def quantity(self, value):
 if value < 0:
 raise ValueError("库存不能为负数")
 self._quantity = value


stock = Stock(5)
stock.quantity = 3
print(stock.quantity)

try:
 stock.quantity = -1
except ValueError as error:
 print(f"ValueError: {error}")

# 输出：
# 3
# ValueError: 库存不能为负数

读取 stock.quantity：调用被 @property 修饰的方法，不加括号。
赋值 stock.quantity = 3：调用对应 setter；本例初始化也走同一条校验路径。
只有 getter：不能通过该属性赋值，但不代表整个对象不可变。

_quantity 是内部存储的命名约定，不是访问权限机制。上例仅演示非负校验，不代表已经验证所有输入类型。见 property。

3.2 `property(getter, setter)` 写法

也可以先定义读取和赋值方法，再用 property() 将它们组合成属性。下面与上一节的 quantity 属性具有相同的读取和校验行为：

代码块 Python

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


class Stock:
 def __init__(self, quantity):
 self.quantity = quantity

 def get_quantity(self):
 return self._quantity

 def set_quantity(self, value):
 if value < 0:
 raise ValueError("库存不能为负数")
 self._quantity = value

 quantity = property(get_quantity, set_quantity)


stock = Stock(5)
stock.quantity = 3
print(stock.quantity)

# 输出：3

这里传给 property() 的是 getter 和 setter 函数本身，不写 get_quantity() 或 set_quantity()。调用方仍然用 stock.quantity 读取，用 stock.quantity = 3 赋值。

两种写法实现的是同一种属性机制；这里的读取和赋值方法可以分别命名，不必都叫 quantity。只传 getter 时，该属性不支持赋值。

4. 上下文管理器：明确资源何时释放

with 的能力取决于对象实现的协议，不是所有 with 都表示“关闭文件”。

协议方法	作用
`__enter__()`	进入上下文；返回值绑定给 `as` 后的变量
`__exit__(exc_type, exc_value, traceback)`	退出上下文；接收异常信息，正常结束时三项均为 `None`
`__exit__()` 返回真值	表示抑制块内异常；返回 `None` 或 `False` 则继续传播异常

__enter__() 成功后，正常退出或因异常离开代码块都会调用 __exit__()。不要无意中返回 True 吞掉异常。 见官方 with 语句说明。

4.1 类式上下文管理器

下面用类管理一个内存文本流，故意在 with 内抛出异常，观察资源释放和异常传播的顺序：

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


from io import StringIO


class TextReader:
 def __init__(self, text):
 self.text = text

 def __enter__(self):
 self.reader = StringIO(self.text)
 return self.reader

 def __exit__(self, exc_type, exc_value, traceback):
 self.reader.close()
 return False


try:
 with TextReader("hello") as reader:
 print(reader.read())
 raise ValueError("读取中断")
except ValueError as error:
 print(f"ValueError: {error}")

print(reader.closed)

# 输出：
# hello
# ValueError: 读取中断
# True

进入：__enter__() 创建并返回文本流，因此 as reader 得到的是 StringIO 对象，不是 TextReader 实例。
退出：发生异常后，先调用 __exit__() 关闭流；它返回 False，异常继续传到外面的 except。

资源已关闭，不代表异常已被处理。 是否抑制异常由 __exit__() 的返回值决定；如果 __enter__() 本身失败，则不会调用这个对象的 __exit__()。见上下文管理器协议。

4.2 用 contextmanager 简化成对操作

@contextmanager 用于基于生成器的上下文管理，不是给任意函数加上它就能配合 with 使用。

被装饰函数调用后需要返回生成器迭代器；通常写成下面这种含 yield 的生成器函数。
普通只 return 一个字符串、列表等值的函数，不能直接套用这个装饰器。
正常进入并退出上下文时，生成器必须恰好 yield 一次，不能零次或多次。

代码块 Python

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


from contextlib import contextmanager
from io import StringIO


@contextmanager
def text_reader(text):
 # StringIO 是内存中的文本流，本例不创建磁盘文件。
 reader = StringIO(text)
 try:
 yield reader
 finally:
 reader.close()


with text_reader("hello") as reader:
 print(reader.read())

print(reader.closed)

# 输出：
# hello
# True

按执行顺序看这个例子：

进入 with：执行 yield 前的代码，创建文本流。
yield reader：把流交给 as reader，暂停生成器，执行 with 中的读取操作。
退出 with：恢复生成器，执行 finally，关闭文本流，所以最后输出 True。

这是协议演示；实际只使用 StringIO 时，可以直接 with StringIO(...) as reader。

如果捕获块内异常只是为了记录，应再次抛出，而不是静默结束。 见 contextlib.contextmanager。

5. 生成器：按需组合数据

生成器适合逐项处理，避免一次性构造全部中间结果。它不保证每种任务都更快，也不会自动缓存已产生的数据。

5.1 逐步读取，耗尽后不会重来

下面的输入有三组：[1, 2]、[3]、[]。这个函数按组依次取出数字，只展开一层。

代码块 Python

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


def flatten(groups):
 for group in groups:
 # 依次产出当前 group 的元素；空列表没有元素可产出。
 yield from group


numbers = flatten([[1, 2], [3], []])
# 只取第一个数字，生成器暂停在这里。
print(next(numbers))
# 从暂停处继续，将剩余数字收集成列表。
print(list(numbers))
# 已经读完，不会自动回到开头。
print(list(numbers))

# 输出：
# 1
# [2, 3]
# []

flatten(...) 创建生成器；next(numbers) 开始执行，从第一组取出 1。
第一次 list(numbers) 继续取出第一组剩余的 2，再取第二组的 3；第三组为空，所以得到 [2, 3]。
第二次 list(numbers) 时已经耗尽，得到 []。如需重新遍历，要重新调用 flatten(...) 创建生成器。

这里先理解“读取位置会向前推进”。yield 与 yield from 的完整差异留给后续易混淆点文章，不在此展开。见生成器官方说明。

5.2 数据流与资源生命周期分开

代码块 Python

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


from io import StringIO


def nonempty_lines(lines):
 for line in lines:
 text = line.strip()
 if text:
 yield text


with StringIO("第一行\n\n第二行\n") as source:
 for text in nonempty_lines(source):
 print(text)
 break

print(source.closed)

# 输出：
# 第一行
# True

本例由调用方的 with 管理文本流，生成器只处理数据；换成 open(..., encoding="utf-8") 时也是这个思路。

循环 break 不等于关闭生成器内部持有的文件。 如果资源是在生成器内部创建的，需要明确关闭生成器或安排上下文管理，不要依赖垃圾回收时机。

6. 赋值、浅拷贝与深拷贝

先看结构：original = [[1, 2], [3]] 是一个外层列表，里面装着两个子列表。

操作	复制了什么	修改子列表时会怎样
`alias = original`	不复制；只是给同一个列表增加名字	通过 `alias` 修改，就是修改原列表
`copy.copy(original)`	只新建外层列表，里面仍引用原来的两个子列表	修改共享子列表，会影响 `original`
`copy.deepcopy(original)`	新建外层列表，并复制这里面的两个子列表	修改副本中的子列表，不影响 `original`

浅拷贝也会创建新列表。区别在于：里面的子列表是否仍与原对象共享。

下面用 import copy 导入模块，copy.copy() 是浅拷贝，copy.deepcopy() 是深拷贝；对于本例的普通列表，original.copy() 也能做浅拷贝。

代码块 Python

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


import copy

original = [[1, 2], [3]]
alias = original
shallow = copy.copy(original)
deep = copy.deepcopy(original)

# shallow[0] 与 original[0] 是同一个子列表，两边都能看到新增的 9。
shallow[0].append(9)
# 只给 shallow 的外层列表加一项，不会给 original 的外层加项。
shallow.append([4])

print(alias is original)
print(shallow is original)
print(shallow[0] is original[0])
print(deep[0] is original[0])
print(original)
print(shallow)
print(deep)

# 输出：
# True
# False
# True
# False
# [[1, 2, 9], [3]]
# [[1, 2, 9], [3], [4]]
# [[1, 2], [3]]

对应上面的两次修改：

shallow[0].append(9) 修改共享的子列表，所以 original 和 shallow 都出现 9。
shallow.append([4]) 修改的是新的外层列表，所以只有 shallow 多出 [4]。
deep 的外层列表和子列表都与原列表分开，因此仍保持 [[1, 2], [3]]。

把深拷贝理解为“为这组嵌套列表建立独立副本”是合适的；但不能只概括成“重新申请一块内存”，否则无法区分浅拷贝，也容易误以为所有内部对象都必然重新创建。

是否深拷贝，取决于是否允许共享，而不是“有嵌套就必须复制”。 深拷贝有额外成本，也不保证每个对象都换成新对象；文件、socket 等资源不能靠它复制。见 copy。

Python 3.13：只替换部分字段

copy.replace() 适用于数据类、命名元组和实现 __replace__() 的类型；创建同类型的新对象，替换指定字段。

代码块 Python

 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 copy import replace
from dataclasses import FrozenInstanceError, dataclass


@dataclass(frozen=True)
class Config:
 host: str
 port: int


original = Config("localhost", 8000)
try:
 # frozen=True 禁止修改这个已有实例的字段。
 original.port = 9000
except FrozenInstanceError as error:
 print(f"FrozenInstanceError: {error}")

# 创建修改了 port 的新实例，原实例保持不变。
updated = replace(original, port=9000)
print(original)
print(updated)

# 输出：
# FrozenInstanceError: cannot assign to field 'port'
# Config(host='localhost', port=8000)
# Config(host='localhost', port=9000)

frozen=True 阻止常规字段赋值；replace() 则创建新实例。字段替换不是深拷贝，也不是任意对象都支持。 见 copy.replace。

dataclass 带不带括号有什么区别？

写法	对当前问题的影响
`@dataclass`	使用默认选项，默认 `frozen=False`，允许常规字段赋值
`@dataclass()`	与上一种等价，同样使用默认选项
`@dataclass(frozen=True)`	显式启用冻结，常规字段赋值会报错

不传选项时，有无括号不会改变行为；真正影响能否赋值的是 frozen。 这属于 dataclass 提供的两种用法，不能推广为所有装饰器都能省略括号。见 dataclass 的等价写法。

代码块 Python

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


from dataclasses import dataclass


@dataclass
class Config1:
 host: str
 port: int


# 实例化新定义的 Config1，不要误用前面冻结的 Config。
original1 = Config1("localhost", 8000)
original1.port = 9000
print(original1)

# 输出：Config1(host='localhost', port=9000)

上面两个示例定义了两个不同的类：Config 是冻结的，Config1 没有冻结。新定义 Config1，不会修改或替换原来的 Config。

把两个示例放在同一脚本里，对比这两种写法：

original1 = Config("localhost", 8000)：用的是前面冻结的 Config，因此修改 original1.port 会报错。
original1 = Config1("localhost", 8000)：用的是新定义的 Config1，因此可以修改 original1.port。

决定对象类型的是等号右边的类名；左边的 original1 只是接收对象的变量名。 给变量名加 1，不会自动改用 Config1。

上例的 @dataclass 换成 @dataclass() 也能正常赋值；这些写法在 Python 3.8～3.10 中已经可用，copy.replace() 才是这里的 3.13 新 API。

7. 正则表达式：选择正确的匹配范围

7.1 先选接口，再写模式

接口	主要用途
`re.fullmatch()`	校验整个字符串
`re.match()`	只从开头尝试匹配，不要求覆盖整串
`re.search()`	查找首个匹配位置
`re.findall()` / `re.finditer()`	获取多个匹配；后者逐个返回匹配对象
`re.sub()`	替换匹配内容
`re.split()`	按模式切分

模式通常写成 原始字符串 r"..."，减少 Python 字符串转义与正则转义的冲突。重复使用时可用 re.compile() 保存模式。见 re 官方文档。

代码块 Python

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


import re

# 自定义账号规则：小写字母开头，其后允许小写字母、ASCII 数字和下划线；总长 3～16。
account_pattern = re.compile(r"[a-z][a-z0-9_]{2,15}")
print(account_pattern.fullmatch("user_01") is not None)
print(account_pattern.fullmatch("user_01!") is not None)

match = re.search(r"order=(?P<number>[0-9]+)", "user=ada order=2048")
if match:
 print(match.group(0))
 print(match.group("number"))
 print(type(match.group("number")).__name__)

# 输出：
# True
# False
# order=2048
# 2048
# str

group("number") 为什么得到 2048？

order= 匹配这段固定文字。
[0-9]+ 匹配一个或多个 ASCII 数字，本例匹配到 2048。
(?P<number>...) 把括号内的匹配内容保存为名叫 number 的组。

group() 是匹配对象的方法。group(0) 取完整匹配，即 order=2048；group("number") 只取命名组中的数字文本，即字符串 "2048"。这里的 "number" 是组名，不是 Python 变量。

打印时字符串不会自动显示引号，返回值并不是整数。 后续要计算时再用 int() 转换。见 Match.group。

匹配失败返回 None，不能直接调用 .group()。

7.2 常用语法与边界

写法	含义
`[a-z]` / `[^a-z]`	字符集合 / 排除集合
`.`	默认匹配换行以外的字符
`*` / `+` / `?`	前项重复 0 次以上 / 1 次以上 / 0 或 1 次
`{m,n}`	前项重复 m 到 n 次
`(abc)` / `(?P<name>abc)`	捕获组 / 命名捕获组
`.*?`	非贪婪重复；优先尝试较短的匹配

a|b 表示择一匹配；例如 cat|dog 可以匹配其中任意一项。

Unicode：str 模式默认按 Unicode 处理；\d 不只匹配 0–9，\s 不只空格和 Tab，\w 包含 Unicode 字母数字与下划线。
ASCII 数字：明确写 [0-9]；需要整体采用 ASCII 字符类规则时使用 re.ASCII。
整串校验：优先 fullmatch()；$ 还能匹配字符串末尾换行之前的位置，不能简单当成“绝对末尾”。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


import re

print(re.fullmatch(r"\d+", "１２３") is not None)
print(re.fullmatch(r"[0-9]+", "１２３") is not None)
print(re.sub(r"\s+", " ", "hello\t world"))

# 输出：
# True
# False
# hello world

正则适合局部文本规则，不适合代替 HTML、JSON 等格式的解析器。 对不受信任的长文本，还要避免可能导致大量回溯的复杂模式。

7.3 反向引用：再次匹配已捕获的内容

捕获组保存匹配到的文本；反向引用要求后面的文本与它相同。 例如，要求连字符两边是同一个英文单词：

代码块 Python

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


import re

print(re.fullmatch(r"([a-z]+)-\1", "python-python") is not None)
print(re.fullmatch(r"([a-z]+)-\1", "python-java") is not None)
print(re.fullmatch(r"(?P<word>[a-z]+)-(?P=word)", "python-python") is not None)

# 重复写两次相同的字符规则，并不要求两次匹配到的文本相同。
print(re.fullmatch(r"([a-z]+)-([a-z]+)", "python-java") is not None)

# 输出：
# True
# False
# True
# True

写法	引用的内容
`\1`	第 1 个捕获组匹配到的文本；捕获组按左括号顺序从 1 编号
`(?P=word)`	名为 `word` 的捕获组匹配到的文本

前两个例子中的 [a-z]+ 捕获了 python，后面的 \1 就必须再次匹配 python；两个独立的 [a-z]+ 则允许分别匹配 python 和 java。

反向引用参与匹配，match.group(1) 或 match.group("word") 则在匹配后取出文本。 数字反向引用配合原始字符串 r"..." 使用，避免 \1 先被 Python 当作字符串转义处理。见正则分组与反向引用。

8. 并发选型与 GIL

并发是多个任务在一段时间内交替推进；并行是同一时刻执行多个任务。两者不能按“任务数是否超过 CPU 核心数”来定义。

方式	通常适合	主要成本与约束
线程 / `ThreadPoolExecutor`	使用阻塞接口的 I/O 任务	共享内存，需要同步；控制工作线程数
进程 / `ProcessPoolExecutor`	默认 CPython 中可拆分的纯 Python CPU 计算	启动、序列化和通信有成本
`asyncio`	使用异步接口的大量 I/O 等待	协作式调度，不能在事件循环里长时间阻塞

并发不是免费的加速开关。 小任务可能因调度成本变慢；选择方式前先确认瓶颈。线程池与进程池接口见 concurrent.futures。

从 3.8～3.12 到 3.13 以后，GIL 有什么变化？

Python 3.8～3.12 的常规 CPython：已经有 GIL。同一解释器内，同一时刻通常只有一个线程执行 Python 字节码，因此纯 Python 重计算通常不能靠多线程利用多核提速。
Python 3.13：常规构建仍默认启用 GIL；另提供实验性的 free-threaded 构建，可以在禁用 GIL 时并行运行 Python 线程。
Python 3.14：free-threaded 正式支持，但仍是可选构建；第三方扩展兼容性仍需检查。

旧版本也能使用多线程处理 I/O 等待，某些释放 GIL 的扩展还可以并行计算。GIL 不是“Python 没有多线程”，也不是“线程永远不能使用多核”。 见 Python 3.12 的线程说明。

“升级 Python”不等于“默认关闭 GIL”；有无 GIL 都不能代替共享数据的业务同步。 见 free-threading 指南及 3.14 支持状态。

9. 线程：先启动，再等待；共享更新要加锁

代码块 Python

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


from threading import Lock, Thread

count = 0
lock = Lock()


def increment(times):
 global count
 for _ in range(times):
 # 两个线程必须使用同一把锁，保护完整的“读取、加一、写回”。
 with lock:
 count += 1


threads = [Thread(target=increment, args=(1000,)) for _ in range(2)]
for thread in threads:
 thread.start()

for thread in threads:
 thread.join()

print(count)

# 输出：2000

target=increment：传函数对象，不是 increment() 的执行结果。
args=(1000,)：一个元素的元组需要逗号；本例也可用 kwargs={"times": 1000} 传入命名参数。
start()：启动线程；直接调用 .run() 不会创建新线程。
join()：阻塞当前调用方，等待指定线程结束。本例已先启动两个线程，不会把它们变成串行任务。

不要用 sleep() 猜测另一个线程“应该做完了”。 等待完成用 join()，传递停止信号可用 Event，在线程间交接任务可用 queue.Queue。

with lock: 能在代码块结束时释放锁，避免漏写 release()；多把锁仍需统一获取顺序，防止死锁。上述行为见 threading。

daemon 线程可能在程序退出时被直接停止，不适合承担必须完成的保存或清理任务。 长期运行的工作线程应通过停止信号自行结束，再由主线程等待；有限任务直接等待完成即可。

10. 进程池：隔离内存，返回结果

进程各有独立的 Python 对象空间，修改子进程的普通全局变量，不会自动同步到父进程。优先通过任务参数与返回值交换数据；需要通信时再考虑队列等工具。

下面仅演示进程池接口，平方运算太小，实际通常不值得启动进程。保存为 process_demo.py 后运行：

代码块 Python

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


from concurrent.futures import ProcessPoolExecutor
from multiprocessing import get_context


def square(number):
 return number ** 2


if __name__ == "__main__":
 # 显式使用 spawn：启动新解释器，让示例跨平台行为更容易理解。
 context = get_context("spawn")
 with ProcessPoolExecutor(max_workers=2, mp_context=context) as executor:
 results = list(executor.map(square, [2, 3, 4]))
 print(results)

# 输出：[4, 9, 16]

不指定 spawn，为什么输出还是 [4, 9, 16]？

在 Mac 上，可能连启动方式都没变：macOS 从 Python 3.8 起默认就是 spawn；未另行配置时，显式指定相当于把默认值写出来。
这个任务看不出机制差异：平方运算只依赖传入的数字。即使换了启动方式，正常执行的结果也应相同；差异主要在子进程如何启动、带入哪些状态以及启动成本。

get_context("spawn") 选择启动方式，mp_context=context 让这个进程池使用它；不指定时使用默认方式。

三种启动方式，区别在哪里？

方式	如何启动子进程	关键差异
`spawn`	启动新解释器，重新导入所需模块	不直接继承父进程的完整运行时状态；启动成本通常较高
`fork`	直接从当前父进程派生	继承当时的内存状态；多线程父进程的锁等状态可能带来风险
`forkserver`	启动专用服务器，再由它派生工作进程	从通常为单线程的服务器派生，不直接从应用主进程派生

例如，父进程在运行中修改了某个全局变量：fork 子进程可从派生时的值开始；spawn 重新导入模块，不会自动得到这次修改。因此应通过参数传入任务需要的数据。 见启动方式与状态差异。

何时值得显式指定 spawn？ 应用需要固定跨平台启动方式，或依赖库明确要求使用它时。默认方式已满足需求，就不必额外指定；它也不是免费的加速选项。

显式指定统一的是启动机制，不保证各平台性能或所有行为相同。

为什么要这样组织？

工作函数放在模块顶层，不要用 lambda 或局部函数作为进程池任务。
入口保护避免新解释器导入模块时再次创建进程池；交互式环境不能照搬这个脚本示例。
参数、返回值及任务函数需要满足可序列化、可导入的要求；不要传打开的文件或锁来“共享一切”。

executor.map() 按输入顺序返回结果，不代表任务按此顺序完成。

需要逐个提交时，submit() 返回表示任务及其结果的 Future 对象；.result() 会等待结果，并在任务失败时重新抛出异常。见进程池文档。

进程启动方式的版本变化

平台	Python 3.13 默认	Python 3.14 默认
Windows、macOS	`spawn`	`spawn`
Linux 等支持 `forkserver` 的常见 POSIX 平台	`fork`	`forkserver`

不要脱离版本说“Linux 默认就是 fork”。 默认方式还可能被程序配置覆盖。见 3.13 启动方式、macOS 自 3.8 起的变化和 3.14 迁移说明。

terminate() 可能跳过清理，并影响正在使用的锁或队列；不要把强制结束当成常规退出方案。本例使用 ProcessPoolExecutor 的上下文管理，退出时会等待已提交任务完成。

11. asyncio：等待时让出执行机会

asyncio 通常在一个事件循环线程中协作调度任务；适合异步 I/O，不会把普通计算自动分配到多个 CPU 核心。

async def：定义协程函数；调用后得到协程对象，不会因此自动执行完。
await：等待可等待对象；发生挂起时，事件循环才能推进其他任务。
TaskGroup：Python 3.11 起提供的任务组，管理一组并发任务的生命周期。

代码块 Python

 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 asyncio


async def fetch_label(name):
 # 仅模拟一次异步等待，不访问网络，也不是性能测试。
 await asyncio.sleep(0.01)
 return f"完成 {name}"


async def main():
 async with asyncio.TaskGroup() as group:
 first = group.create_task(fetch_label("A"))
 second = group.create_task(fetch_label("B"))

 # 离开任务组后两项都已完成；按固定顺序读取结果。
 print(first.result())
 print(second.result())


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

# 输出：
# 完成 A
# 完成 B

两个容易混淆的点：

连续写 await fetch_label("A")、await fetch_label("B") 是依次等待；上例先创建两个任务，让它们并发推进。
任务组中出现非取消异常时，会取消其余任务并等待清理，通常以异常组报告失败；不要静默吞掉取消异常。见 TaskGroup。

事件循环里不要直接执行 time.sleep()、阻塞网络请求或长时间 CPU 循环。 阻塞 I/O 可按需交给 asyncio.to_thread()；纯 Python 重计算通常另选进程池。

脚本用 asyncio.run() 启动；Jupyter 等已有事件循环的环境通常直接 await main()，不要再嵌套调用 asyncio.run()。

12. TCP：传的是字节流，不是消息包

客户端主动连接，服务端监听并接受连接。accept() 返回的连接 socket 才用于与该客户端通信；监听 socket 继续负责接受新连接。

操作	必须记住的边界
`send(data)`	可能只发送部分字节，需要检查返回数量
`sendall(data)`	持续发送直到完成或报错；不表示对方业务已处理成功
`recv(n)`	最多接收 n 字节，不保证获得完整消息
`recv(n)` 返回 `b""`，且 n 大于 0	对方发送方向已结束，不是“暂时没有数据”

一次 send 不对应一次 recv；TCP 本身不保留应用消息边界。 实际协议需约定长度前缀、分隔符或结束连接等规则。见 Socket HOWTO。

只在本机运行的最小示例

下面发送一条很短的消息，用“关闭发送方向”表示消息结束。特意每次最多读 2 字节，演示为什么不能收到一块就立即解码中文。

代码块 Python

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


import socket

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
 # AF_INET 使用 IPv4；127.0.0.1 仅本机可访问，端口 0 由系统分配。
 server.bind(("127.0.0.1", 0))
 server.listen(1)
 server.settimeout(2)

 with socket.create_connection(server.getsockname(), timeout=2) as client:
 connection, _ = server.accept()
 with connection:
 connection.settimeout(2)
 client.sendall("你好".encode("utf-8"))
 client.shutdown(socket.SHUT_WR)

 chunks = []
 # := 将本次读取结果绑定到 chunk，同时检查是否到达流结束。
 while chunk := connection.recv(2):
 chunks.append(chunk)

print(b"".join(chunks).decode("utf-8"))

# 输出：你好

`:=` 海象运算符：赋值后，把值用于判断

:= 叫赋值表达式，也叫海象运算符，不是海马运算符；它在 Python 3.8 就已经引入。

写法	作用
`name = value`	赋值语句，保存值
`name := value`	保存值，同时把这个值作为表达式结果，可用于条件判断
`name == value`	比较是否相等，不赋值

一个不涉及网络的例子：

代码块 Python

1
2
3
4
5


text = "hello"
if (length := len(text)) > 3:
 print(length)

# 输出：5

括号里的表达式先把 5 保存到 length，再用 5 > 3 判断是否进入代码块。括号也明确了“先赋值，再比较”的分组。

回到 TCP 示例，while chunk := connection.recv(2): 每轮执行三步：

调用一次 recv(2)，最多读取 2 字节。
把读取结果保存到 chunk，随后判断这个字节串是否非空。
非空就执行 chunks.append(chunk)，再开始下一轮；读到 b"" 就结束循环。

它相当于把“读取、赋值、判断是否结束”合在循环条件里，不是重复读取两次，也不是判断相等。对于这里的 TCP 读取，b"" 表示对方发送方向结束，暂时没有数据时会等待或超时。见赋值表达式。

收包时还要注意：

先收齐，再解码：UTF-8 字符可能跨读取边界；长数据流也可使用增量解码器。
shutdown(SHUT_WR)：关闭发送方向，不等于立即关闭整个 socket。
with 和超时：分别负责关闭资源、限制阻塞等待；超时异常仍需由实际业务处理。

这里只发送几个字节，能在同一线程里完成演示；大数据双向通信需要双方持续收发，不能照搬这个发送完再接收的组织方式。API 细节见 socket。

本地练习绑定 127.0.0.1。 IPv4 中绑定空字符串或 0.0.0.0 会监听所有本地网络接口，不是“仅本机”。

13. HTTP：交给协议库处理

TCP 的可靠传输不等于安全传输，它本身不提供加密和身份认证。HTTPS 在 HTTP 通信中加入 TLS 保护。见 TCP 安全边界。

协议	理解重点
HTTP/1.1	使用文本形式的起始行和头部，通常基于 TCP
HTTP/2	二进制分帧与多路复用，通常基于 TCP
HTTP/3	基于 QUIC，不能沿用“HTTP 全都走 TCP”的说法

协议差异见 HTTP/1.1、HTTP/2和 HTTP/3。

13.1 解析 URL，不要手工切字符串

代码块 Python

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


from urllib.parse import parse_qs, urlsplit

url = urlsplit("https://example.com/search?q=python&page=2#intro")
print(url.scheme, url.hostname)
print(url.path)
print(parse_qs(url.query))
print(url.fragment)

# 输出：
# https example.com
# /search
# {'q': ['python'], 'page': ['2']}
# intro

查询参数：parse_qs() 返回列表值，是因为同一个参数可以出现多次。
片段标识：#intro 不会作为普通 HTTP 请求的请求目标发送给服务器。
安全边界：解析 URL 不等于验证它安全或允许访问。见 urllib.parse。

13.2 看懂报文，不手写生产服务器

下面是 HTTP/1.1 请求结构示意，不是程序输出；实际行结束符使用 \r\n，头部后有空行：

代码块 Http

1
2
3


GET /search?q=python HTTP/1.1
Host: example.com
Accept: application/json

请求：关注方法、目标路径、头部和可选正文；GET 请求正文没有通用语义，通常不应发送。
响应：关注状态码、头部和正文；并非所有响应都带正文，例如 204 响应。
消息边界：依照协议中的长度、分块等规则处理，不能靠一次 recv(1024) 或 split(" ") 解析完整请求。见 HTTP 语义和 HTTP/1.1 消息格式。

不要把请求路径直接拼到本地目录后读取文件。 旧式手写静态服务器还需要处理路径越界、协议解析、超时和并发限制；这些不适合靠几段教学代码承担。

HTTP 请求优先使用标准库 urllib.request 或项目选定的客户端库。标准库 http.server 可用于受控本地预览，但不适合作为生产服务器。

13.3 常用 HTTP 状态码

先按首位判断类别：2xx 表示成功，3xx 表示重定向，4xx 表示客户端错误，5xx 表示服务器错误。 常见状态码如下：

状态码	含义
`200 OK`	请求成功，具体结果含义取决于请求方法
`201 Created`	请求成功，并创建了资源
`204 No Content`	请求成功，响应不包含正文
`301 Moved Permanently`	资源永久迁移到新地址
`302 Found`	资源暂时位于其他地址
`400 Bad Request`	请求有误，例如语法或消息格式不合法
`401 Unauthorized`	缺少目标资源所需的有效认证凭据
`403 Forbidden`	服务端理解请求，但拒绝执行
`404 Not Found`	未找到目标资源，或不愿透露它是否存在
`500 Internal Server Error`	服务端遇到意外情况，无法完成请求
`502 Bad Gateway`	网关或代理从上游收到无效响应
`503 Service Unavailable`	服务暂时无法处理请求，例如过载或维护

401 关注认证，403 关注拒绝执行，不能把两者都理解成“密码错误”。500 也不等于“网络没连上”，它是服务端返回的 HTTP 响应。

301、302 通常通过 Location 头给出跳转地址；客户端可能将原来的 POST 改为 GET。需要明确保留请求方法时，使用 307（临时）或 308（永久）。具体语义见 HTTP 状态码规范。

Python 3 基础速查

Sat, 10 Oct 2026 17:37:18 +0800

版本：示例使用 Python 3.13，按对应版本官方文档复核；实际项目以自身声明的 Python 版本为准。

1. Python、CPython 与交互环境

名称	定位
Python	语言及其规范
CPython	最常用、由 Python 项目维护的实现
PyPy	包含 JIT 的另一种实现，第三方扩展兼容性需要单独核对
IPython、Jupyter	交互环境，通常运行在 CPython 之上

源码不一定被直接逐行解释执行。 以默认 CPython 为例，源码先编译为字节码，再由虚拟机执行，并可能缓存 .pyc。

具体执行方式取决于实现。Python 通常以一定运行时开销换取表达力、生态和开发效率，性能是否够用应以实测为准。

2. 安装、运行与环境隔离

尚未安装时，从 python.org 下载页获取 Python。

新项目：可以选择当前稳定版。
已有项目：以项目声明的 Python 版本和依赖兼容范围为准。

安装完成后，先确认终端实际调用的是哪个版本。

2.1 确认解释器

macOS 或 Linux 通常使用 python3，Windows 可使用 py 启动器：

代码块 Shell

1
2
3


# macOS / Linux
python3 --version
# 输出格式：Python 3.13.11

代码块 Powershell

1
2
3


# Windows PowerShell
py --version
# 输出格式：Python 3.13.11

直接运行解释器会进入 REPL，适合验证表达式；把代码保存为 hello.py 后则可以运行脚本：

代码块 Python

1
2
3
4


name = "Python"
print(f"Hello, {name}!")

# 输出：Hello, Python!

代码块 Shell

1
2
3


# macOS / Linux
python3 hello.py
# 输出：Hello, Python!

代码块 Powershell

1
2
3


# Windows PowerShell
py hello.py
# 输出：Hello, Python!

2.2 用 `venv` 快速建立项目环境

已经安装 Python 后，可以先用标准库 venv 完成最小环境隔离实践。

作用：为当前项目建立独立的第三方包目录，避免不同项目互相覆盖依赖。
前提：基于现有 Python 创建环境，不会替你安装另一个 Python 版本。
目录：.venv 只存放环境，不放项目源码，也不提交到 Git。

代码块 Shell

1
2
3
4
5


# macOS / Linux
# 用当前 python3 创建 .venv，再让当前 shell 优先使用其中的 python 和 pip
python3 -m venv .venv
source .venv/bin/activate
# 成功时通常无输出；当前 shell 的 Python 已切换到 .venv。

代码块 Powershell

1
2
3
4


# Windows PowerShell
py -m venv .venv
.venv\Scripts\Activate.ps1
# 成功时通常无输出；当前 PowerShell 的 Python 已切换到 .venv。

激活后统一使用当前环境中的 python。用 python -m pip 比直接使用 pip 更明确，因为它能保证安装目标就是当前解释器：

代码块 Shell

1
2
3
4
5
6


python --version
# 输出格式：Python 3.13.x
python -m pip --version
# 输出格式：pip <版本> from <.venv 路径>/site-packages/pip (python 3.13)
python -m pip install package_name
# 输出：安装日志取决于包、索引和缓存；package_name 需要替换成真实包名。

不要用 sudo pip install ... 修改系统 Python。

项目依赖应记录在 pyproject.toml 或锁文件中，虚拟环境本身可随时重建。

使用完毕后，退出当前 shell 的虚拟环境：

代码块 Shell

1
2


deactivate
# 成功时通常无输出；恢复激活前的解释器搜索路径，不会删除 .venv。

venv 与 Miniconda 怎么选？

venv：同样可用于生产项目，不能用“初学者 / 企业级”划分工具。
Miniconda：包含 conda、Python 及必要依赖的精简发行版。conda 可管理不同 Python 版本及非 Python 依赖。

选择取决于依赖和部署方式。Miniconda 的安装与环境管理另文介绍，本文先用 venv 跑通基础示例。

3. 语法、注释与命名

3.1 缩进是语法的一部分

Python 用缩进表示代码块。每层使用 4 个空格，不要混用 Tab 与空格。

为什么这样约定？

4 个空格是 PEP 8 风格建议，不是解释器强制的唯一宽度。
解析行首缩进时，Python 将 Tab 展开到下一个 8 列制表位，编辑器却可能按 4 列显示；视觉对齐不代表缩进层级相同。
混用导致缩进含义依赖 Tab 宽度时，会触发 TabError，它属于 IndentationError。

编辑器建议：把 Tab 键设为插入 4 个空格。 按了 Tab 键，不等于文件里存了 Tab 字符。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


temperature = 28

if temperature >= 30:
 print("炎热")
elif temperature >= 20:
 print("舒适")
else:
 print("偏冷")

# 输出：舒适

3.2 注释不等于文档字符串

注释：# 从当前位置注释到行尾；多行注释需要每行都加 #。
跨行字符串：'''...''' 和 """...""" 都可以使用，前后必须是同一种引号。三引号不是专用的“多行注释”语法。
文档字符串：普通字符串字面量放在模块、类或函数体的第一条语句，可通过 __doc__ 或 help() 读取；惯例用三个双引号。

单独放在其他位置的三引号字符串通常没有可见效果，但内部转义和引号仍受字符串语法约束，不能把任意代码包进去当注释。

代码块 Python

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


def area(width: float, height: float) -> float:
 """返回矩形面积。"""
 return width * height # 单位由调用方约定


print(area(3.0, 4.0))
print(area.__doc__)

message = '''第一行
第二行'''
print(message)

# 输出：
# 12.0
# 返回矩形面积。
# 第一行
# 第二行

注释应该解释“为什么”，而不是逐字复述代码。过时注释比没有注释更危险。

3.3 命名规则与惯例

标识符区分大小写，可以包含 Unicode 字母、数字和下划线，但不能以数字开头，也不能使用关键字。关键字应动态查看：

代码块 Python

1
2
3
4
5
6
7


import keyword

# kwlist 是保留关键字列表，不能用作普通变量名
print(keyword.kwlist)
# softkwlist 是软关键字列表：只在特定语法位置有特殊含义
# 例如 match、case 用于模式匹配，type 用于类型别名；其他位置仍可作为名称
print(keyword.softkwlist)

Python 3.13 输出：

代码块 Text

1
2


# ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
# ['_', 'case', 'match', 'type']

常用的 PEP 8 命名约定：

变量、函数、模块：snake_case
类：CapWords
常量：UPPER_CASE
内部实现细节：前导下划线，如 _cache

全大写只是“不要重新赋值”的协作约定，不会让对象真正不可变。

4. 名称、对象与类型

4.1 赋值是名称绑定

Python 变量更准确的说法是“名称绑定到对象”，而不是一个固定类型的内存盒子：

代码块 Python

1
2
3
4
5
6
7
8
9


value = 42
print(type(value))

value = "forty-two"
print(type(value))

# 输出：
# <class 'int'>
# <class 'str'>

动态类型：名称可以重新绑定到不同类型的对象。
强类型：通常不会偷偷把无关类型混合运算，例如整数与字符串不能直接相加。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


try:
 total = 1 + "2"
except TypeError as exc:
 print(f"TypeError: {exc}")

# 输出：TypeError: unsupported operand type(s) for +: 'int' and 'str'

total = 1 + int("2")
print(total)

# 输出：3

多个名称可以指向同一个可变对象：

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


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

print(first)
print(first is second)

# 输出：
# [1, 2, 3]
# True

需要独立的浅拷贝可使用 first.copy() 或 first[:]；嵌套对象是否也要复制，需要根据数据结构决定是否使用 copy.deepcopy()。

4.2 常见内置类型

类别	类型	是否可变	示例
空值	`NoneType`	否	`None`
布尔	`bool`	否	`True`、`False`
数值	`int`、`float`、`complex`	否	`42`、`3.14`、`1 + 2j`
文本与字节	`str`、`bytes`	否	`"你好"`、`b"data"`
序列	`list`、`tuple`、`range`	仅 `list` 可变	`[1, 2]`、`(1, 2)`
映射	`dict`	是	`{"name": "Ada"}`
集合	`set`、`frozenset`	仅 `set` 可变	`{1, 2}`

“对象不可变”表示对象自身的值不能原地改变，不代表指向它的名称不能重新绑定。

complex：复数

组成：a + bj 中，a 是实部，b 是虚部系数，j 表示平方为 -1 的虚数单位。
写法：Python 写 1j；单独的 j 会被当成变量名。
用途：支持加减乘除，常见于科学计算和信号处理；普通业务先认识表示法即可。

代码块 Python

1
2
3
4
5
6
7
8
9


number = complex(1, 2) # 等价于 1 + 2j
print(number)
print(number.real, number.imag)
print(1j * 1j)

# 输出：
# (1+2j)
# 1.0 2.0
# (-1+0j)

set 与 frozenset：可变集合与不可变集合

二者都保存不重复的可哈希元素，支持交集、并集等运算。

类型	能否原地增删	自身能否作为字典键或集合元素
`set`	可以	不可以，自身不可哈希
`frozenset`	不可以	可以，自身可哈希

集合运算可以产生新对象，不等于修改原对象。

代码块 Python

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


editable = {1, 2}
editable.add(3)
fixed = frozenset([1, 2, 2])

print(sorted(editable))
print(sorted(fixed))
print(fixed | {3} == {1, 2, 3})

# 输出：
# [1, 2, 3]
# [1, 2]
# True

4.3 真值规则

None、False、数值零以及空字符串和空容器通常为假，其余对象通常为真：

代码块 Python

1
2
3
4
5
6


items: list[str] = []

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

# 输出：列表为空

if value: 同时把 0、空值和空容器视为假。如果业务上必须区分这些情况，就应写出精确条件。

5. 数值与运算符

常用算术运算符包括 +、-、*、/、//、% 和 **。对内置 int、float，/ 执行除法并返回 float， // 则把商向负无穷取整：

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


print(7 / 2)
print(7 // 2)
print(-7 // 2)
print(2 ** 10)

# 输出：
# 3.5
# 3
# -4
# 1024

int() 把浮点数向零截断，不等于数学上的向下取整：

代码块 Python

1
2
3
4
5
6
7
8


import math

print(int(-1.8))
print(math.floor(-1.8))

# 输出：
# -1，int() 向零截断
# -2，math.floor() 向下取整

浮点数比较：math.isclose()

浮点数采用二进制表示，很多十进制小数不能精确存储。 math.isclose(a, b) 判断两数是否在允许误差内接近，返回布尔值。

rel_tol：相对误差。以两数绝对值中较大的一个为基准，默认 1e-9。
abs_tol：绝对误差。默认 0.0；比较接近零的数时，通常要指定正的 abs_tol。

误差阈值由业务确定。这个函数不会修改数值，也不等于先保留几位小数再比较。

代码块 Python

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


import math

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(math.isclose(0.1 + 0.2, 0.3))
# 允许与零的差不超过 0.000000001
print(math.isclose(1e-10, 0.0, abs_tol=1e-9))

# 输出：
# 0.30000000000000004
# False
# True
# True

十进制计算：Decimal

Decimal 可精确表示 0.1 这类有限十进制小数，适合金额等需要明确十进制精度的计算。

从字符串构造，如 Decimal("0.1")，避免带入 float 已有的二进制误差。
运算仍有精度限制，例如不能把除法结果理解成无限精确。
明确舍入规则，金额保留几位、如何取舍都应由业务规定。

代码块 Python

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


from decimal import Decimal, ROUND_HALF_UP

print(Decimal("0.1") + Decimal("0.2"))
price = Decimal("19.90")
print(price * 3)
# quantize 按指定小数位舍入；这里明确采用 ROUND_HALF_UP
print(Decimal("19.905").quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))

# 输出：
# 0.3
# 59.70
# 19.91

比较运算可以链式书写，逻辑运算使用 and、or、not：

代码块 Python

1
2
3
4
5


age = 24
if 18 <= age < 60:
 print("年龄在目标区间")

# 输出：年龄在目标区间

6. 字符串、字节与格式化输出

6.1 字符串是不可变的 Unicode 文本

代码块 Python

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


language = "Python"

print(language[0])
print(language[-1])
print(language[1:4])
print(language.lower())

# 输出：
# P
# n
# yth
# python

切片遵循左闭右开区间 [start:stop:step]。字符串方法返回新对象，不会原地修改原字符串。

6.2 优先使用 f-string

% 格式化和 str.format() 仍然有效，但新代码通常优先使用可读性更好的 f-string：

代码块 Python

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


name = "Ada"
score = 95.678
student_id = 7

print(f"{name} 的成绩是 {score:.2f}")
print(f"学号：{student_id:03d}")
print(f"调试值：{score=}")

# 输出：
# Ada 的成绩是 95.68
# 学号：007
# 调试值：score=95.678

转义字符 \n 表示换行，\t 表示水平制表符；制表符显示成多宽由终端或编辑器决定。

代码块 Python

1
2
3


print("第一行\n第二行")
# sep 是参数间的分隔符（默认空格）；end 是输出结尾（默认换行）
print("A", "B", "C", sep=" | ", end="\n")

输出：

代码块 Text

1
2
3


# 第一行
# 第二行
# A | B | C

6.3 文本与字节要显式转换

网络、压缩和二进制文件通常处理 bytes；界面和业务文本通常处理 str。二者不能直接拼接：

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


text = "你好，Python"
payload = text.encode("utf-8")
restored = payload.decode("utf-8")

print(payload)
print(restored)

# 输出：
# b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8cPython'
# 你好，Python

编码：str → bytes，使用 .encode()。
解码：bytes → str，使用 .decode()，按对应编码解释字节。

Python 3 的 str 已经是文本，没有 .decode() 方法，不能再次解码。

字节可以来自 .encode()，也可以直接从文件或网络读取，不要求先在当前程序里编码一次。读写文本文件时应明确指定编码。

7. 输入与安全转换

input() 总是返回字符串。转换可能失败，应处理具体的 ValueError：

代码块 Python

1
2
3
4
5
6
7
8


raw_age = input("请输入年龄：").strip()

try:
 age = int(raw_age)
except ValueError:
 print("年龄必须是整数")
else:
 print(f"明年 {age + 1} 岁")

两种输入的执行结果：

代码块 Text

1
2
3
4
5


# 请输入年龄：20
# 明年 21 岁
#
# 请输入年龄：abc
# 年龄必须是整数

读取密码：getpass.getpass()

getpass.getpass() 是标准库中的密码输入函数，返回 str。

与 input() 的区别：在支持的终端中不回显键入字符，通常连星号也不显示。
职责边界：只负责输入，不负责加密或验证密码；读取后也不要打印密码。

代码块 Python

1
2
3
4
5
6


import getpass

password = getpass.getpass("请输入密码：")

# 支持隐藏输入的终端中，输出：请输入密码：
# 键入字符不回显，按回车后字符串保存到 password。

部分 IDE 控制台不支持隐藏输入，可能出现 GetPassWarning 并回显；遇到这种情况改在终端运行。

选择安全的转换方式

不要把 eval() 当成类型转换工具。 它会执行 Python 表达式，对不可信输入使用可能导致任意代码执行。

已知目标类型：使用 int()、float()、str()。
JSON 数据：使用 json.loads()。它按 JSON 语法解析数据，不执行 Python 表达式。
语法区别：JSON 用 true、null，Python 用 True、None。

两者的详细对比留到基础易混淆点文章。

代码块 Python

1
2
3
4
5
6


import json

settings = json.loads('{"theme": "dark", "page_size": 20}')
print(settings["theme"])

# 输出：dark

8. 核心容器

8.1 列表与元组

列表适合可变的有序数据，元组适合结构固定的记录或不可变序列：

代码块 Python

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


tasks = ["read", "code"]
tasks.append("review")
tasks.extend(["test", "release"])

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

print(tasks)
print(x, y)

# 输出：
# ['read', 'code', 'review', 'test', 'release']
# 10 20

元组本身不能增删或替换元素，但元素仍可能指向列表等可变对象，因此元组不保证“深层不可变”，也不一定可哈希。

避免用乘法创建共享的嵌套可变对象：

代码块 Python

1
2
3
4
5
6
7
8


# 错误：两行引用同一个内部列表
# matrix = [[0] * 3] * 2

matrix = [[0] * 3 for _ in range(2)]
matrix[0][0] = 1
print(matrix)

# 输出：[[1, 0, 0], [0, 0, 0]]

8.2 字典

字典保存键值映射，键必须可哈希。字典保留插入顺序，但业务需要排序时，仍应显式使用 sorted()。

为什么列表不能作为键？

定位方式：字典借助哈希值定位键。可哈希对象的哈希值在生命周期中保持不变，相等对象具有相同哈希值。
列表不可哈希：列表内容可变，Python 不给列表提供哈希能力，因此 {[1, 2, 3]: "abc"} 会报错。
可用的键：整数、字符串，以及元素也全部可哈希的元组。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


try:
 mapping = {[1, 2, 3]: "abc"}
except TypeError as exc:
 print(f"TypeError: {exc}")

# 输出：TypeError: unhashable type: 'list'

mapping = {(1, 2, 3): "abc"}
print(mapping[(1, 2, 3)])

# 输出：abc

不可变不等于一定可哈希。 元组里含列表时仍不可哈希；自定义对象取决于它的哈希与相等性实现。

代码块 Python

1
2
3
4
5
6
7
8


user = {"name": "Ada", "age": 36}
user["city"] = "London"

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

email = user.get("email") # 缺失时返回 None
print(email)

输出：

代码块 Text

1
2
3
4


# name Ada
# age 36
# city London
# None

读取键：下标还是 get()？

必填字段用 mapping[key]：缺失时抛出 KeyError。例如姓名必填，user["name"] 能及时暴露缺字段问题。
可选字段用 mapping.get(key)：缺失时默认返回 None。例如用户可以不填邮箱，user.get("email") 就适合。

注意拼写：把 name 错写成 user.get("nmae")，也只会得到 None，错误可能拖到后续步骤才出现。

8.3 集合

集合保存不重复、可哈希的元素，适合去重和成员判断；集合本身没有可依赖的展示顺序。

代码块 Python

1
2
3
4
5
6
7
8


required = {"title", "content"}
provided = {"title", "content", "tags", "author"}

print(required <= provided)
print(provided - required)

# 输出：True
# 示例输出：{'tags', 'author'}，元素顺序不保证

8.4 推导式

推导式适合简短、单一的映射或过滤；逻辑复杂时使用普通循环更清楚。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


numbers = range(10)
squares = [number ** 2 for number in numbers if number % 2 == 0]
index = {name: position for position, name in enumerate(["Ada", "Guido"])}

print(squares)
print(index)

# 输出：
# [0, 4, 16, 36, 64]
# {'Ada': 0, 'Guido': 1}

生成器表达式使用圆括号，按需产生值，不会一次构造完整列表。

下面示例中的数字写法：

1_000_000 就是 1000000：数字下划线是 Python 3.6 起支持的标准分隔写法，只提高可读性。
range(1_000_000)：依次产生 0 到 999999。

代码块 Python

1
2
3
4


total = sum(number ** 2 for number in range(1_000_000))
print(total)

# 输出：333332833333500000

9. 分支、循环与模式匹配

9.1 `if`、`for` 与 `while`

Python 的 for 遍历可迭代对象，而不是只提供计数循环：

代码块 Python

1
2
3
4


names = ["Ada", "Guido", "Grace"]

for position, name in enumerate(names, start=1):
 print(position, name)

输出：

代码块 Text

1
2
3


# 1 Ada
# 2 Guido
# 3 Grace

并行遍历多个序列可使用 zip()：

代码块 Python

1
2
3
4
5


names = ["Ada", "Guido"]
scores = [98, 95]

for name, score in zip(names, scores, strict=True):
 print(f"{name}: {score}")

输出：

代码块 Text

1
2


# Ada: 98
# Guido: 95

strict=True 会在迭代发现序列长度不一致时抛出 ValueError，适合长度必须相同的业务数据。

while 适合结束条件不是“遍历完某个集合”的情况。循环必须保证状态朝退出条件推进：

代码块 Python

1
2
3
4


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

输出：

代码块 Text

9.2 `match` 是结构化模式匹配

match 是 Python 3.10 新增的模式匹配语句：按顺序比较各个 case 后的模式，只执行第一个匹配分支。

case 是软关键字，不是函数。 它既能匹配固定值，也能检查序列结构并取出元素。

下面把命令表示为元组。模式 ("move", direction, distance) 分三部分理解：

结构：序列必须有三个元素。
固定值：首元素必须为 "move"。
捕获变量：后两个元素分别绑定给 direction、distance，不是与同名旧变量比较。

代码块 Python

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


def describe(command: tuple[str, ...]) -> str:
 match command: # 选择要匹配的数据
 case ("move", direction, distance):
 # 匹配三元素序列；例如 direction = "东"，distance = "3"
 return f"向 {direction} 移动 {distance}"
 case ("quit",):
 # 匹配唯一元素为 "quit" 的序列；元组中的逗号不能省略
 return "退出"
 case _:
 # _ 匹配任何剩余情况，不保存匹配值，通常放在最后
 return "未知命令"


print(describe(("move", "东", "3")))
print(describe(("quit",)))
print(describe(("status",)))

# 输出：
# 向 东 移动 3
# 退出
# 未知命令

使用时记住：

无需 break：匹配后不会自动继续执行下一个 case。
没有匹配就跳过：没有分支匹配且没有 case _ 时，整个语句直接结束。
序列模式也能匹配列表：参数类型标注本身不会限制运行时传入的类型。

简单条件继续用 if 即可。

10. 函数与作用域

10.1 参数与返回值

函数可以组合位置参数、默认参数和仅限关键字参数：

代码块 Python

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


from decimal import Decimal


def format_price(amount: Decimal, currency: str = "CNY", *, precision: int = 2) -> str:
 return f"{currency} {amount:.{precision}f}"


print(format_price(Decimal("19.90")))
print(format_price(Decimal("19.90"), precision=1))

# 输出：
# CNY 19.90
# CNY 19.9

* 后的参数：必须按关键字传递，避免布尔值、数字等位置参数含义不清。
*args：收集额外位置参数。
**kwargs：收集额外关键字参数。

但普通业务函数不应无理由接受任意参数。

函数没有显式 return 时返回 None。返回多个值实际上是返回一个元组：

代码块 Python

1
2
3
4
5
6
7
8


def bounds(values: list[int]) -> tuple[int, int]:
 return min(values), max(values)


lowest, highest = bounds([3, 1, 8])
print(lowest, highest)

# 输出：1 8

10.2 不要使用可变默认值

默认参数在函数定义时求值，只创建一次：

代码块 Python

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


# list[str] | None 是联合类型：items 可以是字符串列表，也可以是 None
# 这里的 | 表示“或”；末尾 = None 才是参数默认值，不是类型的一部分
def add_item(item: str, items: list[str] | None = None) -> list[str]:
 if items is None:
 items = []
 items.append(item)
 return items


print(add_item("read"))
print(add_item("code"))

# 输出：
# ['read']
# ['code']

这个规则同样适用于字典、集合以及自定义的可变对象。

10.3 作用域与闭包

名称查找通常遵循 LEGB：局部（Local）→ 外层函数（Enclosing）→ 全局（Global）→ 内置（Built-in）。

尽量通过参数和返回值传递数据，少依赖可变全局状态。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


def make_multiplier(factor: int):
 def multiply(value: int) -> int:
 return value * factor

 return multiply


double = make_multiplier(2)
print(double(5))

# 输出：10

lambda 适合短小的单表达式函数，例如排序键；一旦需要分支、异常处理或文档，就应使用 def。

代码块 Python

1
2
3
4
5


records = [{"name": "Ada", "score": 98}, {"name": "Guido", "score": 95}]
records.sort(key=lambda record: record["score"], reverse=True)
print(records)

# 输出：[{'name': 'Ada', 'score': 98}, {'name': 'Guido', 'score': 95}]

11. 异常与资源管理

异常用于报告当前层不能正常完成的操作。捕获异常时应尽可能具体，不要用裸 except: 隐藏退出、取消和程序错误。

代码块 Python

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


def parse_port(raw: str) -> int:
 try:
 port = int(raw)
 except ValueError as exc:
 raise ValueError("端口必须是整数") from exc

 if not 1 <= port <= 65535:
 raise ValueError("端口必须在 1 到 65535 之间")
 return port


for raw in ("8000", "abc", "70000"):
 try:
 print(parse_port(raw))
 except ValueError as exc:
 print(f"ValueError: {exc}")

# 输出（依次对应上面的三个输入）：
# 8000
# ValueError: 端口必须是整数
# ValueError: 端口必须在 1 到 65535 之间

异常结构的职责：

try：只包围可能失败的最小范围。
except：处理明确知道如何恢复或转换的异常。
else：仅在没有异常时执行。
finally：无论是否异常都执行，适合必须进行的清理。

文件和锁等资源优先使用 with，由上下文管理器保证释放，通常无需手写 finally。

假设 notes.txt 包含“第一行”和“第二行”：

代码块 Python

1
2
3
4
5
6


from pathlib import Path

path = Path("notes.txt")
with path.open("r", encoding="utf-8") as file:
 for line in file:
 print(line.rstrip())

输出：

代码块 Text

1
2


# 第一行
# 第二行

数据库连接：核对 with 的具体职责

sqlite3.Connection 的 with 只管理事务提交或回滚，不会关闭连接。
关闭连接仍需显式调用 close()，或另外使用能负责关闭的上下文管理器。

文件操作：区分状态检查与实际操作

查看状态：Path.exists() 可判断此刻是否存在，但不能替代操作本身的错误处理。
读写文件：使用明确的打开模式，捕获具体异常；不要用“读取失败就新建文件”的宽泛异常逻辑判断是否存在。
保证约束：“先检查再操作”可能有并发竞态，真正的写入约束应由打开模式或底层存储保证。

12. 文件、路径与结构化数据

12.1 使用 `pathlib` 表达路径

pathlib.Path 把路径表示为对象，比手工拼接 / 或 \\ 更跨平台。

Path("data") 表示什么？

位置：相对于当前工作目录的 data 路径。
创建对象：不会创建目录，也不会自动变成绝对路径；调用 mkdir() 才会创建目录。
系统差异：macOS / Linux 中是 PosixPath，Windows 中是 WindowsPath。

为什么会看到 PosixPath('data')？

查看方式（macOS / Linux）	显示内容
交互环境直接查看对象，或使用 `repr()`	`PosixPath('data')`，包含对象类型
使用 `print()`	`data`，只显示路径文本

下面假设在 macOS 的 /Users/you/project 目录启动程序，且路径不涉及符号链接：

代码块 Python

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


from pathlib import Path

data_dir = Path("data")
print(data_dir)
print(repr(data_dir))
print(data_dir.resolve()) # 返回解析后的绝对路径对象，不修改原来的 data_dir
print(data_dir)

# 示例输出（对象类型和绝对路径因系统、启动目录而异）：
# data
# PosixPath('data')
# /Users/you/project/data
# data

路径对象之间的 / 表示拼接子路径。

下面创建目录并写入文件。data_dir / "report.txt" 在上述目录下实际指向 /Users/you/project/data/report.txt：

代码块 Python

1
2
3
4
5
6
7
8
9


from pathlib import Path

data_dir = Path("data")
data_dir.mkdir(parents=True, exist_ok=True) # 补齐缺失的父目录；目标目录已存在时不报错

report_path = data_dir / "report.txt"
report_path.write_text("第一行\n第二行\n", encoding="utf-8")
content = report_path.read_text(encoding="utf-8")
print(content, end="")

输出如下，同时会生成 data/report.txt：

代码块 Text

1
2


# 第一行
# 第二行

read_text() 适合体积可控的文本；大文件应逐行读取，避免一次占用过多内存。

12.2 JSON 序列化与反序列化

序列化：Python 对象 → 可存储、传输的 JSON 文本。
反序列化：JSON 文本 → Python 对象。

函数名带 s 的版本主要处理字符串，不带 s 的版本处理已经打开的文件对象：

函数	方向	输入与结果
`json.dumps(obj)`	序列化	Python 对象 → JSON 字符串 `str`
`json.dump(obj, file)`	序列化	把 JSON 文本写入文件对象，返回 `None`
`json.loads(text)`	反序列化	JSON 字符串 → Python 对象，也支持 `bytes`、`bytearray`
`json.load(file)`	反序列化	从文件对象读取 JSON，返回 Python 对象

dump() / load() 接收文件对象，不是文件路径字符串。 两组方法分别这样使用：

代码块 Python

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


import json
from pathlib import Path

profile = {"name": "Ada", "skills": ["math", "programming"]}

# 字符串方式：对象 → JSON 字符串 → 对象
text = json.dumps(profile, ensure_ascii=False)
print(text)
print(json.loads(text))

# 文件方式：对象 → profile.json → 对象
path = Path("profile.json")
with path.open("w", encoding="utf-8") as file:
 json.dump(profile, file, ensure_ascii=False, indent=2)
with path.open("r", encoding="utf-8") as file:
 loaded = json.load(file)
print(loaded)

# 输出：
# {"name": "Ada", "skills": ["math", "programming"]}
# {'name': 'Ada', 'skills': ['math', 'programming']}
# {'name': 'Ada', 'skills': ['math', 'programming']}

类型限制：JSON 不会自动保存 datetime、Decimal、集合或自定义类，需要先转换为约定的数据结构。

不要对不可信数据使用 pickle。 反序列化恶意 pickle 可以执行代码。

13. 模块、包与程序入口

模块：每个 .py 文件都是模块。
常规包：目录通常包含 __init__.py。
导入行为：会执行模块的顶层代码，因此顶层应以定义、常量和必要的轻量初始化为主。

下面只是项目结构示意；可安装包还需要在 pyproject.toml 中声明构建和包发现配置：

代码块 Text

1
2
3
4
5
6
7
8


price_tool/
├── pyproject.toml
├── src/
│ └── price_tool/
│ ├── __init__.py
│ ├── formatter.py
│ └── __main__.py
└── tests/

脚本入口使用显式的 main()，既方便测试，也避免模块被导入时直接执行业务：

代码块 Python

1
2
3
4
5
6
7
8


def main() -> None:
 print("程序开始")


if __name__ == "__main__":
 main()

# 作为脚本运行时输出：程序开始

Path.cwd()：当前工作目录

cwd 是 current working directory。Path.cwd() 返回当前工作目录的绝对路径对象，通常由启动命令时所在的目录决定。

当前工作目录不保证等于脚本文件所在目录。 相对路径的读写以当前工作目录为基准。

常见导入形式与调用方式如下：

代码块 Python

1
2
3
4
5
6
7
8


import math
from pathlib import Path

print(math.sqrt(81))
print(Path.cwd()) # 查看当前工作目录

# 输出：9.0
# 示例输出：/Users/you/project，实际值取决于启动目录

避免通配导入：from module import * 会让名称来源不清晰。
避免模块重名：不要把文件命名为 random.py、json.py、typing.py 等标准库名称，否则可能遮蔽真正的模块。

14. 类与数据类

类把状态和行为组织在一起。不是所有数据都需要类：简单转换可用函数，固定的小型记录可考虑元组或数据类。

@dataclass 自动生成什么？

它是应用在类定义上的装饰器：类定义完成后，根据 name: str 等字段声明补齐常见方法。

自动生成的方法	用途
`__init__`	接收构造参数，保存为实例字段
`__repr__`	以可读形式展示对象的字段内容
`__eq__`	按字段比较同类型实例是否相等

代码块 Python

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


from dataclasses import dataclass
from decimal import Decimal


@dataclass # 自动生成初始化、展示和相等性比较方法
class Product:
 name: str
 price: Decimal
 stock: int = 0

 def reserve(self, quantity: int) -> None:
 if quantity <= 0:
 raise ValueError("数量必须大于零")
 if quantity > self.stock:
 raise ValueError("库存不足")
 self.stock -= quantity


product = Product("Keyboard", Decimal("399.00"), stock=10) # 自动把参数保存为实例字段
product.reserve(2)
print(product.stock)
print(product) # 使用自动生成的 __repr__ 展示字段
print(product == Product("Keyboard", Decimal("399.00"), stock=8))

# 输出：
# 8
# Product(name='Keyboard', price=Decimal('399.00'), stock=8)
# True

去掉 @dataclass 后有什么差异？

构造参数要自己处理：只删装饰器，上面的 Product("Keyboard", ...) 会报 TypeError。需要手写 __init__，给 self.name、self.price、self.stock 赋值。
展示与比较要自己实现：普通类不会默认按这些字段展示内容或比较相等。

它不替你完成什么？

reserve() 这类业务方法仍需手写。
默认不生成大小排序方法。
不会自动检查字段类型或业务合法性。

继承与组合：继承表达“是一个”，组合表达“拥有一个”。业务代码通常优先组合；确实需要共享接口和可替换行为时，再使用继承。

15. 迭代器与生成器

可迭代对象：能产生迭代器。
迭代器：通过 __next__() 逐个返回值，耗尽时抛出 StopIteration。

日常代码通常使用 for，无需手动调用这些方法。

包含 yield 的函数是生成器函数，调用后返回生成器对象，执行会在迭代时按需推进：

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 假设 notes.txt 依次包含“第一行”、空行和“第二行”
def read_non_empty_lines(path: str):
 with open(path, "r", encoding="utf-8") as file:
 for line in file:
 stripped = line.strip()
 if stripped:
 yield stripped


for line in read_non_empty_lines("notes.txt"):
 print(line)

输出：

代码块 Text

1
2


# 第一行
# 第二行

生成器适合流式处理，使用时注意：

只能消费一次：需要重复遍历时，重新创建生成器，或在数据量允许时转成列表。
资源生命周期：文件等资源可能在迭代期间一直保持打开，直到退出相应的上下文。

16. 类型标注

类型标注提高可读性，并帮助编辑器和静态类型检查器发现问题。Python 运行时不会根据类型注解强制检查类型。

type UserId = int：给类型起一个业务名称

语法来源：Python 3.12 新增的类型别名声明。
作用：给 int 起别名 UserId，让标注表达“这里的整数是用户编号”。
边界：没有创建一种新的整数，也不会自动验证编号是否合法。

代码块 Python

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


type UserId = int # 类型别名：让标注中的用户编号更容易辨认


def active_names(users: dict[UserId, str], disabled: set[UserId]) -> list[str]:
 return [name for user_id, name in users.items() if user_id not in disabled]


user_id: UserId = 1001
print(type(user_id))
print(active_names({1: "Ada", 2: "Guido", 3: "Linus"}, {2}))

# 输出：
# <class 'int'>
# ['Ada', 'Linus']

区分 user_id 与 UserId

user_id 是变量：上例绑定的对象实际类型是 int。
UserId 是类型别名对象：不是普通赋值 UserId = int，不能当作 int() 那样调用。

常用标注写法

字符串列表：list[str]。
字符串键、整数值的字典：dict[str, int]。
可空类型：User | None。

类型标注应表达真实契约，不要为了“全部有类型”而使用大量 Any 或复杂泛型。

静态类型检查不能替代外部输入的解析与校验。

17. 调试与测试

17.1 先读完整 traceback

最后一行：异常类型和消息。
上方调用栈：错误如何到达现场。

应修复根因，不要只在最外层加一个宽泛的 try/except。

常见异常包括：

SyntaxError：语法无法解析。
IndentationError：缩进不合法。
NameError：名称不存在。
TypeError：操作或调用不接受当前类型。
ValueError：类型可以接受，但值不合法。
KeyError、IndexError：映射键或序列位置不存在。
FileNotFoundError：目标文件不存在。

临时观察变量可以使用 print()。日志库的选择与配置不在本篇展开，先掌握如何读出异常位置和原因。

17.2 为行为写测试

标准库 unittest 可以直接起步，项目也可以选择第三方测试框架。测试应覆盖公开行为、边界和失败路径，避免绑定内部实现细节。

先认识示例中的三个名称：

unittest.TestCase：测试基类，提供一组断言方法；继承后即可使用。
test_：测试方法的名称前缀，测试运行器会调用这些方法。
self：当前测试实例，通过它调用继承的 assertEqual() 等方法。

把下面内容保存为 test_example.py：

代码块 Python

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


import unittest


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


class AddTests(unittest.TestCase): # 继承测试基类，获得 assertEqual 等方法
 def test_adds_two_integers(self) -> None:
 # 先算出实际值 add(2, 3)，再与期望值 5 比较；不相等时报告测试失败
 self.assertEqual(add(2, 3), 5)


if __name__ == "__main__":
 unittest.main() # 直接运行本文件时，发现并执行本文件的测试

# 结果：1 项测试通过，耗时因环境而异

self.assertEqual(actual, expected)：比较实际值与期望值

相等：断言通过。
不相等：抛出断言失败，由测试运行器记录；它不是返回 True / False 的判断函数。

这里检查 2 + 3 是否为 5。把期望值改成 6，测试就会失败，并显示 5 != 6。

也可以通过命令行启动测试：-v 展示每项测试的名称，test_example 是去掉 .py 的模块名。

代码块 Shell

1

python -m unittest -v test_example

示例输出（unittest 默认写入 stderr，耗时因环境而异）：

代码块 Text

1
2
3
4
5
6


# test_adds_two_integers (test_example.AddTests.test_adds_two_integers) ... ok
#
# ----------------------------------------------------------------------
# Ran 1 test in 0.000s
#
# OK

18. 单词统计小程序

下面的命令行程序综合了路径、函数、类型标注、容器、异常和标准库。

输入：UTF-8 文本文件，逐行读取。
统计规则：识别由英文字母和内部单引号组成的单词。
适用边界：中文等没有空格边界的语言需要分词工具，不能直接套用这个正则表达式。

代码块 Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


from collections import Counter
from pathlib import Path
import re
import sys


# 预先编译正则，供逐行匹配复用：
# [A-Za-z]+ 匹配连续英文字母；(?:...) 把内部规则作为一组，不单独返回捕获结果
# 后面的 ? 表示该组可出现零次或一次，因此可识别 don't 这样的单词
WORD_PATTERN = re.compile(r"[A-Za-z]+(?:'[A-Za-z]+)?")


def top_words(path: Path, limit: int = 10) -> list[tuple[str, int]]:
 # Counter 是计数字典：键为单词，值为出现次数
 counts: Counter[str] = Counter()
 with path.open("r", encoding="utf-8") as file:
 for line in file:
 # lower 统一小写，findall 返回本行单词列表，update 为每个单词累计次数
 counts.update(WORD_PATTERN.findall(line.lower()))
 # 返回最多 limit 组 (单词, 次数)，按次数从高到低排列
 return counts.most_common(limit)


def main() -> int:
 # sys.argv[0] 是脚本路径，sys.argv[1] 是用户传入的文本文件路径
 # 共两个元素才说明恰好传入了一个参数
 if len(sys.argv) != 2:
 # .name 只取文件名；错误提示写到 stderr（标准错误流）
 print(f"用法：{Path(sys.argv[0]).name} <文本文件>", file=sys.stderr)
 return 2 # 约定退出码 2 表示参数用法错误

 path = Path(sys.argv[1])
 try:
 results = top_words(path)
 except (OSError, UnicodeError) as exc: # 分别处理文件访问失败、文本解码失败
 print(f"读取失败：{exc}", file=sys.stderr)
 return 1 # 约定退出码 1 表示读取失败

 for word, count in results:
 # <20 表示左对齐、最小宽度 20；>6 表示右对齐、最小宽度 6
 print(f"{word:<20} {count:>6}")
 return 0 # 退出码 0 表示成功


if __name__ == "__main__":
 raise SystemExit(main()) # 执行 main，并把返回值交给操作系统作为进程退出码

将程序保存为 word_count.py，并令 sample.txt 内容为 Python is simple. Python is readable.：

代码块 Shell

1

python word_count.py sample.txt

输出：

代码块 Text

1
2
3
4


# python 2
# is 2
# simple 1
# readable 1

继续练习时可以逐步加入 argparse 参数、停用词、JSON 输出和单元测试。每次只增加一个可验证的能力，比一次堆入框架更容易理解。

19. 学完基础后检查什么

能解释名称绑定、可变对象以及常见内置类型的用途。
能为字符串、数值和结构化输入选择安全的转换方式，不对外部输入使用 eval()。
能熟练使用列表、字典、集合、推导式、enumerate() 和 zip()。
能写参数清晰的函数，避免可变默认值，并理解局部与外层作用域。
能捕获具体异常，用 with 管理文件等资源。
能创建虚拟环境，通过 python -m pip 管理当前项目依赖。
能把代码拆成模块，使用 main() 入口，并为关键行为编写测试。

ORTHANT · 技术知识库

Miniconda 安装与使用

1. venv、Miniconda 与 Anaconda

2. 安装与初始化

2.1 Linux

2.2 macOS

2.3 Windows

2.4 初始化与 base

3. 配置镜像

3.1 可复制的镜像地址

3.2 设置 Conda 镜像

4. 创建和使用环境

5. 安装与管理包

5.1 Conda 命令

5.2 pip 命令

6. 导出依赖与重建

6.1 pip：requirements.txt

6.2 Conda：environment.yml

7. 删除环境与清理缓存

8. 常见问题

ORTHANT 博客技术架构详解

1. 整体结构

2. 一篇文章怎么发布

3. 读者打开页面时

4. 三种身份

5. 搜索、评论和浏览统计

6. 这样做的代价

Python 3 易混淆点

对象与容器

1. 可变与不可变，究竟什么不能变？

2. == 与 is 有什么区别？小整数缓存能当判断依据吗？

3. 字典键为什么不能是列表？元组一定能当键吗？

4. 赋值、浅拷贝、深拷贝分别复制了什么？

5. 列表、字典、集合操作都是 O(1) 吗？

函数与作用域

6. 为什么不要用 items=[] 作为常规默认参数？

7. global 与 nonlocal 有什么区别？

8. 循环创建的 lambda，为什么都返回最后一个值？

9. *args、**kwargs、/、单独的 * 有什么区别？

10. 装饰器做了什么？wraps 又有什么用？

迭代与生成器

11. 可迭代对象、迭代器、生成器是什么关系？

12. 列表推导式与生成器表达式，差别只是括号吗？

13. yield 与 yield from 的区别是什么？

14. next() 与生成器的 send() 有什么区别？

表达式与数据

15. eval() 与 json.loads() 能互相替代吗？

16. 为什么 0.1 + 0.2 != 0.3？换成 Decimal 就全精确了吗？

17. if not value 与 value is None 是一回事吗？

18. and、or 的返回值一定是布尔值吗？

19. list.sort() 与 sorted() 有什么区别？排序稳定是什么意思？

20. str 与 bytes 有什么区别？编码与解码怎么记？

类与异常

21. 类属性与实例属性有什么区别？为什么多个实例共用一个列表？

22. __new__() 与 __init__() 都是构造函数吗？

23. super() 就是“调用父类”吗？MRO 是什么？

24. @dataclass(frozen=True) 就彻底不可变了吗？类型标注会自动校验吗？

25. try、except、else、finally 按什么顺序执行？

26. with 只是自动关闭文件吗？会不会吞异常？

27. 能用 assert 校验用户输入或权限吗？

运行时与并发

28. del 会立即释放对象吗？循环引用一定导致内存泄漏吗？

29. 有 GIL 为什么还要加锁？Python 3.13 以后没有 GIL 了吗？

30. 线程、进程、协程怎么选？多进程会共享全局变量吗？

31. 写了 async def 和 await，任务就自动并发了吗？

Python 3 进阶速查

1. 闭包：保留外层变量

循环中的闭包为什么容易出错？

2. 装饰器：包装调用，而不改函数正文

2.1 参数、返回值与元数据都要保留

2.2 带参数的装饰器与叠加顺序

2.3 __call__ 与类实现的装饰器

3. property：让属性访问带上逻辑

3.1 装饰器写法

3.2 property(getter, setter) 写法

4. 上下文管理器：明确资源何时释放

4.1 类式上下文管理器

4.2 用 contextmanager 简化成对操作

5. 生成器：按需组合数据

5.1 逐步读取，耗尽后不会重来

2. `==` 与 `is` 有什么区别？小整数缓存能当判断依据吗？

6. 为什么不要用 `items=[]` 作为常规默认参数？

7. `global` 与 `nonlocal` 有什么区别？

9. `*args`、`**kwargs`、`/`、单独的 `*` 有什么区别？

10. 装饰器做了什么？`wraps` 又有什么用？

13. `yield` 与 `yield from` 的区别是什么？

14. `next()` 与生成器的 `send()` 有什么区别？

15. `eval()` 与 `json.loads()` 能互相替代吗？

16. 为什么 `0.1 + 0.2 != 0.3`？换成 Decimal 就全精确了吗？

17. `if not value` 与 `value is None` 是一回事吗？

18. `and`、`or` 的返回值一定是布尔值吗？

19. `list.sort()` 与 `sorted()` 有什么区别？排序稳定是什么意思？

20. `str` 与 `bytes` 有什么区别？编码与解码怎么记？

22. `new()` 与 `init()` 都是构造函数吗？

23. `super()` 就是“调用父类”吗？MRO 是什么？

24. `@dataclass(frozen=True)` 就彻底不可变了吗？类型标注会自动校验吗？

25. `try`、`except`、`else`、`finally` 按什么顺序执行？

26. `with` 只是自动关闭文件吗？会不会吞异常？

27. 能用 `assert` 校验用户输入或权限吗？

28. `del` 会立即释放对象吗？循环引用一定导致内存泄漏吗？

31. 写了 `async def` 和 `await`，任务就自动并发了吗？

2.3 `call` 与类实现的装饰器

3.2 `property(getter, setter)` 写法

`:=` 海象运算符：赋值后，把值用于判断

2.2 用 `venv` 快速建立项目环境

9.1 `if`、`for` 与 `while`

9.2 `match` 是结构化模式匹配

12.1 使用 `pathlib` 表达路径