企业官网建设流程全解析

简介：面向Python初、中级开发者的面试复习PDF，聚焦面试与考核中高频出现的核心语法与底层机制，帮助读者系统查漏补缺。内容按问答形式整理，覆盖生成器与迭代器实现、列表与元组差异、字典哈希存储、GIL多线程限制、闭包与装饰器用法、Python 2/3关键差异、可变与不可变对象等知识点，并配有简洁代码片段，便于理解与记忆。资源为1个PDF文件，压缩包约304KB，结构清晰、篇幅精炼，适合准备Python开发岗位笔试面试，或希望快速巩固语言特性的学习者随身查阅。目前已有13637人学习下载，内容针对性强，能在较短时间内补齐高频考点，是一份实用的复习资料。

1. "Python 八股文.pdf"里装的不是题库，而是一张知识地图

某开发者把 Python 八股文背得滚瓜烂熟，面试官随口让他推算一段代码的输出，他就卡壳了。回头翻开 PDF 才发现原理全写在里面，他只是跳过了推导过程直接背结论。

"Python 八股文.pdf"这类文档，本质是把技术面试里反复出现的高频问题整理成册，从可变对象、垃圾回收到 GIL、装饰器，覆盖的都是简历上写"精通 Python"的人最容易漏掉的基础盲区。它不会教你怎么写业务代码，但能帮你把每个基础点练到当场讲得清楚、答得利落的程度。

适合两类人：准备 Python 岗位面试的求职者，和写了几年 Python 但只会用、讲不清原理的开发者。把它当体检清单，别当教科书。

2. Python 八股文的三大核心板块：语言机制、内存模型、并发模型

这类文档的试题看起来杂乱无章，但覆盖面其实就三大板块。把它们吃透，剩下的语法糖考点都只是小菜。下面按面试官出题的逻辑，把每块的关键考点、验证方式和易错边界过一遍。

2.1 语言机制考点：可变性、拷贝与参数传递

Python 语言机制有四个高频方向：可变对象与不可变对象、浅拷贝与深拷贝、函数参数的传递方式、默认参数的可变陷阱。这四个方向表面独立，实际上指向同一个底层概念——对象的身份、类型与值之间的关系。只背答案没用，自己跑一遍就全懂了。

# 可变性验证：身份(id)是否变化是关键 a = [1, 2, 3] print(id(a)) # 输出一个地址A a.append(4) print(id(a)) # 仍是地址A，可变对象原地修改 b = (1, 2, 3) # b[0] = 99 # TypeError，元组不可变 s = "hello" s += " world" print(id(s)) # 地址变化，字符串是不可变对象

这段代码对应面试第一问："Python 里哪些可变、哪些不可变？"答案本身不难，关键是要补一句：判断依据是操作后对象的id是否变化，而不是"能不能变"的直觉。字符串拼接看着像原地变，其实每次都是新建对象；列表append看着没变，其实就在原对象上操作。这一层讲清楚了，浅拷贝与深拷贝的问题就顺着接上来。

import copy origin = [[1, 2], [3, 4]] shallow = copy.copy(origin) deep = copy.deepcopy(origin) shallow[0][0] = 99 # 只改内层元素 print(origin) # [[99, 2], [3, 4]]，浅拷贝的内层仍共享 deep[0][0] = 88 print(origin) # [[99, 2], [3, 4]]，深拷贝完全独立 # 面试追问：如果只做 shallow[0] = [100, 200] 这种外层替换呢？ shallow[0] = [100, 200] print(origin) # [[99, 2], [3, 4]]，外层替换不影响原对象

这里有个几乎人人都踩过的坑：用列表.copy()或copy.copy()做了一层拷贝，就以为内存完全隔离。实际上拷贝的边界是"一层"——外层容器是新的，容器内的元素引用还是原样。判断深浅拷贝最实用的方法是问自己："修改嵌套结构里的最深层元素，原对象会不会跟着变？"会变就是浅，不变就是深。理解到这个层面，才能应对接下来必然出现的参数传递问题。

Python 参数传递的准确说法是"对象引用传递的值的拷贝"，但面试时更实用的表述是：像列表这种可变对象传进函数后，函数内原地修改会影响外部；像整数、字符串这种不可变对象，函数内重新赋值不影响外部。与其纠结措辞，不如用代码验证两个场景。

