夯实基础：Python 中的迭代器(Iterator)

在 Python 中，迭代器（Iterator） 是实现了迭代协议的对象，用于按需生成序列中的元素，支持逐步遍历（每次返回一个元素）。它是 Python 中 “迭代” 机制的核心，支撑了 for 循环、列表推导式、生成器等多种常见功能。迭代器的核心优势是惰性计算（按需生成元素），可大幅节省内存（尤其处理大量数据时）。

一、迭代器的核心概念

1. 迭代（Iteration）与可迭代对象（Iterable）

• 迭代：重复执行某个操作（如遍历列表中的元素）的过程。
• 可迭代对象（Iterable）：可以被迭代的对象（如列表、元组、字符串、字典、集合等），它们实现了 __iter__() 方法，该方法返回一个迭代器。

常见的可迭代对象：

# 可迭代对象示例
lists = [1, 2, 3]       # 列表
tuples = (1, 2, 3)      # 元组
strings = "abc"         # 字符串
dicts = {"a": 1, "b": 2} # 字典（迭代的是键）
sets = {1, 2, 3}        # 集合

2. 迭代器（Iterator）的定义

迭代器是实现了迭代协议的对象，需同时满足：

1. 实现 __iter__() 方法：返回迭代器自身（self），确保迭代器可被迭代。
2. 实现 __next__() 方法：返回序列中的下一个元素；当没有元素时，抛出 StopIteration 异常。

迭代器与可迭代对象的关系：

• 可迭代对象（如列表）通过 __iter__() 方法 “生成” 迭代器。
• 迭代器是 “真正执行迭代” 的对象，负责逐个返回元素。

二、迭代器的工作原理

1. 从可迭代对象到迭代器

通过内置函数 iter() 可将可迭代对象转换为迭代器（本质是调用可迭代对象的 __iter__() 方法）：

# 可迭代对象（列表）
my_list = [10, 20, 30]

# 转换为迭代器
my_iter = iter(my_list)  # 等价于 my_list.__iter__()

print(type(my_list))  # <class 'list'>（可迭代对象）
print(type(my_iter))  # <class 'list_iterator'>（迭代器）

2. 迭代器的遍历：next() 函数

通过内置函数 next() 可获取迭代器的下一个元素（本质是调用迭代器的 __next__() 方法）：

my_iter = iter([10, 20, 30])

print(next(my_iter))  # 10（等价于 my_iter.__next__()）
print(next(my_iter))  # 20
print(next(my_iter))  # 30
print(next(my_iter))  # 无元素时抛出 StopIteration 异常

执行结果：

10
20
30
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print(next(my_iter))
StopIteration

3. for 循环的底层逻辑

for 循环本质是对迭代器的封装，自动处理了 StopIteration 异常，流程如下：

1. 调用可迭代对象的 __iter__() 方法，获取迭代器。
2. 不断调用迭代器的 __next__() 方法，获取元素并执行循环体。
3. 当捕获到 StopIteration 异常时，退出循环。

例如，for 循环遍历列表的底层等价代码：

my_list = [10, 20, 30]

# for 循环的底层逻辑
iterator = iter(my_list)  # 步骤1：获取迭代器
while True:
    try:
        item = next(iterator)  # 步骤2：获取下一个元素
        print(item)  # 执行循环体
    except StopIteration:
        break  # 步骤3：捕获异常，退出循环

三、迭代器的特点

1. 一次性：迭代器只能遍历一次，元素被访问后不会保留，无法 “回溯” 或 “重置”（若需重新遍历，需重新创建迭代器）。

   my_iter = iter([1, 2, 3])
   list(my_iter)  # [1, 2, 3]（第一次遍历）
   list(my_iter)  # []（第二次遍历，已无元素）
   

2. 惰性计算：迭代器不会一次性生成所有元素，而是按需生成（调用 next() 时才生成下一个元素），适合处理大量数据或无限序列（如生成所有自然数）。

3. 节省内存：由于惰性计算，迭代器无需将所有元素加载到内存（对比列表：列表会一次性存储所有元素）。

四、自定义迭代器

通过在类中实现 __iter__() 和 __next__() 方法，可自定义迭代器。以下是一个生成斐波那契数列的迭代器示例：

