Python八股文速查手册：生成器、迭代器、GIL与可变对象核心概念解析

简介：这份《Python 八股文.pdf》面向准备技术面试的 Python 学习者与初中级开发者，系统梳理高频核心考点，帮助读者在有限时间内建立完整的知识框架。内容围绕内置电池、生成器与迭代器、列表与元组、字典实现、GIL 全局解释器锁、Python 2 与 3 差异、可变与不可变对象、闭包、装饰器及元类等主题展开，既讲概念定义，也结合代码示例说明底层原理与常见追问方向。资源包内含 1 个 PDF 文件，整体约 304KB，轻量便携，适合通勤或碎片时间反复翻阅。目前已有 13672 人学习下载，说明其在面试复习场景中具备较高参考价值。读者可借此快速定位薄弱环节，理解生成器延迟计算、字典 O(1) 查询、GIL 对多线程的影响等关键机制，并借助闭包、装饰器、元类等进阶内容提升对 Python 语言特性的整体把握。

1. 面试间里的“八股文”：为什么这些老概念总被反复问

你可能遇到过这种场景：面试官坐下来，第一个问题不是让你写代码，而是问“Python 的生成器和迭代器有什么区别”。你心里嘀咕，这都什么年代了，怎么还在问这些？但偏偏就是这些被戏称为“八股文”的基础概念，几乎每一轮技术面都会出现。原因不复杂——它们不是死记硬背的考点，而是理解 Python 这门语言行为方式的钥匙。

打个比方，学开车不一定要懂发动机原理，但如果你知道变速箱什么时候换挡、刹车为什么会有热衰减，你开起来就会更有判断力。Python 的生成器、迭代器、GIL、可变与不可变对象，就是这门语言的“变速箱逻辑”。搞懂它们，你才能解释为什么有些代码跑得快、有些写法会踩坑、有些 bug 看起来像玄学。这份《Python 八股文.pdf》把散落在各处的基础概念收拢到一起，用问答的方式一条条讲清楚，适合当成一本随时翻查的“概念字典”。

2. 从生成器到迭代器：一对最容易搞混的“孪生兄弟”

2.1 生成器到底解决了什么问题

假设你要处理一个包含一千万个元素的列表，每个元素都要做某种计算。如果一次性把所有结果算出来存进列表，内存瞬间就被吃光了。生成器的思路是：别急，你要一个我算一个。

Python 里创建生成器有两种方式。第一种是列表生成式加括号：

# 列表生成式用方括号，生成器用圆括号 g1 = (x for x in range(10))

第二种是在函数里用yield关键字：

def fib(max): n, a, b = 0, 0, 1 while n < max: yield b # 每次执行到这里暂停，把 b 交出去 a, b = b, a + b n = n + 1 return 'done' g2 = fib(8)

yield的行为很像一个“暂停键”。函数执行到yield时，把值交出去，自己停在那里；下次你再要值，它从暂停的地方继续跑。这就是为什么生成器“不占内存”——它不需要提前把所有结果算好存起来，而是用的时候才算。

注意：生成器只能遍历一次。遍历完了再想从头来，得重新创建一个新的生成器对象。

2.2 可迭代对象和迭代器的层级关系

很多人把“可迭代”和“迭代器”当成同义词，其实它们是一个包含关系。

可迭代对象（Iterable）是那些能用在for循环里的东西，包括 list、tuple、str、dict、set，以及生成器。判断一个对象是否可迭代，可以用：

from collections.abc import Iterable print(isinstance([1, 2, 3], Iterable)) # True print(isinstance('hello', Iterable)) # True print(isinstance(123, Iterable)) # False

迭代器（Iterator）的要求更严格：它必须能被next()函数不断调用并返回下一个值，直到抛出StopIteration。列表是 Iterable 但不是 Iterator，你可以用iter()把列表转成迭代器：

lst = [1, 2, 3, 4, 5] it = iter(lst) # 把列表转成迭代器 print(next(it)) # 1 print(next(it)) # 2

从类定义的角度看，可迭代对象只需要实现__iter__()方法；迭代器则需要同时实现__iter__()和__next__()。生成器天然就是迭代器，因为它自动实现了这两个方法。但反过来不成立——迭代器不一定是生成器，你可以自己写一个类来实现迭代器协议，而不用yield。

