跳转至

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 张小抄,进考场前再背一遍。

  1. Git:merge 保留分叉、rebase 线性重写;共享分支禁 rebase;已推送回退用 revert;冲突 = 三段标记 + add + continue。
  2. Linux:ss/ps/top/free/df/du/grep/awk/sed/curl/tail 成组记忆,排查按「定位进程 → 采样 → 验证」走流程。
  3. pytest:fixture 参数名注入 + yield 做 teardown + scope 控生命周期;parametrize 多组数据;monkeypatch/mocker 打桩。
  4. 设计模式:单例 3 写法、工厂解耦创建、观察者发布订阅、策略算法可换、装饰器组合加职责——每个都要能说场景与坑。
  5. 性能分析:timeit→cProfile→line_profiler→memory_profiler 递进;线上用 py-spy 采样;排查先 top 定位再取样。
  6. 进程管理:supervisor 应用级管家,systemd 系统级,Docker 容器共享内核、镜像分层、exec 进容器排障。

教程来源:Akun-python/autumn-recruitment。 MIT 许可证全文。