class FibIterator:
    """自定义迭代器：生成斐波那契数列（前 n 项）"""
    def __init__(self, n):
        self.n = n  # 生成的项数
        self.a = 0  # 斐波那契数列的第1项
        self.b = 1  # 斐波那契数列的第2项
        self.count = 0  # 已生成的项数

    # 实现 __iter__()：返回迭代器自身
    def __iter__(self):
        return self

    # 实现 __next__()：返回下一个元素，无元素时抛 StopIteration
    def __next__(self):
        if self.count < self.n:
            result = self.a
            # 计算下一项（a, b = b, a+b）
            self.a, self.b = self.b, self.a + self.b
            self.count += 1
            return result
        else:
            # 超出项数，抛出异常终止迭代
            raise StopIteration

# 使用自定义迭代器
fib_iter = FibIterator(5)  # 生成前5项斐波那契数列

# 方式1：用 for 循环遍历
for num in fib_iter:
    print(num, end=" ")  # 输出：0 1 1 2 3

# 方式2：转换为列表（触发完整迭代）
print("\n", list(FibIterator(5)))  # 输出：[0, 1, 1, 2, 3]

五、迭代器与生成器的关系

生成器（Generator） 是一种特殊的迭代器，它自动实现了迭代协议（无需手动编写 __iter__() 和 __next__() 方法），通过 yield 关键字定义，语法更简洁。

生成器示例（等价于上述斐波那契迭代器）：

def fib_generator(n):
    """生成器函数：生成斐波那契数列前 n 项"""
    a, b = 0, 1
    count = 0
    while count < n:
        yield a  # 暂停并返回当前元素，下次调用从这里继续
        a, b = b, a + b
        count += 1

# 生成器是迭代器的一种
gen = fib_generator(5)
print(isinstance(gen, iterator))  # True（判断是否为迭代器）

# 遍历生成器
for num in gen:
    print(num, end=" ")  # 输出：0 1 1 2 3

生成器本质是迭代器的 “语法糖”，简化了迭代器的创建，是处理惰性计算场景的首选。

六、迭代器的应用场景

1. 处理大量数据：当数据量过大（如 100 万条记录），列表会占用大量内存，而迭代器可按需生成元素，显著节省内存。

   # 生成100万个数：迭代器方式（内存友好）
   class BigDataIterator:
       def __init__(self, size):
           self.size = size
           self.i = 0
       def __iter__(self):
           return self
       def __next__(self):
           if self.i < self.size:
               self.i += 1
               return self.i
           raise StopIteration
   
   # 遍历100万个数，内存占用极低
   for num in BigDataIterator(1000000):
       pass  # 处理逻辑
   

2. 无限序列：迭代器可表示无限序列（如所有自然数），因无需存储所有元素，仅在需要时生成下一个。

   class InfiniteNatural:
       def __iter__(self):
           self.n = 1
           return self
       def __next__(self):
           result = self.n
           self.n += 1
           return result
   
   # 遍历前10个自然数（无限序列的有限使用）
   natural_iter = iter(InfiniteNatural())
   for _ in range(10):
       print(next(natural_iter), end=" ")  # 输出：1 2 3 4 5 6 7 8 9 10
   

3. 流式数据处理：如读取大文件时，迭代器可按行读取（而非一次性加载整个文件到内存）。

   # 用迭代器逐行读取大文件
   def read_large_file(file_path):
       with open(file_path, "r") as f:
           while True:
               line = f.readline()  # 逐行读取（惰性）
               if not line:
                   break
               yield line  # 生成器（迭代器）返回每行内容
   
   # 遍历大文件，内存占用低
   for line in read_large_file("big_file.txt"):
       process(line)  # 处理每行数据
   

七、迭代器相关工具函数

Python 内置了多个用于操作迭代器的函数，简化迭代逻辑：

示例：用 itertools 生成无限序列并限制遍历次数：

import itertools

# 生成从 10 开始的无限整数序列（迭代器）
count_iter = itertools.count(10, step=2)  # 10, 12, 14, ...

# 取前5个元素
for _ in range(5):
    print(next(count_iter), end=" ")  # 输出：10 12 14 16 18

总结

迭代器是 Python 迭代机制的核心，通过 __iter__() 和 __next__() 方法实现按需生成元素，具有惰性计算和节省内存的优势。其核心特点是：一次性遍历、向前迭代、无内存冗余。

可迭代对象（如列表、字符串）是迭代的 “源头”，通过 iter() 转换为迭代器；for 循环本质是对迭代器的封装，自动处理 StopIteration 异常。生成器是迭代器的简化形式，通过 yield 关键字快速实现惰性计算。

在处理大量数据、无限序列或流式数据时，迭代器是提升性能和节省内存的关键工具。