def mutate(lst, num): lst.append(99) # 原地修改，影响外部 num = 100 # 重新绑定，不影响外部 data = [1, 2] n = 5 mutate(data, n) print(data) # [1, 2, 99] print(n) # 5 def bad_default(item, container=[]): container.append(item) return container print(bad_default(1)) # [1] print(bad_default(2)) # [1, 2]，同一个默认列表被反复污染

最后的bad_default是默认参数陷阱的标准演示。默认参数在函数定义时只创建一次，之后每次调用都复用同一个列表对象。很多人背过"默认参数不要用可变对象"，但没跑过这段代码，也就不知道它到底怎么被污染的。解决办法是把默认值改成None，函数体内再判断赋值。这道题出现频率极高，因为一道题同时考了可变对象、参数传递、函数定义时机三个知识点，是典型的八股追问结构。

2.2 内存模型考点：引用计数、垃圾回收与循环引用

内存模型是八股文里最容易被误解的部分。很多人背下"Python 用引用计数加分代回收"，但被问"引用计数为零就一定立即释放吗""循环引用怎么处理""__del__为什么在循环引用场景下不执行"就露馅。根子在于没分清两套机制各管什么。

import sys import gc obj = [] print(sys.getrefcount(obj) - 1) # 1，减去 getrefcount 自身的一次引用 class Node: def __init__(self): self.next = None a = Node() b = Node() a.next = b b.next = a del a del b print("手动触发 gc 前的循环引用对象数:", len(gc.get_objects()))

引用计数的机制很简单：每个对象头部保存一个计数值，被引用的次数加一，引用解除就减一，降到零就立即回收。但它有一个致命盲区——循环引用。上面代码里a和b互相引用，删除外部引用后计数不会归零，对象成了垃圾却无法被引用计数回收。这时候轮到分代回收出场，它周期性扫描容器对象，找出循环引用并断开。

面试时建议这样回答：Python 的回收机制是两层协作，引用计数负责大部分即时的、非循环的内存回收，分代垃圾回收负责兜底清理循环引用；gc模块能手动触发分代回收，gc.get_objects()能拿到所有被 GC 追踪的对象。注意，只有容器对象会被分代回收追踪，整数、字符串这类不可变对象不参与。"哪些对象进 GC、哪些不进"这个边界，才是区分背答案和真理解的分水岭。

还有一个高频追问是内存泄漏排查。实际项目里真正常见的不是循环引用，而是对象被全局容器（缓存、注册表、单例列表）无意中持有。这时候用gc.get_objects()配合tracemalloc统计分配来源，比盯着引用计数更有效。八股文里关于内存的题，最终都要落到"线上怎么排查 OOM"这个实战问题上，光说出引用计数四个字是不够的。

2.3 并发模型考点：GIL、多线程、多进程与协程

并发板块里 GIL 绕不开。面试官通常从一道陷阱题切入："Python 多线程是不是假的？"这个问题本身不严谨，因为多线程在 I/O 密集场景确实有效，只是对 CPU 密集场景受限。GIL 的本质是 CPython 解释器在进程级别维护的一把锁，保证同一时刻只有一个线程执行字节码。它对 I/O 场景影响不大，因为线程在等待 I/O 时会释放 GIL。

# GIL 影响验证：CPU 密集型对比 import threading import time def busy_work(n): total = 0 for i in range(n): total += i return total start = time.time() for _ in range(2): busy_work(20000000) print("串行耗时:", time.time() - start) start = time.time() t1 = threading.Thread(target=busy_work, args=(20000000,)) t2 = threading.Thread(target=busy_work, args=(20000000,)) t1.start(); t2.start() t1.join(); t2.join() print("双线程耗时:", time.time() - start)

这段代码在主流 CPython 版本下跑出来，双线程和串行耗时基本相当甚至更慢。原因是两个线程轮番竞争 GIL，CPU 密集计算被锁切成碎片，切换开销反而拖后腿。但面试只讲到这一步还不够，得继续补两句：多线程适合 I/O 密集场景，因为socket.recv、文件读取这类系统调用会释放 GIL；CPU 密集场景要换多进程，每个进程有独立的解释器和 GIL，能利用多核；协程则是单线程内的事件循环，靠await让出执行权，吞吐量高于线程，但前提是全部 I/O 操作都得是异步的。

注意：PyPy、Jython 等解释器没有 GIL 或实现不同，面试讨论默认指 CPython。

