27迭代器

## 迭代

在 Python 中，迭代指的是**逐个访问容器（如列表、元组、字典、集合、字符串）中的每个元素的过程**。

例如，我们常用的 for 循环就是最典型的迭代操作：

```python
my_list = [1, 2, 3]
for item in my_list:
    print(item)
```

输出结果：

```python
1
2
3
```

这个过程就是在“迭代” my_list。

## 可迭代对象 (Iterable)

**定义**：一个实现了 \_\_iter\_\_() 方法（支持从 0 开始索引）的对象，\_\_iter\_\_() 方法必须返回一个**迭代器**。

**简单理解**：任何你可以用 for 循环去遍历的对象，都是可迭代对象。

**常见的可迭代对象**：

- 容器类型：list, tuple, dict, set, str
- 打开的文件对象 (open('file.txt'))
- 生成器 (Generator)

例如：
```python
# collections.abc.Iterable 是一个抽象基类，它的主要作用是提供一种标准化的、可靠的方法来检查一个对象是否是可迭代的。
#与 isinstance() 函数结合，来验证一个对象是否可迭代。
from collections.abc import Iterable

my_list = [1, 2, 3]
print(isinstance(my_list, Iterable))  # 输出: True
print(isinstance("hello", Iterable))  # 输出: True
print(isinstance(42, Iterable))       # 输出: False
```

输出结果：
```python
True
True
False
```

**注意**：可迭代对象**本身并不是迭代器**。当你使用 for 循环时，for 语句的内部机制会**自动调用**可迭代对象的 \_\_iter\_\_() 方法来获取一个迭代器，然后使用这个迭代器来完成遍历。

## 迭代器 (Iterator)

**定义**：一个实现了**迭代器协议**的对象，迭代器协议包含两个方法：

- \_\_iter__(): 返回迭代器对象本身，这使得迭代器本身也是可迭代的。
- \_\_next\_\_(): 返回容器中的下一个元素，当没有更多元素时，**必须抛出 StopIteration 异常**。

**核心特性**：

- **惰性计算 (Lazy Evaluation)**：迭代器不会一次性将所有元素都加载到内存中，它只在调用 \_\_next\_\_()方法时才计算并返回下一个值，这对于处理大规模数据流（如大文件、无限序列）非常高效，可以节省大量内存。
- **一次性消费**：迭代器就像一个“一次性水杯”，遍历一次之后就用尽了。如果你想再次遍历，必须重新创建一个新的迭代器。它不记得之前的遍历状态。
- **只能向前**：迭代器没有“后退”或“重置”的概念，你只能不断地调用 next() 来获取下一个元素。

**如何从可迭代对象获取迭代器**：使用内置函数 iter()。

```python
my_list = [1, 2, 3]  # 可迭代对象 (Iterable)
my_iter = iter(my_list)  # 获取它的迭代器 (Iterator)

print(type(my_iter)) # 输出: <class 'list_iterator'>
```

输出结果：
```python
<class 'list_iterator'>
```

**如何手动使用迭代器**：使用内置函数 next()。

```python
my_list = [1, 2, 3]  # 可迭代对象 (Iterable)
my_iter = iter(my_list)  # 获取它的迭代器 (Iterator)
print(next(my_iter))  # 输出: 1
print(next(my_iter))  # 输出: 2
print(next(my_iter))  # 输出: 3
print(next(my_iter))  # 抛出 StopIteration 异常
```

输出结果：
```python
1
2
3

print(next(my_iter))  # 抛出 StopIteration 异常
          ~~~~^^^^^^^^^
StopIteration

```

for 循环的本质就是自动处理了 iter() 和 next() 以及捕获 StopIteration 异常的过程。上面的手动过程等价于：

```python
my_iter = iter([1, 2, 3])
while True:
    try:
        item = next(my_iter)
        print(item)
    except StopIteration:
        break
```

输出结果：

```python
1
2
3

进程已结束，退出代码为 0
```

## 自定义迭代器

你可以通过定义一个类来实现迭代器协议，从而创建自己的迭代器。

**示例：创建一个返回数字的平方的迭代器，直到某个上限**。

```python
class SquareIterator:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0

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

def __next__(self):
        # 计算并返回下一个值
        if self.current < self.limit:
            result = self.current ** 2
            self.current += 1
            return result
        else:
            # 没有更多元素时，抛出 StopIteration
            raise StopIteration

# 使用自定义迭代器
for num in SquareIterator(5):
    print(num)
# 输出: 0, 1, 4, 9, 16

# 手动使用
sq_iter = SquareIterator(3)
print(next(sq_iter)) # 0
print(next(sq_iter)) # 1
print(next(sq_iter)) # 4
# print(next(sq_iter)) # 抛出 StopIteration
```

输出结果：
```python
0
1
4
9
16
0
1
4
```

## 内置迭代器工具

Python 的 itertools 模块提供了大量用于操作迭代器的强大工具，例如：

- itertools.count(start=0, step=1): 创建一个无限的计数器。
- itertools.cycle(iterable): 无限循环一个可迭代对象。
- itertools.chain(*iterables): 将多个可迭代对象连接成一个。
- itertools.islice(iterable, stop): 对迭代器进行切片操作。

这些函数本身返回的都是迭代器，充分利用了惰性计算的特性。

## 对比

| 特性         | 可迭代对象 (Iterable)                | 迭代器 (Iterator)                                      |
| ------------ | ------------------------------------ | ------------------------------------------------------ |
| **定义**     | 实现了 \_\_iter\_\_() 方法的对象     | 实现了 \_\_iter\_\_() **和** \_\_next\_\_() 方法的对象 |
| **内存**     | 可能一次性存储所有数据（如列表）     | **惰性计算**，按需生成，节省内存                       |
| **状态**     | 无状态（遍历可由多个迭代器独立进行） | **有状态**，记录当前位置，**一次性消费**               |
| **关系**     | 迭代器的“工厂”                       | 可迭代对象的“遍历代理”                                 |
| **示例**     | list, dict, str                      | generator, file object, itertools 函数返回值           |
| **获取方式** | 直接创建                             | iter(iterable)                                         |
| **使用方式** | for loop (自动获取迭代器)            | next(iterator), for loop                               |

## 应用场景

**1. 处理大型文件或数据流**

对于无法一次性加载到内存的大型文件（如日志、CSV），迭代器可逐行读取，避免内存溢出。

**2. 生成无限序列**

迭代器可通过循环不断生成新元素，适合需要无限数据的场景（如测试、模拟）。

**3. 优化内存密集型操作**

当处理大量数据时，迭代器避免了预存储所有元素，显著降低内存占用。

**4. 实现惰性数据管道**

迭代器可串联成 “数据处理管道”，每个步骤仅处理当前元素，无需等待整个序列，适合流式处理。