2.3 为什么面试官总爱问这两个

因为这两个概念串起了 Python 里“惰性求值”和“协议编程”两条主线。理解了生成器，你就能理解为什么range(1000000)不会撑爆内存；理解了迭代器协议，你就能理解for循环背后到底在做什么——它先调用iter()拿到迭代器，然后反复调用next()，直到捕获StopIteration才停下来。

这份资料里把生成器和迭代器的定义、创建方式、判断方法都列得很清楚，遇到不确定的时候翻一下，比在网上搜碎片化的答案要快得多。

3. 可变与不可变：一个“传参翻车”引出的核心概念

3.1 为什么修改一个变量会“牵连”另一个

先看一段代码：

a = [1, 2, 3] b = a b.append(4) print(a) # [1, 2, 3, 4]

你只改了b，a也跟着变了。这不是 bug，而是因为a和b指向的是同一个列表对象。列表是可变对象，你对它做的任何修改都是“原地修改”，所有指向它的变量都会看到变化。

换成不可变对象就不一样了：

x = 10 y = x y = y + 1 print(x) # 10 print(y) # 11

整数是不可变的，y = y + 1并不是修改了原来的 10，而是创建了一个新的整数对象 11，让y指向它。x仍然指向 10。

Python 里的可变对象包括 list、dict、set；不可变对象包括 bool、int、float、tuple、str。这个分类直接影响函数传参的行为——把列表传进函数，函数内部修改它会影响到外面；把整数传进去，函数内部怎么改都不会影响外面。

3.2 浅拷贝和深拷贝的区别到底在哪

理解了可变与不可变，再看拷贝就清晰了。

赋值（=）只是创建了一个新的引用，两个变量指向同一个对象。浅拷贝（copy.copy）创建了一个新对象，但新对象里包含的还是对原始对象内部元素的引用。深拷贝（copy.deepcopy）则是递归地复制所有嵌套对象，完全独立。

import copy original = [[1, 2], [3, 4]] shallow = copy.copy(original) deep = copy.deepcopy(original) original[0].append(99) print(shallow) # [[1, 2, 99], [3, 4]] 浅拷贝跟着变了 print(deep) # [[1, 2], [3, 4]] 深拷贝不受影响

浅拷贝只复制了外层列表，内层的子列表还是共享的。深拷贝把里里外外都复制了一遍，所以原对象怎么改都跟它没关系。

提示：深拷贝虽然彻底，但遇到循环引用或超大对象时开销很大，不是所有场景都适合用。

3.3 常见误区：这些概念最容易搞混

误区一：把“可迭代对象”等同于“迭代器”。列表是可迭代对象，但它不是迭代器。区别在于迭代器有状态，能记住遍历到哪了；列表没有“遍历位置”这个概念，每次for循环都从头开始。区分方法很简单：能用next()的就是迭代器，只能用在for里的就是可迭代对象。

误区二：以为元组完全不可变。元组本身不可变，但如果元组里装的是列表，那个列表的内容是可以改的。t = (1, [2, 3])，你不能把t[0]改成别的，但可以t[1].append(4)。元组的“不可变”指的是它持有的引用不变，不是引用指向的对象不变。

误区三：认为多线程一定能加速。在 CPython 里，由于 GIL 的存在，同一时刻只有一个线程在执行 Python 字节码。多线程适合 IO 密集型任务（比如网络请求、文件读写），因为 IO 等待时 GIL 会被释放；但 CPU 密集型任务用多线程反而可能更慢，应该用多进程。

误区四：把is和==混用。==比较的是值，is比较的是内存地址。对于小整数和短字符串，Python 有缓存机制，可能让is返回 True，但这不代表所有相同值的对象都是同一个。判断值相等用==，判断是不是同一个对象用is。

误区五：以为 Python 2 和 Python 3 只是版本号不同。两者的差异是结构性的：print在 Python 3 里是函数，在 Python 2 里是语句；Python 3 的str是 Unicode 字符串，Python 2 的str是字节串；Python 3 的除法返回浮点数，Python 2 的整数除法返回整数。这些差异直接影响代码的行为，不是改个版本号就能兼容的。