对应的常识是：multiprocessing不是threading的简单替换品，它重启解释器、有进程间通信成本，数据要用Queue或Manager传递，不能靠共享内存。还有一个容易被忽略的点——Python 3.13 之后 GIL 的默认行为有调整，但多数面试场景讨论的还是传统 CPython 行为。遇到这种题，先说清楚讨论的是哪个实现，能避免掉进版本争议的坑。

3. 别当背诵材料用：把八股文拆成"原理+代码+表达"三层

这类 PDF 哪怕每题答案都写全了，直接背也是低效的。原因很简单：面试官听过的背诵腔太多了，稍微换个问法，纯背答案的人就接不住。我的做法是把每一道题拆成三层来处理：第一层是验证结论的最小代码，第二层是 30 秒能讲完的口头表达，第三层是它和其他题目的关系网。

3.1 第一步：用最小代码逐条验证结论

凡是文档里出现的结论，都拿解释器现场跑一遍。别嫌麻烦，这一步的目的是把"别人告诉你的结论"变成"你自己观察到的现象"。大多数八股翻车，都输在只记结论没记现象。比如"字典是插入有序的"这个说法，Python 3.7 前后行为不同；"小整数有缓存"这个结论，只在[-5, 256]范围内成立。这些边界不靠代码验证，光靠背是记不牢的。

# 小整数缓存与字典有序性验证 a = 256 b = 256 print(a is b) # True，256 在缓存区间内 c = 1000 d = 1000 print(c is d) # False，1000 不在缓存区间内 from sys import intern s1 = intern("hello") s2 = intern("hello") print(s1 is s2) # True，短字符串驻留 d1 = {"a": 1, "b": 2} d2 = {"b": 2, "a": 1} print(list(d1.keys()) == list(d2.keys())) # False，插入顺序被保留

is和==的区别在这里体现得淋漓尽致。is比较身份（id），==比较值。小整数缓存和字符串驻留让一部分对象碰巧共享身份，但这是解释器的实现优化，不是语言规范的要求。写业务代码的人不用关心，面试却几乎必考，因为它是考察"你清不清楚 Python 对象模型"的经典切口。

验证完之后，在每道题旁边记下"你从这个实验观察到了什么"，而不是把 PDF 原话抄一遍。比如验证完小整数缓存，应该写"256 和 1000 的差异证明缓存有边界，且is在数值比较上不可靠"。这种笔记才是面试时真正能调用的信息，背来的标准答案在紧张状态下经常一个字都想不起来。

3.2 第二步：把答案组织成 30 秒口头表达

八股题目在面试里一般不给写代码的时间，要求边想边说。所以每个考点要准备一个 30 秒版本，结构固定为：结论一句话 → 原理两到三句 → 例子一句 → 延伸一句。以装饰器为例，标准回答长这样——

"装饰器是一个接收函数并返回新函数的可调用对象，用来在不修改原函数代码的前提下增加通用逻辑。它的底层机制是闭包，内部函数捕获外层函数的参数和上下文。常见应用是日志、鉴权、缓存和重试。@decorator语法糖等价于func = decorator(func)，装饰器本身需要参数时，就要再包一层。"

这段回答 30 秒内说完，覆盖定义、原理、应用、语法糖四个层次。面试官接下来问"装饰器执行顺序"或"怎么给装饰器加参数"，都是从这个主干的延伸。说的时候要用自己的话，哪怕措辞不精练，也比背诵原文好——组织语言的过程本身就在检验理解程度。见过最翻车的回答是原封不动背标准定义，被追问一个偏门角度就支支吾吾，原因就是脑子里只有一条孤立的文本，没有形成可以推演的结构。

3.3 第三步：把相关题目串成知识网

八股文最大的价值不是每道题的独立答案，而是题目之间的关联。面试官很少只问一个点，典型的追问链是"生成器有什么特点"→"生成器和迭代器什么关系"→"生成器为什么省内存"→"生成器在什么场景效率反而低"。每一步都是上一步的延伸，只背了第一步的答案，后面就只能翻车。

# 生成器节省内存的验证：直接用 sys.getsizeof 观察 import sys list_comp = [x * x for x in range(10000)] gen_exp = (x * x for x in range(10000)) print(sys.getsizeof(list_comp)) # 列表推导式立即生成全部元素 print(sys.getsizeof(gen_exp)) # 生成器表达式只有迭代器自身大小 def fibonacci(): a, b = 0, 1 while True: yield b a, b = b, a + b fib = fibonacci() for _ in range(5): print(next(fib)) # 1, 2, 3, 5, 8

