07 工程工具核心八股(Git / Linux / pytest / 设计模式 / 性能 / 进程管理)¶
核心概念¶
(a) 🗂️ 工程工具六件套:版本控制、排查、测试与代码质量¶
工程工具八股是「动手能力」的试金石:Git 管版本、Linux 管排查、pytest 管测试、设计模式管代码结构、性能工具管优化、systemd / Docker 管部署。每件工具背「核心命令 + 一个实战场景」就够应付面试。
(该图在 GitHub/VSCode + mermaid 插件中可渲染)
flowchart TB
Tools["🔧 工程工具六件套"]
Tools --> Git["🌿 Git 版本控制<br/>分支模型 / rebase / reset"]
Tools --> Linux["🐧 Linux 命令与现场排查"]
Tools --> PyTest["🧪 pytest 测试<br/>fixture / 参数化 / mock"]
Tools --> Pattern["🧩 设计模式<br/>单例 / 工厂 / 观察者 / 策略"]
Tools --> Perf["📊 性能分析与线上排查"]
Tools --> Ops["🐳 进程管理 / systemd / Docker"]
- 🌿 Git 版本控制:背熟核心命令(add / commit / branch / merge / rebase / reset / revert)与分支模型(Git Flow vs GitHub Flow)。重点辨析 rebase vs merge(历史线性 vs 保留分叉)和 reset vs revert(回退本地 vs 撤销已推送提交),冲突解决步骤要能讲。
- 🐧 Linux 命令与现场排查:命令速查表(ps / top / netstat / ss / df / free / lsof 等)要熟;五个「现场排查」场景(CPU 100%、内存吃紧、磁盘满、进程 D/Z 状态、端口被占)是高频情景题,答题按「定位 → 分析 → 处理」三步走。
- 🧪 pytest 测试:fixture 的 scope(function / class / module / session)与依赖注入、参数化 parametrize、mock / monkeypatch 打桩、断言风格是四大考点。面试常问「怎么测一个发 HTTP 请求的函数」——答案是用 mock 让它不真发。
- 🧩 设计模式:单例(模块级 /
__new__/ 装饰器三种写法)、工厂(简单工厂 vs 工厂方法)、观察者(订阅-发布)、策略(注册表字典替代 if/elif)、装饰器模式(结构型,区别于 Python 装饰器语法)都有 Python 实现,开闭原则是贯穿始终的评价标准。 - 📊 性能分析与线上排查:分析工具四件套(cProfile / timeit / memory_profiler / py-spy)各有用途;排查流程「先复现 → 再定位(CPU / 内存 / IO)→ 后优化」,CPU 密集找算法、IO 密集找等待。
- 🐳 进程管理 / systemd / Docker:supervisor 与 systemd 负责守护进程、崩溃自动拉起;Docker 背镜像 vs 容器、常用命令(build / run / exec / logs)、Dockerfile 最佳实践(固定 tag、层缓存、非 root)与容器排查命令。
覆盖范围:Git 命令与分支模型、Linux 排查命令、pytest 测试框架、常用设计模式的 Python 实现、性能分析与线上排查、进程管理与 Docker。 使用方式:命令/代码可直接复制运行;每节含对比表与面试追问,速记卡片见文末附录。
1. Git 版本控制¶
💡 定义(小白版):Git 是代码的「时光机 + 多人协作存档系统」——把代码每次改动记录成历史快照,随时对比、回退、合并。 🏷️ 类比:写论文时每改一版就「另存为 v1/v2/v3」,Git 就是自动帮你另存为,还能回到任何一版、看清任意两版差异。
1.1 核心命令清单¶
| 命令 | 作用 | 典型用法 / 参数 |
|---|---|---|
git init |
初始化仓库 | git init -b main 指定初始分支 |
git add |
暂存改动 | git add -p 分块暂存 |
git commit |
提交快照 | git commit -am "msg" 跳过暂存直接提交已跟踪文件 |
git status / git diff |
查看状态/差异 | git diff --staged 看已暂存差异 |
git branch |
分支管理 | git branch -d name / -D 强制删 |
git checkout / switch |
切换分支 | git switch -c feature/xxx 新建并切换 |
git merge |
合并(保留历史) | git merge --no-ff feature |
git rebase |
变基(重写历史) | git rebase -i HEAD~3 交互式整理提交 |
git cherry-pick |
挑选提交到当前分支 | git cherry-pick <commit-hash> |
git stash |
暂存未提交改动 | git stash push -m "wip" / git stash pop |
git reset |
回退(重写历史) | --soft(留暂存) / --mixed(留工作区) / --hard(全丢) |
git revert |
反向提交(追加新提交) | git revert <commit-hash> 安全回退已推送提交 |
git log |
查看提交历史 | git log --oneline --graph --all |
git reflog |
查看所有指针移动 | 找回被 reset 掉的提交 |
git fetch / pull / push |
远程同步 | git pull --rebase 拉取并变基 |
1.2 分支模型:Git Flow vs GitHub Flow¶
Git Flow(适合版本发布节奏固定、需要长期维护分支的团队):
master(稳定发布) ← merge --no-ff ← develop(集成分支)
develop ← feature/*(功能分支)
master ← hotfix/*(线上热修,直接合 master + develop)
master ← release/*(发布准备,只修 bug)
GitHub Flow(适合持续部署、发布频繁的团队):
main(永远可部署) ← feature 分支 → PR(Code Review) → 合并后自动部署
| 维度 | Git Flow | GitHub Flow |
|---|---|---|
| 分支数量 | 多(master/develop/feature/release/hotfix) | 少(main + 临时 feature) |
| 发布方式 | 版本节奏式(release 分支冻结) | 持续部署(PR 合入即上线) |
| 历史复杂度 | 复杂、--no-ff 合并图密集 |
线性、清爽 |
| 适用团队 | 传统版本发布、多版本并存维护 | 互联网快速迭代、CI/CD 成熟 |
| 学习成本 | 高 | 低 |
选择要点:需要同时维护 v1/v2/v3 多版本 → Git Flow;单版本快速上线 → GitHub Flow(或 trunk-based)。
1.3 冲突解决步骤¶
冲突发生在 merge / rebase / cherry-pick 时(双方修改同一文件同一区域)。标准流程:
1. 识别冲突文件:git status 显示 "both modified" / "Unmerged paths"
2. 打开冲突文件,定位 <<<<<<< HEAD / ======= / >>>>>>> 三段
3. 人工裁决:保留哪段 / 合并哪段 / 删除哪段,并删掉冲突标记
4. git add <文件> 标记为已解决
5a. merge 场景:git commit 完成合并
5b. rebase 场景:git rebase --continue;想放弃本次变基:git rebase --abort
伪代码(rebase 冲突期间的处理循环):
while 有冲突文件:
编辑解决 -> git add
git rebase --continue # 或 --skip 跳过该提交,--abort 整体放弃
⚠️ 易错点:rebase 冲突时不要用
git merge --continue;merge 冲突时也不要git rebase --continue,两者命令不同。rebase 会重写提交,不要在共享分支上 rebase。
1.4 rebase vs merge 对比¶
| 维度 | merge | rebase |
|---|---|---|
| 历史形态 | 保留分叉,形成合并提交 | 线性历史,提交被重放到新基点 |
| 是否重写提交 | 否 | 是(换 hash) |
| 冲突次数 | 一次合并解决一次 | 每个被重放的提交都可能冲突 |
| 可追踪性 | 保留「何时合并了哪个分支」 | 丢失原分叉信息 |
| 共享分支安全 | ✅ 安全 | ❌ 危险(会改写他人已有提交) |
| 典型场景 | 合并 feature 回主干 | 拉取远端时 pull --rebase 保持线性 |
黄金法则:绝不 rebase 已经 push 到共享仓库的分支。个人未推送的分支可自由 rebase。
1.5 reset vs revert¶
| 命令 | 效果 | 历史 | 适用 |
|---|---|---|---|
git reset --hard <sha> |
HEAD 回退,工作区丢弃 | 重写历史,reflog 可救 | 本地未推送提交 |
git reset --soft <sha> |
HEAD 回退,改动留在暂存区 | 重写历史 | 合并多个提交 |
git revert <sha> |
生成一个「反向提交」 | 追加新提交,历史不变 | 已推送 / 线上回滚 |
口诀:reset 回退「删掉过去」,revert 回退「否定过去」。已 push 的提交回退必须用 revert,否则 push 会被拒绝(non-fast-forward)。
1.6 面试追问¶
🧭 答法提示:被问「生产环境怎么选」时先给结论(个人分支 rebase、合主干 merge、共享分支绝不 rebase),再补一句理由;被问撤销时先分清「本地 vs 已推送」再给命令。
Q:rebase 和 merge 你生产环境怎么选?
A:个人未推送分支用 rebase 保持整洁;合入主干用 merge(--no-ff)保留合并语义。共享分支只 merge 不 rebase。
Q:代码已 push 又想撤销怎么办?
A:git revert <sha> 提交一个反向提交再 push;不要 reset 后强推(push -f),会破坏协作者的本地历史。
Q:cherry-pick 用在什么场景? A:把某个修复/功能单独搬到其他分支(如把 hotfix 挑到 develop),避免整条 merge;代价是重复提交,历史里会出现两份相同改动。
Q:stash 后如何找回?
A:git stash list 查看,git stash pop 恢复并删除记录;git stash apply 保留记录;误删可用 git fsck --lost-found 或 reflog 找回。
💡 面试点评:会背命令清单只是及格;加分点是场景判断——「已推送回退用 revert、共享分支不 rebase、stash 与冲突解决流程」这类实战判断。
2. Linux 常用命令与现场排查¶
💡 定义(小白版):Linux 是服务器上最常见的操作系统,本节教你怎么用命令「问」操作系统发生了什么。 🏷️ 类比:Windows 用鼠标点,Linux 用命令「发号施令」——先把命令当工具箱背熟,就能自己修服务器。
2.1 命令速查表¶
| 命令 | 用途 | 典型参数 |
|---|---|---|
ps |
查看进程快照 | ps aux 全量;ps -ef 标准格式;ps aux \| grep python 过滤 |
top |
实时进程/负载监控 | top -Hp <pid> 看线程;top -d 1 1 秒刷新;P/M 按 CPU/内存排序 |
free |
内存使用 | free -h 人类可读;free -m 以 MB 显示 |
df |
磁盘分区占用 | df -h;df -i 看 inode |
du |
目录/文件占用 | du -sh * 汇总当前目录各项;du -h --max-depth=1 |
grep |
文本匹配 | grep -n pattern file;-i 忽略大小写;-v 反向;-r 递归;-E 扩展正则 |
awk |
文本按列处理 | awk '{print $1}';awk '$4 > 90 {print}' 条件过滤 |
sed |
流编辑 | sed -n '5,10p' 打印行段;sed -i 's/old/new/g' 原地替换 |
netstat |
网络连接/端口 | netstat -tlnp 监听端口+进程;-u UDP;ss 是其现代替代 |
curl |
发送 HTTP 请求 | curl -i 带头;-X POST;-d '{}';-m 5 超时;-w "%{time_total}" 计时 |
tail |
查看文件尾部 | tail -f app.log 实时跟踪;-n 200 指定行数 |
2.2 五个「现场排查」场景¶
场景① 端口被占用(8080 起不来服务)
ss -tlnp | grep 8080 # 或 netstat -tlnp | grep 8080
lsof -i :8080 # 直接列出占用 8080 的进程
kill -9 <PID> # 确认是僵尸进程后强杀;否则先 kill <PID>
场景② 内存爆了(free 显示几乎耗尽 / 服务 OOM)
free -h # 确认 available 是否告急
ps aux --sort=-%mem | head -5 # 找出内存占用 TOP 进程
cat /proc/<pid>/smaps | grep -E "Rss|Swap" # 细看单进程内存分布
dmesg -T | grep -i "out of memory" # 看内核 OOM-Killer 记录
# 定位到进程后:优化或重启,必要时调 ulimit / 换机器
场景③ 磁盘满了(df 显示 100%,写入报 no space)
df -h # 定位哪个分区满了
du -sh /* 2>/dev/null | sort -rh | head # 找大目录(注意 / 通配要加 -x 避免跨分区)
find / -xdev -size +1G -type f 2>/dev/null # 找大文件
lsof +L1 2>/dev/null # 找已被删除但仍占空间的「幽灵文件」
# 清理后 df -h 确认;另查 df -i 排除 inode 耗尽
场景④ 进程假死(top 正常但请求全部超时 / 线程卡死)
ps -eo pid,ppid,stat,cmd | grep <服务名> # 看状态:D(不可中断)/Z(僵尸)/T(停止)
top -Hp <pid> # 看具体线程 CPU/状态
cat /proc/<pid>/task/<tid>/status | grep -E "State|voluntary_ctxt"
jstack <pid> | grep -A 20 "RUNNABLE" # Java 场景看线程栈
# D 状态:多为磁盘/网络 IO 卡死;Z 状态:父进程未 wait,找父进程处理
场景⑤ 日志过滤(从 GB 级日志找错误与统计)
grep -n "ERROR\|Exception" app.log | tail -50 # 过滤错误
tail -f app.log | grep --line-buffered "timeout" # 实时跟踪指定关键词
awk '$9 ~ /^5[0-9][0-9]$/ {print $9}' access.log | sort | uniq -c # 统计 5xx 数量
sed -n '/2024-06-01 10:00/,/2024-06-01 10:05/p' app.log # 按时间段切片
awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -10 # Top10 访问 IP
2.3 面试追问¶
🧭 答法提示:把命令按「场景串」答(定位 → 采样 → 处理),并主动提进阶用法(ss 替代 netstat、lsof +L1 找幽灵文件),显得有实战而不是背命令。
Q:ps 和 top 的区别? A:ps 是一次性快照,top 是实时刷新(还能看负载、按 CPU/内存排序);排查历史进程用 ps,监控实时状态用 top。
Q:df 和 du 的区别? A:df 看分区整体使用量(从文件系统统计),du 从目录遍历累加文件大小;du 更准但慢,df 与 du 数字不一致常因「已删除但仍被进程占用」的文件。
Q:awk 和 sed 各自擅长什么? A:awk 是按列处理 + 编程(字段、统计、条件),sed 是按行流编辑(打印区间、替换、删除行)。配合 grep(按行匹配)构成三件套。
Q:排查 CPU 100% 的命令串?
A:top -H -p <pid> 找烧 CPU 的线程 → strace -p <tid> 看系统调用 → 结合代码定位死循环/GC/自旋;Python 场景可用 py-spy dump --pid <pid> 直接拿 Python 栈。
💡 面试点评:命令要成组记忆(场景化输出命令串),面试官最反感「我只用过 ls/cd」。能说出
ss替代netstat、lsof +L1找幽灵文件这类进阶用法是加分项。
3. pytest 测试框架¶
💡 定义(小白版):pytest 是 Python 的测试框架:你写「假设输入 X 应该得到 Y」的测试函数,pytest 自动找到它们并运行,失败时告诉你差在哪。 🏷️ 类比:质检员:你把「检查标准」写成测试,pytest 替你逐条验收,不合格的标红报告。
3.1 核心概念¶
pytest 是 Python 主流测试框架,特点:函数式用例(无需类)、自动发现(test_*.py / test_* 函数)、丰富断言(纯 assert,失败时自动显示上下文)、强大 fixture 体系。
# test_demo.py —— 最简用例
def add(a, b):
return a + b
def test_add():
assert add(1, 2) == 3 # 直接 assert,失败自动展示 diff
运行:pytest -v(详细)/ pytest test_demo.py::test_add(单个)/ pytest -x(失败即停)/ pytest --pdb(失败进调试器)。
3.2 fixture 原理与 scope¶
fixture 是可复用的测试依赖注入:pytest 根据测试函数参数名自动查找同名 fixture,并在测试前后执行 setup/teardown(yield 之前是 setup,之后是 teardown)。
import pytest
@pytest.fixture
def db_conn():
print("\n[setup] 建立数据库连接")
conn = {"connected": True}
yield conn # 测试拿到的是 yield 出来的值
print("[teardown] 关闭连接") # 测试结束后自动执行
def test_query(db_conn):
assert db_conn["connected"] is True
scope 控制生命周期:
| scope | 生命周期 | 适用 |
|---|---|---|
function(默认) |
每个测试函数独立 | 大部分场景 |
class |
每个测试类一次 | 类内共享 |
module |
每个模块一次 | 模块级共享资源 |
session |
整个测试会话一次 | 数据库、昂贵连接 |
@pytest.fixture(scope="session")
def big_cache():
return {} # 整个测试会话只建一次
fixture 依赖:fixture 可以引用其他 fixture(参数名即依赖),pytest 自动拓扑排序执行;autouse=True 让所有测试自动使用(无参数依赖时)。
@pytest.fixture
def user(db_conn): # 依赖 db_conn
return {"id": 1, "name": "alice"}
3.3 参数化 parametrize¶
@pytest.mark.parametrize 把同一用例跑多组数据,避免复制代码:
import pytest
@pytest.mark.parametrize("a,b,expected", [
(1, 2, 3),
(0, 0, 0),
(-1, 1, 0),
(100, 200, 300),
], ids=["case1", "zero", "neg", "big"]) # ids 自定义用例名
def test_add(a, b, expected):
assert add(a, b) == expected
笛卡尔积组合:多个 parametrize 叠加 = 全组合;同一用例参数从 fixture 拿(indirect=True)也常见。
3.4 mock / monkeypatch¶
monkeypatch 是 pytest 内置 fixture,用于运行时替换属性/环境变量(如打桩网络请求):
# 打桩:不真实发 HTTP
def get_weather(city):
import urllib.request
with urllib.request.urlopen(f"http://api/weather/{city}") as r:
return r.read().decode()
def test_get_weather(monkeypatch):
def fake_urlopen(url):
return io.StringIO('{"temp": 25}')
monkeypatch.setattr("urllib.request.urlopen", fake_urlopen) # 运行时替换
assert "25" in get_weather("beijing")
unittest.mock / pytest-mock(mocker fixture)提供更强的 Mock 对象(断言调用次数/参数、自动清理):
# 需安装 pytest-mock:pip install pytest-mock
def test_calls(mocker):
fake = mocker.patch("module.send_email") # 自动 mock 并还原
call_api()
fake.assert_called_once_with(to="a@b.com") # 断言调用参数
⚠️ 易错点:patch 的路径要打「被使用时」的模块(
app.utils.send_email)而非定义处;monkeypatch 改动自动还原,这是它比手动 setattr 安全的原因。
3.5 断言风格¶
- 原生
assert,失败自动 diff(pytest 会反编译语句展示左右值); - 异常断言:
pytest.raises(ZeroDivisionError);近似比较:pytest.approx;字符串包含:in。
import pytest
def divide(a, b):
if b == 0:
raise ZeroDivisionError("b cannot be 0")
return a / b
def test_divide_error():
with pytest.raises(ZeroDivisionError, match="cannot"):
divide(1, 0)
def test_approx():
assert 0.1 + 0.2 == pytest.approx(0.3) # 浮点近似比较
3.6 完整可运行示例¶
# test_order.py —— 可直接 pytest 运行
import pytest
from unittest import mock
class Order:
def __init__(self, items):
self.items = items
def total(self):
return sum(i["price"] for i in self.items)
def pay(self, gateway):
return gateway.charge(self.total())
@pytest.fixture(scope="function")
def order():
return Order([{"name": "apple", "price": 10},
{"name": "banana", "price": 5}])
@pytest.mark.parametrize("extra,expected", [([], 15), ({"name": "x", "price": 100}, 115)])
def test_total(order, extra, expected):
order.items = order.items + extra
assert order.total() == expected
def test_pay_mock(order, mocker): # mocker 需要 pytest-mock
fake_gw = mocker.Mock(charge=mocker.Mock(return_value="OK"))
assert order.pay(fake_gw) == "OK"
fake_gw.charge.assert_called_once_with(15)
3.7 面试追问¶
🧭 答法提示:pytest 追问的核心是「fixture 参数名即依赖注入 + yield 做 teardown + scope 控生命周期」,答完这三点再补一个你写过的真实用例,不要只背概念。
Q:fixture 的 teardown 怎么保证一定执行?
A:yield 之后的代码在测试结束无论成败都会执行(类似 finally);也支持 addfinalizer。这是 pytest 比 setup/teardown 旧式写法更可靠的核心理由。
Q:参数化用例失败如何定位哪组数据?
A:pytest 会为每组生成带参数用例名(ids 可自定义);pytest -k 过滤、pytest -vv 显示参数化全名。
Q:mock 与真实依赖怎么权衡? A:单元测试尽量 mock 外部边界(网络/DB/时间);集成测试走真实依赖。过度 mock 会让测试「测试自己的 mock」,失去意义。
💡 面试点评:能现场说清「fixture 参数名即依赖注入 + yield 做 teardown + scope 生命周期 + parametrize 组合」四件事,pytest 题基本无死角。
4. 常用设计模式与 Python 实现¶
💡 定义(小白版):设计模式 = 前辈们总结出的「常见问题的标准解法」套路,让代码更好改、更好懂。本节先懂「解决什么问题 + 生活类比」,再记 Python 写法。 🏷️ 类比:做菜的「菜谱模板」:回锅肉有回锅肉的做法套路,模式就是写代码的套路菜谱。
4.1 单例模式(3 种写法)¶
定义:保证一个类只有一个实例,并全局可访问。适用:配置中心、连接池、日志器。
写法一:__new__ 拦截(最标准)
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
s1, s2 = Singleton(), Singleton()
print(s1 is s2) # True
写法二:装饰器
def singleton(cls):
instances = {}
def get_instance(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return get_instance
@singleton
class Config:
pass
print(Config() is Config()) # True
写法三:模块级单例(Python 惯用法)
# singleton_module.py
class _Logger:
def __init__(self):
self.level = "INFO"
logger = _Logger() # 模块导入即单例,最 Pythonic
⚠️ 易错点:单例不是线程安全的(
__new__竞态),多线程下需加锁;测试中单例难以隔离,常用工厂注入替代。面试常追问「单例的坏处」——答:全局可变状态、隐藏依赖、难以测试。
4.2 工厂模式(Factory)¶
定义:把「创建对象」的逻辑封装,客户端不依赖具体类。适用:产品族多、创建逻辑复杂(如根据配置创建不同模型/存储后端)。
class Storage:
def save(self, data): ...
class S3Storage(Storage):
def save(self, data): return f"S3 saved {data}"
class LocalStorage(Storage):
def save(self, data): return f"local saved {data}"
class StorageFactory: # 简单工厂
@staticmethod
def create(kind):
if kind == "s3":
return S3Storage()
if kind == "local":
return LocalStorage()
raise ValueError(kind)
print(StorageFactory.create("s3").save("x")) # S3 saved x
抽象工厂 / 工厂方法:把创建逻辑下沉到子类(create 是抽象方法),扩展新产品只需加子类,符合开闭原则。
4.3 观察者模式(Observer)¶
定义:发布-订阅——被观察者状态变化时自动通知所有订阅者。适用:事件系统、UI 回调、指标上报。
class Subject:
def __init__(self):
self._observers = []
def attach(self, obs): self._observers.append(obs)
def detach(self, obs): self._observers.remove(obs)
def notify(self, event):
for obs in self._observers:
obs.update(event)
class EmailNotifier: # 观察者 1
def update(self, event): print(f"[email] {event}")
class LogNotifier: # 观察者 2
def update(self, event): print(f"[log] {event}")
s = Subject()
s.attach(EmailNotifier())
s.attach(LogNotifier())
s.notify("user registered")
# [email] user registered
# [log] user registered
Python 内置替代:asyncio 事件、Observable(Rx)或直接用回调列表——观察者模式的本质就是回调注册表。
4.4 策略模式(Strategy)¶
定义:把可替换的算法族封装成对象,运行时切换。适用:多种排序/计价/压缩/路由算法。
class QuickSort:
def sort(self, data): return sorted(data) # 简化示例
class MergeSort:
def sort(self, data): return sorted(data, reverse=False)
class Sorter: # 上下文:持有策略
def __init__(self, strategy):
self.strategy = strategy
def run(self, data):
return self.strategy.sort(data)
sorter = Sorter(QuickSort())
print(sorter.run([3, 1, 2])) # [1, 2, 3]
sorter.strategy = MergeSort() # 运行时切换策略
与函数式对比:Python 中策略常简化为传函数(sorted(data, key=...))——策略模式本质是「依赖注入算法」;面试可指出「一等函数让策略模式退化为高阶函数」。
4.5 装饰器模式(结构型,区别于 Python 装饰器语法)¶
定义:动态给对象添加职责,用组合替代继承。适用:给类/对象叠加日志、鉴权、缓存而不改动原类。
class TextComponent:
def render(self): return "hello"
class BoldDecorator: # 装饰者:包装并增强
def __init__(self, wrapped):
self._wrapped = wrapped
def render(self):
return f"**{self._wrapped.render()}**"
t = BoldDecorator(TextComponent())
print(t.render()) # **hello**
# 可无限叠加:BoldDecorator(ItalicDecorator(TextComponent()))
与 Python 装饰器语法的关系:语法糖装饰器本质也是「函数包装函数」,二者理念相同——包装 + 透传 + 增强。
4.6 设计模式对比表¶
| 模式 | 类型 | 核心思想 | Python 场景 |
|---|---|---|---|
| 单例 | 创建型 | 全局唯一实例 | 配置/连接池 |
| 工厂 | 创建型 | 创建逻辑封装 | 存储后端、模型工厂 |
| 观察者 | 行为型 | 发布-订阅解耦 | 事件、回调 |
| 策略 | 行为型 | 算法族可替换 | 排序/计价策略 |
| 装饰器 | 结构型 | 组合叠加职责 | 日志/鉴权/缓存包装 |
4.7 面试追问¶
🧭 答法提示:每个模式按「解决什么问题 → Python 天然替代 → 有什么坑」三句答,被追问时再展开具体写法;主动提「先看变化点再套模式」是加分话术。
Q:单例和全局变量的区别? A:单例保证唯一实例 + 统一入口,可延迟创建、可继承控制;但仍属于全局可变状态,是两者共同的缺点。现代框架更推崇「依赖注入 + 容器管理生命周期」。
Q:观察者模式有什么坑? A:订阅者忘记反注册会内存泄漏(被 Subject 强引用);通知顺序不应被依赖;异常会中断通知链。Python 中注意循环引用导致 GC 回收问题。
Q:策略模式在 Python 里怎么简化? A:算法少时直接传函数/lambda(一等公民),只有策略多、需配置与校验时才用类封装——「过度设计」也是面试要主动避免的点。
💡 面试点评:设计模式题的关键不是背 UML,而是场景 + 权衡。每个模式能说出「解决什么问题、Python 里的天然替代、有什么坑」即高分。
5. 性能分析与线上排查¶
💡 定义(小白版):性能分析 = 找出「程序慢在哪、内存吃在哪」并用数据证明优化效果的过程。 🏷️ 类比:家里网慢,先看是路由、宽带还是电脑的问题——定位到具体环节再修,别瞎换设备。
5.1 分析工具四件套¶
① timeit(微观基准):对代码片段精确计时(默认百万次),排除系统噪音:
import timeit
print(timeit.timeit("[x for x in range(1000)]", number=10000))
print(timeit.timeit("list(range(1000))", number=10000)) # 后者明显更快
② cProfile(函数级 CPU 剖析):记录每个函数调用次数与耗时,定位热点:
python -m cProfile -s cumtime my_script.py # 按累计耗时排序
import cProfile, pstats
cProfile.run("sum(range(1_000_000))", "prof.out")
pstats.Stats("prof.out").sort_stats("cumulative").print_stats(10)
③ line_profiler(逐行剖析):@profile 装饰器标注函数,输出每行耗时(需 pip install line_profiler):
@profile # kernprof -l -v my_script.py
def process(data):
total = 0
for x in data: # 这行如果占大头,说明循环是瓶颈
total += x * x
return total
④ memory_profiler(内存剖析):@profile 看每行内存增量(需 pip install memory_profiler);tracemalloc 用于精确定位内存泄漏快照对比:
import tracemalloc
tracemalloc.start()
a = [list(range(1000)) for _ in range(100)] # 模拟分配
snap1 = tracemalloc.take_snapshot()
b = [list(range(1000)) for _ in range(100)]
snap2 = tracemalloc.take_snapshot()
top = snap2.compare_to(snap1, 'lineno')
for stat in top[:3]:
print(stat)
5.2 排查流程¶
CPU 100% 排查步骤:
1. top → 找高 CPU 进程 PID
2. top -Hp <pid> → 找具体线程 TID
3. 采样线程栈:strace -p <tid>(系统调用) / py-spy dump --pid <pid>(Python 栈)
4. 结合代码定位:死循环 / 忙等 / 过度 GC / 低效算法
5. 修复后对比验证(cProfile 前后 profile 对比)
OOM / 内存暴涨排查步骤:
1. free -h + dmesg -T | grep -i oom → 确认 OOM-Killer
2. ps aux --sort=-%mem → 找出大内存进程
3. tracemalloc 快照对比 → 判断「泄漏」还是「正常增长」
4. 排查方向:缓存无上限 / 全局 list 累积 / 循环引用未回收 / 大对象常驻
5. 修复:限流缓存、分页处理、gc.collect 兜底、减小批大小
慢接口排查步骤:
1. 确认现象:curl -w "%{time_connect} %{time_starttransfer}" 分段计时
2. 区分阶段:网络耗时?服务处理耗时?下游耗时?
3. 服务端:cProfile 定位函数热点;慢 SQL 用 EXPLAIN 分析索引
4. 并发视角:连接池耗尽 / 锁竞争 / 单线程事件循环被阻塞
5. 验证:压测(wrk/ab)对比修复前后 p99 延迟
5.3 对比表¶
| 工具 | 粒度 | 成本 | 定位的问题 |
|---|---|---|---|
timeit |
代码片段 | 极低 | 某段代码谁快 |
cProfile |
函数级 | 中(有开销) | 热点函数、调用次数 |
line_profiler |
行级 | 高 | 具体哪行是瓶颈 |
memory_profiler |
行级内存 | 高 | 内存分配热点 |
tracemalloc |
分配点 | 中 | 内存泄漏 |
5.4 面试追问¶
🧭 答法提示:把「工具链(timeit→cProfile→line_profiler→memory_profiler)」和「排查流程(top→定位→采样→验证)」讲成方法论,再补一个你真实排查过的案例,比背工具定义加分得多。
Q:cProfile 的 overhead 会影响结果吗?
A:会。它给每个函数插桩,总耗时被放大(尤其高频小函数);结论应看相对占比而非绝对时间。低开销替代:py-spy(采样式,不插桩)。
Q:线上没装 profile 工具怎么排查?
A:用 py-spy(采样 Python 栈,无需改代码);或临时加日志打点(埋点计时);或导出 profile 到文件离线分析。绝不在线上直接跑完整 cProfile。
Q:内存泄漏 vs 内存增长怎么区分? A:泄漏 = 回收不了(tracemalloc 快照间持续增长且无法解释);增长 = 正常业务(缓存、池、批处理)。判断标准:跑两轮相同负载,比较内存快照差异。
💡 面试点评:把「工具链(timeit→cProfile→line_profiler→memory_profiler)」与「排查流程(top→定位→采样→验证)」串成方法论,面试官会追问「具体一次你怎么做的」,提前准备一个真实案例。
6. 进程管理工具与 Docker¶
💡 定义(小白版):进程管理 = 让程序「开机自启、崩溃自动拉起、日志可查」的一套保障机制。 🏷️ 类比:给项目请个 24 小时保安:程序倒了它立刻扶起来,还写值班日志。
6.1 supervisor / systemd¶
supervisor:Python 生态的进程管理守护进程,负责拉起、监控、自动重启业务进程(非 init 系统,跑在用户态):
; /etc/supervisor/conf.d/app.conf
[program:app]
command=python -m app.server ; 启动命令
directory=/srv/app
autostart=true ; 开机自动启动
autorestart=true ; 崩溃自动重启
stderr_logfile=/var/log/app.err ; 日志
stdout_logfile=/var/log/app.out
numprocs=1
supervisorctl status # 查看全部
supervisorctl restart app # 重启指定
supervisorctl tail -f app # 跟踪日志
systemd:现代 Linux 的系统级 init 与服务管理器,管理系统服务、开机自启、依赖、资源限制:
# /etc/systemd/system/app.service
[Unit]
Description=My App
After=network.target
[Service]
ExecStart=/usr/bin/python /srv/app/server.py
Restart=always # 崩溃自动重启
RestartSec=3
User=www
LimitNOFILE=65535 # 文件描述符上限
[Install]
WantedBy=multi-user.target
systemctl daemon-reload # 修改配置后重载
systemctl start/stop/restart app
systemctl status app # 查看状态与最近日志
systemctl enable app # 开机自启
journalctl -u app -f # 跟踪服务日志
对比表:
| 维度 | supervisor | systemd |
|---|---|---|
| 定位 | 应用级进程管家(用户态) | 系统级服务管理(PID 1) |
| 自启 | 依赖外部 init 拉它 | ✅ 原生开机自启 |
| 资源限制 | 弱 | 强(Limit*、cgroup) |
| 日志 | 文件 | journald 统一收集 |
| 适用 | Python/脚本进程、无 systemd 环境 | 现代 Linux 全场景 |
6.2 Docker 基础命令¶
Docker 用容器(共享内核的隔离进程 + 镜像层文件系统)打包应用。核心命令:
| 命令 | 作用 | 典型用法 |
|---|---|---|
docker build |
按 Dockerfile 构建镜像 | docker build -t myapp:1.0 . |
docker run |
启动容器 | docker run -d -p 8080:80 --name web myapp:1.0 |
docker ps |
查看容器 | docker ps -a 含已停止;docker ps -f name=web 过滤 |
docker logs |
查看容器日志 | docker logs -f --tail 100 web |
docker exec |
进入运行中容器 | docker exec -it web bash |
docker stop/rm |
停止/删除容器 | docker rm -f web |
docker images / rmi |
镜像管理 | docker rmi myapp:old |
docker compose up |
多容器编排 | docker compose up -d |
Dockerfile 最小示例:
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt # 依赖层:改动少时利用层缓存
COPY . .
CMD ["python", "app.py"]
docker build -t myapp:1.0 .
docker run -d -p 8000:8000 --restart=unless-stopped myapp:1.0
docker ps
docker logs -f $(docker ps -q -f ancestor=myapp:1.0)
docker exec -it $(docker ps -q -f ancestor=myapp:1.0) bash
⚠️ 易错点:
docker exec进的是运行中容器,docker run是新容器;docker logs只看 stdout/stderr,进程直接写文件的日志看不到;容器内进程 PID 1 退出 = 容器退出(要前台运行应用)。
6.3 面试追问¶
🧭 答法提示:Docker 题抓住「镜像 vs 容器(类 vs 实例)、-p 端口映射、exec 进容器排障、重启策略」四件事讲透;能讲清「容器共享宿主机内核」即通过。
Q:容器和虚拟机的区别? A:虚拟机有独立内核(Hypervisor 虚拟化硬件),隔离强、开销大;容器共享宿主机内核(cgroup + namespace 隔离),秒级启动、镜像分层复用。隔离强度弱于虚拟机(逃逸风险更高)。
Q:supervisor 的 autorestart 与 systemd 的 Restart 区别?
A:本质相同——守护进程监控子进程退出码自动拉起;systemd 还能做资源限制、开机自启、日志统一。Docker 里则用 --restart 策略(unless-stopped/always)。
Q:线上容器如何查问题?
A:docker logs 看输出 → docker exec 进容器用 ps/top 看资源 → docker inspect 看配置/挂载 → 宿主机 docker stats 看资源占用。注意容器内可能没有调试工具(需挂载或换镜像)。
💡 面试点评:Docker 题常考「镜像与容器区别(类 vs 实例)、
-p端口映射、exec 进容器排障、重启策略」四件事;能把「容器共享内核」讲透即通过。
附录:速记卡(一句话 × 6 主题)¶
💡 定义(小白版):附录是「考前速记卡」——每章只留一句话精华,考前扫一遍唤醒记忆。 🏷️ 类比:考试前看提纲:把 200 页书浓缩成 6 张小抄,进考场前再背一遍。
- Git:merge 保留分叉、rebase 线性重写;共享分支禁 rebase;已推送回退用 revert;冲突 = 三段标记 + add + continue。
- Linux:
ss/ps/top/free/df/du/grep/awk/sed/curl/tail成组记忆,排查按「定位进程 → 采样 → 验证」走流程。 - pytest:fixture 参数名注入 + yield 做 teardown + scope 控生命周期;parametrize 多组数据;monkeypatch/mocker 打桩。
- 设计模式:单例 3 写法、工厂解耦创建、观察者发布订阅、策略算法可换、装饰器组合加职责——每个都要能说场景与坑。
- 性能分析:timeit→cProfile→line_profiler→memory_profiler 递进;线上用 py-spy 采样;排查先 top 定位再取样。
- 进程管理:supervisor 应用级管家,systemd 系统级,Docker 容器共享内核、镜像分层、
exec进容器排障。