迭代器和生成器通过按需生成数据提升内存效率与代码简洁性，迭代器需实现__iter__和__next__方法，生成器则用yield简化迭代器创建，适用于处理大数据、无限序列及延迟计算场景。
迭代器（Iterator）和生成器（Generator）在Python编程中是处理序列数据，尤其是大型或无限序列的强大工具。它们的核心价值在于提供了一种高效、内存友好的方式来按需访问数据，而不是一次性将所有数据加载到内存中。简单来说，迭代器定义了如何遍历一个序列的“规则”或“协议”，而生成器则是一种非常简洁、优雅地创建这种“规则”的“工厂”，它本身就是一个迭代器。它们让我们的代码在处理数据流时更加灵活、高效，也更易读。
当我们谈论数据处理，尤其是在面对海量数据或需要延迟计算的场景时，内存效率和代码简洁性往往是摆在首位的考量。迭代器和生成器正是为了解决这些痛点而生。
迭代器（Iterator） 是一个遵循迭代器协议的对象。这个协议在Python中非常明确：一个对象如果实现了
__iter__()
__next__()
next()
__iter__()
__next__()
__next__()
StopIteration
理解迭代器的关键在于它的“按需取用”特性。它不会一次性把所有数据都准备好，而是当你需要下一个数据时，它才去计算或获取。这对于处理大型文件、数据库查询结果，甚至是无限序列（比如斐波那契数列）时，显得尤为重要。它避免了将整个数据集加载到内存中可能导致的内存溢出问题。
class MyRangeIterator:
def __init__(self, start, end):
self.current = start
self.end = end
def __iter__(self):
return self
def __next__(self):
if self.current < self.end:
value = self.current
self.current += 1
return value
else:
raise StopIteration
# 使用自定义迭代器
for i in MyRangeIterator(0, 5):
print(i) # 输出 0, 1, 2, 3, 4生成器（Generator） 则可以看作是迭代器的一种特殊且更高级的实现方式。它通过一个包含
yield
yield
每次当生成器对象的
__next__()
for
yield
yield
yield
return
StopIteration
生成器极大地简化了迭代器的创建过程。我们不再需要手动维护
current
__next__
StopIteration
def my_range_generator(start, end):
current = start
while current < end:
yield current
current += 1
# 使用生成器
for i in my_range_generator(0, 5):
print(i) # 输出 0, 1, 2, 3, 4
# 生成器对象本身就是迭代器
gen = my_range_generator(0, 3)
print(next(gen)) # 0
print(next(gen)) # 1
print(next(gen)) # 2
# print(next(gen)) # 抛出 StopIteration从本质上讲，生成器就是一种更方便、更Pythonic 的方式来创建迭代器。它们都致力于解决在处理序列数据时效率和资源消耗的问题，但生成器以其简洁的语法，让开发者能够更专注于业务逻辑，而不是迭代器协议的实现细节。
我们为什么需要这些听起来有些“高级”的概念呢？这并非是炫技，而是实实在在的工程需求。在我日常的工作中，迭代器和生成器几乎无处不在，它们解决的核心问题可以归结为以下几点：
首先，内存效率是最大的驱动力。想象一下，你需要处理一个包含数百万行数据的CSV文件，或者从一个大型数据库中查询出海量记录。如果一次性将所有数据都加载到内存中，你的程序很可能因为内存不足而崩溃。迭代器和生成器采用的是“延迟加载”或“按需生成”的策略。它们只在需要时才生成或读取下一个数据项，这意味着无论数据集有多大，内存中始终只保留当前处理的那一小部分数据，这极大地降低了程序的内存占用。这对于大数据处理、日志分析、机器学习模型训练中的数据预处理等场景至关重要。
其次，它们实现了延迟计算（Lazy Evaluation）。这意味着数据或结果只在真正需要的时候才被计算出来。比如，你有一个复杂的计算序列，但最终你可能只关心序列的前几个元素。如果使用列表推导式一次性生成所有结果，那么即使后续元素用不到，也白白浪费了计算资源。生成器则可以避免这种不必要的计算，只在你调用
next()
for
再者，处理无限序列的能力。有些序列本质上是无限的，比如自然数序列、斐波那契数列，或者一个永不停止的数据流。显然，我们不可能把一个无限序列存储在内存中。迭代器和生成器允许我们定义一个规则来生成这些序列的元素，并在需要时逐个获取，而无需担心内存问题。这为模拟、科学计算等领域提供了强大的工具。
最后，代码的简洁性和可读性。尤其是在生成器的帮助下，原本需要编写一个完整的类、实现
__iter__
__next__
yield
手写一个自定义迭代器，其实就是深入理解Python迭代器协议的关键。虽然生成器提供了更简洁的实现方式，但掌握手动实现迭代器能让我们对底层机制有更深刻的认识。这就像了解汽车发动机的工作原理，即使你通常只知道踩油门。
一个自定义迭代器需要实现两个核心方法：
__iter__()
__next__()
__iter__(self)
iter()
for
__iter__()
return self
__next__(self)
next()
for
StopIteration
让我们通过一个稍微复杂一点的例子来演示：一个可以生成斐波那契数列的迭代器。斐波那契数列是一个无限序列，这恰好是迭代器和生成器大展身手的场景。
class FibonacciIterator:
def __init__(self, max_count=None):
# max_count 限制生成元素的数量，如果为 None 则理论上无限
self.max_count = max_count
self.count = 0
self.a, self.b = 0, 1 # 斐波那契数列的起始值
def __iter__(self):
return self
def __next__(self):
if self.max_count is not None and self.count >= self.max_count:
raise StopIteration
# 生成第一个元素（0）时，特殊处理
if self.count == 0:
self.count += 1
return 0
# 生成第二个元素（1）时，特殊处理
elif self.count == 1:
self.count += 1
return 1
else:
# 计算下一个斐波那契数
next_fib = self.a + self.b
self.a = self.b
self.b = next_fib
self.count += 1
return next_fib
# 使用自定义斐波那契迭代器
print("生成前10个斐波那契数：")
fib_iter = FibonacciIterator(max_count=10)
for num in fib_iter:
print(num, end=" ") # 输出 0 1 1 2 3 5 8 13 21 34
print("\n")
# 也可以手动调用 next()
fib_manual = FibonacciIterator(max_count=3)
print(next(fib_manual)) # 0
print(next(fib_manual)) # 1
print(next(fib_manual)) # 1
# print(next(fib_manual)) # 会抛出 StopIteration在这个
FibonacciIterator
self.a
self.b
self.count
max_count
__next__
a
b
count
max_count
StopIteration
通过这样的手动实现，我们可以清晰地看到迭代器如何管理其内部状态，以及如何通过
StopIteration
在Python中，我们有两种主要的方式来创建生成器：生成器函数（Generator Functions） 和 生成器表达式（Generator Expressions）。它们都创建了生成器对象，但它们在语法、适用场景和复杂性方面有所不同。理解它们的区别，能帮助我们更高效地编写代码。
生成器函数，我们前面已经提到，它是通过
def
yield
def filter_and_transform_data(data_stream):
for item in data_stream:
if item > 0: # 过滤掉负数
yield item * 2 # 转换：乘以2生成器表达式 则是一种更简洁、更紧凑的语法，它看起来非常类似于列表推导式，但用圆括号
()
[]
data = [1, -2, 3, -4, 5] filtered_transformed_gen = (item * 2 for item in data if item > 0) # 这就创建了一个生成器表达式
何时选择？
选择生成器函数：
async/await
send()
选择生成器表达式：
if
sum(x*x for x in range(10))
如何高效利用？
延迟计算的优势： 无论是生成器函数还是生成器表达式，它们的核心优势都在于延迟计算。这意味着你只在真正需要时才消耗资源。例如，当你需要找到一个大列表中满足某个条件的第一项时，使用生成器会比先创建一个完整的新列表再查找效率更高，因为生成器会在找到第一项后立即停止。
避免创建中间列表： 这是生成器最直接的性能优势。比如，如果你想计算一个大文件中所有非空行的长度之和，你可以这样写：
# 低效：创建中间列表
# total_len = sum([len(line.strip()) for line in open('large_file.txt') if line.strip()])
# 高效：使用生成器表达式
total_len = sum(len(line.strip()) for line in open('large_file.txt') if line.strip())第二个例子就避免了将所有处理过的行先存储在一个列表中，节省了大量内存。
链式操作与管道： 生成器非常适合构建数据处理管道。你可以将一个生成器的输出作为另一个生成器的输入，形成一个处理链。每个生成器只负责其特定的转换，数据在管道中流动，而不会在任何阶段完全物化。这使得代码模块化，易于理解和维护。
在我个人的实践中，我通常会优先考虑生成器表达式，因为它非常简洁。只有当逻辑变得复杂，或者我需要更精细地控制生成过程（比如需要维护复杂的内部状态或实现双向通信）时，我才会转向生成器函数。它们两者都是Python处理数据流的利器，熟练掌握它们能让你的代码更健壮、更高效。
以上就是迭代器（Iterator）与生成器（Generator）详解的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
569
收藏