生成器和迭代器这一串问题，背后是同一个原理：惰性求值。生成器不保存完整序列，只在每次next()时计算下一个值。省内存是结果，不是目的。抓住这个根，才能回答"生成器什么场景效率反而低"——如果你要反复随机访问序列的多个位置，惰性求值每次都要重新计算，列表的一次性构建反而更优。知识网的价值就在这：题目换个角度，你还是能找到对应的知识点。

串网的方法很朴素：拿到目录后，自己画一遍从语言机制到并发模型的关联线，比如"可变对象 → 浅拷贝 → 传参陷阱 → 默认参数掉坑"，"GIL → 多线程 → I/O 密集 → asyncio"。画的过程不需要精确，关键是逼自己回答"这两个考点之间靠什么逻辑连接"。能连接起来的知识才叫掌握，孤立的条目叫记忆碎片，面试紧张时根本调不出来。

4. 八股文覆盖不到的实战题：手写代码与项目追问

PDF 再全，也有两类题覆盖不到，或者说覆盖了但容易忽略：一类是手写代码题，一类是从简历项目延伸的追问。前者考"能不能在不能查文档的紧张状态下写出对的代码"，后者考"基础知识能不能在实际场景中被调用"。

4.1 高频手写题：装饰器、生成器、单例与上下文管理器

手写代码题看似是题库外的内容，考点却全是八股文里的老熟人。最常见的几个：手写带参数的装饰器、手写惰性计算生成器、手写线程安全的单例，以及手写上下文管理器。前两个分别对应闭包和迭代器协议，PDF 里全有原理，只是没人把原理翻译成代码。

# 手写带参数的装饰器：日志级别可控 import functools def log(level="INFO"): def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): print(f"[{level}] 调用 {func.__name__}，参数: {args}") return func(*args, **kwargs) return wrapper return decorator @log(level="WARN") def divide(a, b): return a / b

@log("WARN")的语法等价于先执行log("WARN")拿到decorator，再执行decorator(divide)拿到wrapper。所以带参数的装饰器一定是三层嵌套，有人叫它装饰器工厂。容易漏的是functools.wraps，不加上它，被装饰函数的__name__和__doc__会被wrapper覆盖，查日志时全是装饰器自身的名字，排查问题非常痛苦。

# 手写生成器版本的分页读取，避免大文件一次性载入 def paginate(file_path, page_size=1024): with open(file_path, "r", encoding="utf-8") as f: while True: lines = f.readlines(page_size) if not lines: break yield lines for page in paginate("app.log", page_size=2048): process(page) # 假设 process 是业务处理函数

这个分页生成器的考点有两个：readlines配合参数可以按行数分批读取而不是整文件载入；with块嵌套在生成器函数里时，资源清理发生在生成器被垃圾回收或显式close()时。很多人写小文件习惯了open(...)后readlines()全量读，一到大文件处理就发现自己对生成器只是嘴上懂。实际业务里日志文件、导出的 CSV、批量导入的数据全是这个场景。

单例的写法版本非常多，面试官想听的不是"哪种最标准"，而是能不能说出不同实现的线程差异。模块级单例天然安全（模块只导入一次），装饰器版本需要加锁，元类版本在继承场景有自己的坑。回答时先说结论"Python 里最简单的单例是模块导入"，再补一句"如果一定要类实例，再加锁"，这个顺序显得有真实取舍经验，而不是背了一个模板。

# 手写上下文管理器：__enter__ 返回资源，__exit__ 处理清理 class Timer: def __init__(self): self.elapsed = 0 def __enter__(self): import time self.start = time.time() return self def __exit__(self, exc_type, exc_val, exc_tb): import time self.elapsed = time.time() - self.start print(f"耗时 {self.elapsed:.4f}s") return False # 返回 False 表示异常继续向外抛 with Timer() as t: sum(range(1000000))

上下文管理器的考点是__exit__的返回值语义：返回True表示吞掉异常，返回False（默认）表示异常正常向外传播。很多人知道with能自动关文件，但不知道__exit__还能决定异常处理方式。手写题里它出现频率不低，因为它同时考了特殊方法、异常传播和资源管理三个知识点。

4.2 项目追问里藏着的八股考点

