Python 后端面试
定位:这是一份面试速查文档——按后端实际考察模块组织,每个条目只讲「机制 + 取舍 + 出问题怎么办」, 目标是考场上能快速回忆。深度讲解、源码剖析和算法题仍在
01.interview-of-python.md, 两者职责分离:那份用来理解,这份用来应试。答题节奏:好的回答是「机制 → 取舍 → 收住」——先一句话说清机制,再点出代价或适用边界,然后停住等追问。 只背结论会在第二层「底层怎么实现」处卡住。
重点索引
标记说明:🔥🔥🔥 公共必考(时间不够先吃透) | 🔥🔥 高频 | 🔥 按 JD 深度🎙️ = 配了 90 秒口述版。
| 模块 / 编号 | 题目 | 重点 | 口述版 |
|---|---|---|---|
| 一·1 | GIL 与多线程跑不满多核 | 🔥🔥🔥 | 🎙️ |
| 一·2 | 装饰器与闭包 | 🔥🔥🔥 | — |
| 一·3 | 生成器为什么省内存 | 🔥🔥🔥 | — |
| 一·4 | 垃圾回收与内存泄漏 | 🔥🔥🔥 | 🎙️ |
| 一·5 | 可变默认参数陷阱 | 🔥🔥🔥 | — |
| 一·6 | is/==、深浅拷贝、可变不可变 | 🔥🔥🔥 | — |
| 一·7 | *args/**kwargs、上下文管理器 | 🔥🔥 | — |
| 二·1 | Django / Flask / FastAPI 对比 | 🔥🔥 | 🎙️ |
| 二·2 | Django 请求生命周期 | 🔥🔥 | — |
| 三·1 | N+1 与 select_related / prefetch_related | 🔥🔥🔥 | 🎙️ |
| 四·1 | 缓存穿透/击穿/雪崩 | 🔥🔥🔥 | — |
| 四·2 | Redis 为什么快 / 持久化 / 一致性 | 🔥🔥 | — |
| 五·1 | 协程与 asyncio 陷阱 | 🔥🔥🔥 | 🎙️ |
| 五·2 | 多线程/多进程/协程如何选 | 🔥🔥🔥 | — |
| 六·1 | 缓存模式 / 限流算法 | 🔥🔥 | — |
| 六·2 | 网络高频点(TCP/HTTP/TLS/IO 多路复用) | 🔥🔥 | — |
一、Python 语言核心(公共必考区)
这一块是 Python 后端面试的公共必考区,字节、腾讯、华为、美团反复出题,围绕的始终是 GIL、装饰器、生成器、内存管理 这几件事。
1.1 GIL:是什么?为什么多线程跑不满多核? 🔥🔥🔥
🎙️ 90 秒口述版
GIL 是 CPython 解释器的全局锁,同一时刻只允许一个线程执行 Python 字节码。它存在的初衷是保护引用计数这些解释器内部状态——如果每个对象都单独加锁,代价太大,索性用一把全局锁。
后果要分两种场景说。CPU 密集型任务,因为任一时刻只有一个线程在跑字节码,多线程没法并行利用多核,而且线程切换本身有开销,多线程甚至可能比单线程更慢。但 I/O 密集型不一样——线程在等 I/O 时会主动释放 GIL,别的线程就能接着跑,所以多线程或协程对 I/O 密集场景依然有效。
那 CPU 密集的出路是什么?用
multiprocessing多进程绕过 GIL,或者把热点交给 NumPy、C 扩展这类会释放 GIL 的库。最后我会补一句:GIL 是 CPython 的实现细节,不是 Python 语言规范的一部分,Jython、PyPy 就没有这个限制。
答题要点
- 本质:CPython 解释器的全局锁,同一时刻只允许一个线程执行 Python 字节码;设计初衷是保护引用计数等解释器内部状态,避免给每个对象单独加锁。
- 后果分场景:
- CPU 密集型:多线程无法并行利用多核,甚至可能更慢(切换开销 + 同一时刻只有一个线程执行)。
- I/O 密集型:等待时线程主动释放 GIL,多线程/协程依然有效。
- 出路:
multiprocessing,或把热点交给 NumPy / C 扩展这类会释放 GIL 的库。
追问:GIL 为什么让多线程跑不满 CPU?——见上,CPU 密集下切换开销 + 串行执行,反而更慢。
1.2 装饰器与闭包 🔥🔥🔥
问题:装饰器的本质是什么?写一个统计耗时的装饰器。
答题要点
- 装饰器是一个可调用对象,接收函数并返回新的包装函数,底层依赖函数是一等公民和闭包作用域绑定。
@decorator等价于fn = decorator(fn)。- 常见用途:缓存、权限校验、日志、计时、重试。
- 用
functools.wraps保留原函数元信息(__name__、__doc__)。
import time, functools
def timer(fn):
@functools.wraps(fn)
def wrapper(*args, **kwargs):
start = time.perf_counter()
try:
return fn(*args, **kwargs)
finally:
print(f"{fn.__name__} cost {time.perf_counter() - start:.3f}s")
return wrapper1.3 生成器为什么省内存 🔥🔥🔥
问题:生成器为什么省内存?和列表的本质区别是什么?
答题要点
- 列表一次性把所有元素放进内存;生成器惰性求值,一次只产出一个值,内存接近常数。
- 适合超大文件、无限序列;代价是只能迭代一次,不支持索引和随机访问。
- 高频追问:
yield与return的区别、yield from的作用(委托子生成器)。
1.4 内存管理与垃圾回收 🔥🔥🔥
🎙️ 90 秒口述版
CPython 以引用计数为主,对象引用数归零就立即释放,这是最直接的回收方式。但引用计数有个死穴——处理不了循环引用,比如两个对象互相引用,计数永远不为零。所以辅以标记清除来回收这种环,再用分代回收提高效率。
分代回收的思路是:对象按存活时间分三代,越年轻的对象回收越频繁。依据是"大部分对象朝生暮死",年轻代里能回收的比例高,频繁扫它性价比最大;熬过多轮扫描的对象才晋升到老年代,扫描频率降低,从而减少全量扫描的开销。
最后一个必答的延伸:既然有 GC,为什么还会内存泄漏?因为 GC 只回收"不可达"的对象,如果对象被一条意外的引用链挂着,它还是可达的。常见来源:全局缓存或单例无限增长、注册了却没注销的回调、
__del__里的循环引用等。所以泄漏的根因通常是持有链没断开,不是 GC 失灵。
答题要点
- 引用计数为主:引用归零立即释放。
- 标记清除:解决循环引用(引用计数处理不了环)。
- 分代回收:对象分三代,越年轻回收越频繁,减少全量扫描开销。
- 为什么还泄漏:全局缓存/单例无限增长、未注销的回调、
__del__中的循环引用——本质是持有链未断开,对象仍可达。
1.5 可变默认参数陷阱 🔥🔥🔥
问题:def f(x, items=[]) 为什么危险?
答题要点
默认参数在函数定义时求值一次,所有调用共享同一个列表,对它的修改会泄漏到后续调用之间。正确写法是 items=None,在函数体内再初始化。
# 危险
def bad(x, items=[]):
items.append(x)
return items
# 正确
def good(x, items=None):
items = [] if items is None else items
items.append(x)
return items这题考察的是你是否真正理解 Python 的求值时机。
1.6 is/==、深浅拷贝、可变与不可变 🔥🔥🔥
答题要点
==比较值,is比较内存地址(引用)。- 浅拷贝只复制最外层容器,内部嵌套对象仍共享引用;深拷贝递归复制。对应
copy.copy/copy.deepcopy。 - 不可变对象(int、str、tuple)不是"线程安全"的充分条件。追问"元组一定不可变吗":元组本身不可变,但内部若含可变对象(如
([1],)),整体状态仍可能变化。
1.7 *args/**kwargs、上下文管理器、类方法/静态方法 🔥🔥
答题要点
*args收集位置参数为元组,**kwargs收集关键字参数为字典。- 上下文管理器
with依赖__enter__/__exit__,用于资源确定性释放;也可用contextlib.contextmanager基于生成器实现。 @classmethod第一个参数是cls;@staticmethod无隐式参数;@property把方法变成属性访问。
二、Web 框架:Django / Flask / FastAPI
框架对比是后端面试的重难点,不能停留在"Django 大而全、Flask 小而快",要从设计理念、核心组件、适用场景三个维度展开。
2.1 三大框架对比 🔥🔥
🎙️ 90 秒口述版
我不会只说"大而全和小而快",而是从设计理念、核心组件、适用场景三个维度对比。
Django 的理念是 batteries-included、约定优于配置,内置 ORM、Admin、认证、模板,价值在于一站式约定降低长期维护成本,适合全功能 Web 应用和快速 MVP。Flask 是微框架,核心只有 Werkzeug 和 Jinja2,价值在于控制力——你只引入需要的组件,适合小型应用和高度定制的架构。FastAPI 为 API 而生,基于 Starlette 和 Pydantic,原生 async/await,靠类型提示自动校验、自动生成 Swagger 文档。
这里有个关键取舍一定要点出来:FastAPI 的"快"主要不是语法层面的快,而是异步 I/O + Pydantic 校验 + 自动文档三者叠加,尤其 I/O 密集高并发场景优势明显。最后收一句:三者没有绝对优劣,选型看团队规模和场景——要快速交付选 Django,要极致控制选 Flask,要高性能 API 选 FastAPI。
| 维度 | Django | Flask | FastAPI |
|---|---|---|---|
| 设计理念 | Batteries-included,约定优于配置 | 微框架,核心极简、扩展按需 | 为 API 而生,基于类型提示和标准 |
| 核心组件 | 内置 ORM、Admin、认证、模板 | 仅 Werkzeug + Jinja2 | Starlette(ASGI)+ Pydantic |
| 数据验证 | Form / Serializer | 依赖第三方 | 类型提示 + Pydantic 自动验证 |
| API 文档 | 需集成第三方 | 需集成第三方 | 自动生成 Swagger / ReDoc |
| 性能 | 同步为主,可经 ASGI 支持异步 | 同步 | 原生 async/await,I/O 密集优势明显 |
| 适用场景 | 全功能 Web、CMS、快速 MVP | 小型应用、高度定制 | 高性能 API、微服务、强校验、实时 |
关键取舍
- FastAPI 的"快" = 异步 I/O + Pydantic 校验 + 自动文档叠加,非语法层面。
- Django 的价值 = 一站式约定降低长期维护成本。
- Flask 的价值 = 控制力,只引入需要的组件。
2.2 Django 请求生命周期 🔥🔥
答题骨架:WSGI/ASGI 服务器 → 中间件栈 → URL 解析 → 视图(常经 ORM)→ 响应 → 中间件回程。
能点出中间件、URL 解析、视图、响应四个环节即可体现对框架的心智模型。
三、Django ORM 与数据库
3.1 N+1 问题与 select_related / prefetch_related 🔥🔥🔥
🎙️ 90 秒口述版
N+1 指的是先查一次列表,再对每条记录查一次关联对象,总共 1+N 次查询——数据量大时这就是性能灾难。
Django 给两个工具,区别就在 SQL 层面怎么执行。
select_related用 SQL JOIN 一次查完,把关联表的数据一起捞回来,适用于 ForeignKey / OneToOne 这种单值关系。prefetch_related是分两步:先查主表,再按主键批量查关联表,然后在 Python 层拼接,适用于 ManyToMany 和反向一对多这种多值关系——因为多值关系用 JOIN 会产生笛卡尔积、数据重复。选择逻辑就是:单值用 select_related 一次 JOIN,多值用 prefetch_related 两次查询。另外 DRF 序列化器里特别容易触发 N+1,因为序列化每条记录时都会去访问关联字段——能点出这一点是加分项。我自己的项目里就用 select_related 把一个接口的查询从 1+N 降到了固定的 2 次。
答题要点
select_related | prefetch_related | |
|---|---|---|
| 实现方式 | SQL JOIN 一次查完 | 两步查询(主表 + 批量查关联表),Python 层拼接 |
| 适用关系 | ForeignKey / OneToOne(单值) | ManyToMany / 反向一对多(多值) |
| 原因 | 单值 JOIN 无数据重复 | 多值 JOIN 会产生笛卡尔积、数据重复 |
- N+1:先查列表(1 次),再对每条查关联(N 次),共 1+N 次。
- 加分项:DRF 序列化器中 N+1 极常见——序列化时访问关联字段会触发查询。
3.2 MySQL 索引 / 事务隔离级别 🔥🔥
这两块属于数据库面试的核心,深度内容已独立成册,本处只保留速记要点:
- B+ 树胜出原因:非叶子只存键不存数据,扇出大、树矮、磁盘 IO 少;所有查询走到叶子,效率稳定;叶子链表天然支持范围查询和排序。
- 必掌握概念:聚簇索引(叶子存完整行,一表一个)、二级索引(叶子存主键,需回表)、覆盖索引(查询列全在索引中)、最左前缀原则(遇范围查询停止)、索引失效场景(函数、前导
%、隐式转换、OR中一列无索引)。 - 事务隔离级别:InnoDB 默认 RR;靠 MVCC 快照读解决不可重复读,靠间隙锁/临键锁基本解决幻读。
- 完整追问链、口述版与踩分点 → MySQL 面试。
四、Redis 与缓存
4.1 缓存穿透 / 击穿 / 雪崩 🔥🔥🔥
答题要点
- 穿透:查不存在的 key,请求直达 DB → 布隆过滤器、缓存空值。
- 击穿:单个热点 key 过期瞬间大量请求打到 DB → 互斥锁重建、逻辑过期、热点永不过期。
- 雪崩:大量 key 同时过期或 Redis 宕机 → 过期时间加随机值、多级缓存、限流降级。
高频追问:布隆过滤器能挡穿透,为什么挡不了击穿?——因为击穿是存在的热点 key 失效,布隆过滤器只能判断"一定不存在",对存在的 key 无效。
4.2 Redis 为什么快 / 持久化 / 一致性 🔥🔥
- 为什么快:纯内存;单线程避免锁竞争和线程切换(6.0 后多线程仅用于网络 I/O);I/O 多路复用(epoll)单线程管理海量连接;底层数据结构(SDS、跳表)针对场景优化。
- 持久化:RDB 快照恢复快、文件小,但两次快照间可能丢数据;AOF 记写命令,丢失少但文件大、恢复慢。生产常见 RDB 冷备 + AOF everysec 兜底,或 4.0+ 混合持久化。
- 一致性:主流先更新数据库,再删除缓存;删缓存失败配合延迟队列兜底重删;更稳妥订阅 binlog 异步删缓存补偿。承认取舍:缓存本质是性能换最终一致,强一致场景应读主库或不加缓存。
- 完整追问链与口述版 → Redis 面试。
五、并发模型:多线程 / 协程 / Celery
5.1 协程与 asyncio 🔥🔥🔥
🎙️ 90 秒口述版
协程是用户态的并发,由事件循环调度,切换开销远小于线程。核心机制是
await——遇到 I/O 等待时协程让出控制权,事件循环转去执行其他协程,所以单线程就能撑起大量并发 I/O 连接。想并发跑多个协程并等全部完成,用asyncio.gather。但这里有个特别关键的实战陷阱,也是区分度的所在:在 async 端点里如果调用同步阻塞的库,比如
requests,会阻塞整个事件循环——因为阻塞期间没有await让出控制权,所有协程都被卡住。所以必须用异步驱动,比如httpx、asyncpg这类。收一句取舍:协程适合 I/O 密集超高并发,但要求整条调用链都是异步的,一处同步阻塞就前功尽弃。
答题要点
- 机制:协程是用户态并发,事件循环调度;
await在等 I/O 时让出控制权,单线程支撑大量并发 I/O。 asyncio.gather并发运行多个协程并等待全部完成。- 关键陷阱:async 端点中调用同步阻塞驱动(
requests)会阻塞整个事件循环,必须用异步驱动(httpx/asyncpg)。
5.2 多线程 / 多进程 / 协程如何选 🔥🔥🔥
| 场景 | 选择 | 原因 |
|---|---|---|
| CPU 密集 | 多进程 / C 扩展 | 绕过 GIL |
| I/O 密集 | 多线程或协程 | 协程在超高并发连接下更优(线程栈内存 + 上下文切换开销大) |
| 耗时任务 | Celery | 从请求链路剥离,异步执行 + 削峰,常配 Redis/RabbitMQ 做 broker |
六、系统设计与网络(后端公共基础)
6.1 缓存模式与限流 🔥🔥
- Cache-Aside:读时先查缓存,miss 查 DB 并回填;写时更新 DB,再删除或让缓存过期。高读场景配合多级缓存(本地 + Redis)和热点 key 打散。
- 限流算法:令牌桶(允许一定突发)、漏桶(恒定速率)、滑动窗口(精确控制单位时间请求数)。分布式用 Redis 计数,按用户/IP 维度限流。
6.2 网络高频点 🔥🔥
- TCP 三次握手 / 四次挥手;TCP 与 UDP 核心区别。
- HTTP/1.1 持久连接 vs HTTP/2 多路复用。
- HTTPS 握手与 TLS 1.2 / 1.3 基本流程。
- I/O 多路复用:
select/poll/epoll区别,Python 侧对应selectors模块。
深度讲解 →
01.interview-of-python.md的「网络」章节。
七、备考建议与答题节奏
按优先级分配时间
- 公共必考区(时间不够先吃透):GIL 与并发、装饰器与闭包、垃圾回收、可变对象与拷贝。
- 次优先:框架对比、Django ORM 的 N+1——后端岗几乎每场都会以某种形式出现。
- 按 JD 深度:数据库和 Redis 的深度取决于岗位,但缓存三件套和索引基础属于"不会就是硬伤"。
答题节奏:机制 → 取舍 → 收住。先一句话说清机制,再点出代价或适用边界,然后停住等追问。只背结论会在第二层"底层怎么实现"处卡住。
项目挂钩:每个八股点最好对应你做过的具体场景(如"在这个接口上用 select_related 把 N+1 从 1+N 降到 2 次查询"),这比纯背答案有说服力得多。
关于"背不下来":别逐字背口述稿。记住每道题的骨架关键词(重点索引表最后一列),考场上用关键词把「机制 → 取舍 → 边界」三层展开。关键词连成线,答案自然顺出来。
相关文档
01.interview-of-python.md— Python 深度理解与算法题(本份负责应试,那份负责理解)- Redis 面试 | MySQL 面试 | RabbitMQ 面试