4. GIL 与多线程：为什么你的多核 CPU 跑不满

4.1 GIL 到底是什么

GIL 全称 Global Interpreter Lock，全局解释器锁。它的作用是确保任何时刻只有一个线程在执行 Python 字节码。即使你的机器有 8 个核，用 CPython 跑多线程时，同一时刻也只有一个线程在跑 Python 代码。

这听起来很反直觉——多线程不就是为了并行吗？但在 CPython 的设计里，GIL 是为了保护解释器内部数据结构的一致性。Python 的内存管理不是线程安全的，如果没有 GIL，多个线程同时操作引用计数可能会导致内存泄漏或崩溃。GIL 用一把大锁把这些问题挡在外面，代价就是多线程无法真正并行执行 Python 代码。

4.2 为什么 IO 密集型任务还能用多线程

关键在于 GIL 的释放时机。Python 在执行 IO 操作时会主动释放 GIL，让其他线程有机会运行。所以当你做网络请求、读写文件、查询数据库时，线程大部分时间在等 IO，GIL 的争抢并不激烈，多线程仍然能提升整体吞吐量。

但如果是纯计算任务，比如大量数学运算、循环处理数据，线程会一直占着 GIL 不放，其他线程只能干等。这时候多线程不仅不能加速，反而因为线程切换的开销变得更慢。解决办法是用多进程（multiprocessing），每个进程有自己独立的解释器和 GIL，可以真正利用多核。

4.3 元类、闭包、装饰器：这些概念为什么总被放在一起问

因为它们都涉及“函数是一等公民”和“类也是对象”这两个 Python 核心设计。

闭包是一个嵌套函数，内部函数引用了外部函数的变量，并且外部函数返回了内部函数。闭包能“记住”外部函数的变量，即使外部函数已经执行完毕。装饰器本质上是一个接收函数作为参数的闭包，它可以在不修改原函数代码的情况下，给函数添加额外功能。比如一个计时装饰器：

import time def calc_time(func): def inner(): t1 = time.time() func() t2 = time.time() print('cost time: {}s'.format(t2 - t1)) return inner

元类则是“创建类的类”。普通类是type的实例，而元类允许你在类定义时和类实例化时插入自定义逻辑。比如在 ORM 框架里，定义一个类就代表数据库里的一张表，元类可以自动把类属性名转成小写、生成对应的 SQL 映射。这些概念之所以常被放在一起，是因为它们都体现了 Python 的“元编程”能力——用代码来操作代码。

5. 什么时候该翻这份资料，什么时候不该

这份《Python 八股文.pdf》的定位很明确：它是一本概念速查手册，不是从零入门的教程，也不是深入 CPython 源码的专著。它适合的场景是——你已经在写 Python 代码，但遇到某个概念不确定，想快速搞清楚定义、区别和典型用法。比如面试前突击复习、代码 review 时跟同事争论“生成器到底是不是迭代器”、或者写装饰器时忘了闭包的作用域规则。

它不适合的场景也很明确：如果你还没写过任何 Python 代码，直接看这些问答会觉得很抽象，因为缺少实际踩坑的经验来挂钩。另外，如果你需要的是某个第三方库的具体用法、性能调优的实战技巧、或者某个框架的深度源码分析，这份资料也帮不上忙——它的覆盖面是语言基础概念，不是工程实践。

我自己的习惯是：每次遇到“这个行为怎么跟我预期不一样”的时候，先翻一遍这份资料里对应的章节。比如有一次我写了一个函数，传了一个列表进去，函数内部修改了列表，外面也跟着变了，我一开始以为是 bug，翻了可变对象那一节才反应过来是引用传递的正常行为。从那以后我每次传可变对象进函数，都会先想一下是要原地修改还是需要拷贝一份。

提示：概念类的资料，最好的用法是“遇到问题再查”，而不是从头到尾背一遍。带着具体问题去翻，记忆效果比死记硬背好得多。

希望这份资料能帮你在遇到 Python 基础概念时少一点懵、多一点笃定。

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