面试官从简历项目切入时，问题表面是业务，实际全是八股考点。你说做过爬虫项目，他会问"并发控制怎么做的"，映射到线程池和信号量；你说做过数据清洗，他会问"超大 DataFrame 怎么优化内存"，映射到生成器和内存模型；你说做过服务接口，他会问"慢请求怎么排查"，映射到 cProfile 和 GIL。这些问题没有标准答案，但答的基础全是八股文。

应对措施是给每个项目准备一组"追问映射表"：每个项目写三到五个关键技术点，每个技术点标注对应的八股考点，再针对考点准备一个真实案例。比如项目里用了asyncio，准备时想明白：为什么不用多线程，await到底发生在哪一行，有没有踩过"某处同步代码阻塞事件循环"的坑。这三问每一问都能拆成一个八股题目，而你有真实场景背书，回答质感和干背完全不同。

# 模拟事件循环被同步代码阻塞的反例排查 import asyncio import time async def fast_task(): print("fast start") await asyncio.sleep(0.1) print("fast done") async def slow_blocking_task(): time.sleep(2) # 同步阻塞，整个事件循环卡住 print("slow done") async def main(): await asyncio.gather(fast_task(), slow_blocking_task()) asyncio.run(main())

这段代码里time.sleep(2)会让fast_task的完成时间也拖到 2 秒以上，因为事件循环在单线程里被同步调用堵死了。正确做法是把耗时同步操作扔给线程池，用await asyncio.to_thread(slow_blocking_task)。这是最常见的协程翻车现场，也是面试官最爱用来区分"看过 asyncio 文档"和"真写过 asyncio 项目"的题。八股能告诉你协程是单线程协作式调度，但只有真实跑过阻塞案例，才理解"协作"的边界——它只对主动让出执行权的代码有效，对同步阻塞无能为力。

另外一个典型的项目追问是性能排查。简历写到接口平均响应 200ms，面试官大概率会问"你用什么定位的瓶颈" 。最高频的工具是cProfile和tracemalloc，一个看函数级耗时，一个看内存分配来源。这两个工具在八股文里都有介绍，但没在项目里用过的人根本说不清先跑哪个、看哪几列数据、怎么定位到具体一行。

# cProfile 定位函数级耗时：按累计耗时排序 import cProfile import pstats cProfile.run("sum(range(5000000))", "profile.out") p = pstats.Stats("profile.out") p.sort_stats("cumulative").print_stats(10)

排错的关键是看cumulative和tottime两列：tottime是函数自身耗时，不含子调用；cumulative是包含子调用的累计耗时。先按cumulative排序定位链条顶端，再按tottime找真正耗钱的那一行。能把这两列的区别讲清楚，比背十个性能优化技巧都管用，因为它是"你确实做过性能分析"的直接证据。八股文负责给你工具清单，而项目负责给你使用经验，两者缺一个，追问环节就会现出原形。

5. Python 八股文备考避坑指南：4 类常见翻车点

背八股文不是背诵比赛，面试官要的是"能落地的基础"。以下是备考过程中最常见的四类翻车，每一条都值得对照检查。

5.1 翻车一：把 CPython 实现细节当语言规范

现象：作答时斩钉截铁地说"Python 的字典是插入有序的""Python 的整数是不可变的"，被追问"这是语言规范，还是 CPython 实现行为"就答不上来。

原因：八股文里很多结论来自 CPython 的实际行为。字典有序是 3.7 起才正式成为语言规范，此前的实现细节；小整数缓存[-5, 256]也是 CPython 的优化，语言规范从未承诺过。把实现细节当规范，一旦面试官问"换个解释器实现还成立吗"，整段答案就崩了。

解决：复习每条结论时给自己加一个标签——"规范"还是"实现"。判断标准是看官方文档（语言参考部分）有没有承诺这个行为。文档里写了的是规范，没写但 CPython 一直这么干的是实现。面试时拿不准的，直接说"这是 CPython 的实现行为，不是语言规范"，这个坦诚比硬背得体得多，往往能接住追问。

5.2 翻车二：只背结论，忽视版本差异

现象：面试官问"asyncio的写法有什么变化""dict有序性从哪版开始保证"，你在脑海里把所有版本混在一起，答得前后矛盾。

原因：Python 3 生命周期内大版本差异明显，从 3.6 到 3.13，f-string、字典有序、asyncio的ensure_future与create_task、match语句、typing的演进，每个大版本都有行为变化。八股文 PDF 通常不标注版本，背的人默认所有答案适用所有版本。

解决：在每道涉及版本行为的题目前标注"3.x+ 适用"。复习时特别关注三个时间点：3.7（字典有序、dataclasses）、3.10（match语句、类型联合写法）、3.12/3.13（更快解释器、typing新写法）。面试时被问版本相关问题，第一句话先说"这个行为在哪个版本成立"，展示版本意识。错版本说结论，是基础题里比较尴尬的翻车。

5.3 翻车三：八股与实践脱节，追问就露馅

现象：背了整套垃圾回收机制，但面试官问"排查过线上内存泄漏吗？当时怎么定位的"就答不上来，因为实际工作里一直用top看内存，出了问题就重启，从没用过gc模块或tracemalloc。

原因：八股文和真实工程之间有一道鸿沟。面试官问八股不是想听教科书念稿，而是想看你有没有把这个知识点变成日常工具。光背不练，一追问工程场景就露馅，这是八股备考最大的风险。

解决：每个核心考点配一个工程场景，哪怕是自己模拟的。学完 GC 后用tracemalloc跑一遍"为什么缓存列表会吃满内存"的本地脚本；学完 GIL 后用线程和进程各跑一次任务对比。场景不必来自真实生产环境，自己造的 Demo 也算数。关键是有"我实际干过这件事"的记忆，回答时的细节感和背诵完全不同。

5.4 翻车四：记忆无索引，临场检索失败

现象：明明背过"闭包"的定义，但面试官从"函数工厂是什么"问起，或者从"为什么会有变量捕获"问起，就完全想不起来。

原因：知识存储时是孤立条目，没有建立与其他考点的关联。面试时题目表达方式稍有变化，检索线索就断了。这是死记硬背的典型后果，很多人把八股文背完，发现换一个问法还是穿帮。

解决：复习顺序按知识网络来，不按 PDF 目录顺序来。把"闭包、装饰器、函数工厂、自由变量"放进一个卡片组，每天随机更换触发词来回忆。练习方法是随机抽一个知识点，用 30 秒口头把它和相关考点讲清楚。检索路径越多，临场越稳。记忆不是目的，调得出来才是。

6. 让八股文真正生效的复习循环：间隔重复与主动回忆

背完一轮就丢一边，效果过不了一周。我的做法是把整份文档转成一套粗粒度的间隔重复计划，不依赖任何工具，一张表格就够。核心是两个动作：主动回忆和设置遗忘节点。

主动回忆的意思是：看题后不翻答案，先在脑子里自己组织一遍回答，甚至出声说一遍，再拿文档核对。这比反复读答案的记忆效率高好几倍，因为每次回忆都在强制重建神经通路，而重读只是被动接收信息。难记住的题标个记号，过两天再来一轮，比均匀地反复翻阅更省时间。

间隔节点的设置按时点推进：当天的题当天复述，第二天抽查，第三天串题，一周后再来一轮，半个月做整体检索。半个月这个节点淘汰掉烂熟的题，只保留错题和卡壳题，压缩成一份清单。清单在面试前两天重新过一遍，就是最终带进考场的弹药。复习时每个考点争取 30 秒说出来，说不顺的记下来，别自欺欺人往下跳。

最后一次整体检索时，我会故意对着镜子或者说给同事听，把每道题的答案说出来而不是默读。说出来和默读的差别极大：前者逼你组织语言、暴露逻辑断点，后者经常让你误以为"我知道了"。这个习惯帮我抓出过很多"以为会了实际说不好"的题，比如"生成器和迭代器的区别"，就是说了两遍才发现自己每次都只能答出特性，答不出两者的从属关系。

走过这一整套循环回头看，八股文真正的作用不是那份 PDF 本身，而是逼我把 Python 基础按"可复述"的标准重新过了一遍。这个标准比"用过"高一个档次，它要求每个知识点都能在紧张、限时的状态下被准确调出。就算面试只考到其中一半，写代码时对内存、并发、协议的理解也会明显更深。

最后说个一直在用的习惯：每次复习把卡壳的题单独记到一个清单里，只记题目不记答案，一周后回头看。能立刻说清楚的就划掉，说不出来的存着，下个月再回来啃。时间一长，这份个人清单比任何通用八股文都更贴合自己的短板，成了每次换工作前必翻的第一份资料。希望帮到你。

本文还有配套的精品资源，点击获取