🔄 Python迭代器与生成器完全指南：从入门到精通

本文详细讲解Python中迭代器(Iterator)和生成器(Generator)的概念、原理及实际应用，帮助你彻底掌握这两个强大的Python特性。

一、什么是迭代器(Iterator)

迭代器是Python中用于遍历集合的对象，它实现了迭代器协议，即包含__iter__()和__next__()两个方法。

1.1 迭代器的基本概念

• 可迭代对象(Iterable): 可以使用for循环遍历的对象（如列表、元组、字符串、字典等）
• 迭代器(Iterator): 实现了__next__()方法的对象，可以记住遍历的位置

1.2 创建迭代器

使用iter()函数将可迭代对象转换为迭代器：

# 从列表创建迭代器
my_list = [1, 2, 3, 4, 5]
my_iterator = iter(my_list)

# 使用next()获取下一个元素
print(next(my_iterator))  # 输出: 1
print(next(my_iterator))  # 输出: 2
print(next(my_iterator))  # 输出: 3

1.3 自定义迭代器

通过实现__iter__()和__next__()方法创建自定义迭代器：

class CountDown:
    def __init__(self, start):
        self.start = start
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.start <= 0:
            raise StopIteration
        self.start -= 1
        return self.start + 1

# 使用自定义迭代器
countdown = CountDown(5)
for num in countdown:
    print(num)  # 输出: 5, 4, 3, 2, 1

二、什么是生成器(Generator)

生成器是一种特殊的迭代器，它使用更简洁的语法来创建迭代器，使用yield关键字定义。

2.1 生成器函数

使用yield关键字代替return，函数就变成了生成器：

def simple_generator():
    yield 1
    yield 2
    yield 3

# 使用生成器
gen = simple_generator()
print(next(gen))  # 输出: 1
print(next(gen))  # 输出: 2
print(next(gen))  # 输出: 3
# 再次调用会抛出StopIteration

2.2 生成器的优势

# 传统方式：一次性生成所有数据（占用大量内存）
def get_squares(n):
    return [x**2 for x in range(n)]

# 生成器方式：惰性计算，节省内存
def get_squares_gen(n):
    for x in range(n):
        yield x**2

# 使用生成器处理大数据
for square in get_squares_gen(1000000):
    if square > 100:
        break
    print(square)

2.3 生成器表达式

类似于列表推导式，但使用圆括号，返回生成器对象：

# 列表推导式（占用内存）
squares_list = [x**2 for x in range(1000)]

# 生成器表达式（节省内存）
squares_gen = (x**2 for x in range(1000))

# 使用生成器表达式
for square in squares_gen:
    if square > 100:
        break
    print(square)

三、生成器的高级用法

3.1 生成器实现无限序列

def fibonacci():
    """生成无限斐波那契数列"""
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# 使用无限序列生成器
fib = fibonacci()
for _ in range(10):
    print(next(fib))  # 输出前10个斐波那契数

3.2 生成器实现文件逐行读取

def read_large_file(file_path):
    """高效读取大文件，不占用大量内存"""
    with open(file_path, 'r', encoding='utf-8') as f:
        for line in f:
            yield line.strip()

# 处理大文件
for line in read_large_file('large_file.txt'):
    process_line(line)  # 逐行处理

3.3 生成器实现数据管道

def data_source():
    """数据源生成器"""
    for i in range(100):
        yield i

def filter_even(gen):
    """过滤偶数"""
    for item in gen:
        if item % 2 == 0:
            yield item

def multiply_by_ten(gen):
    """乘以10"""
    for item in gen:
        yield item * 10

# 构建数据管道
pipeline = multiply_by_ten(filter_even(data_source()))
for result in pipeline:
    print(result)  # 输出: 0, 20, 40, 60, 80, ...

四、迭代器与生成器的实际应用

4.1 实现迭代器协议的数据类

class Team:
    def __init__(self):
        self.members = []
    
    def add_member(self, name):
        self.members.append(name)
    
    def __iter__(self):
        """使Team类可迭代"""
        return iter(self.members)

team = Team()
team.add_member("Alice")
team.add_member("Bob")
team.add_member("Charlie")

# 直接遍历Team对象
for member in team:
    print(member)

4.2 使用yield from简化代码

def flatten(nested_list):
    """展平嵌套列表"""
    for item in nested_list:
        if isinstance(item, list):
            yield from flatten(item)  # 递归展平
        else:
            yield item

nested = [1, [2, 3], [4, [5, 6]], 7]
print(list(flatten(nested)))  # [1, 2, 3, 4, 5, 6, 7]

4.3 上下文管理器与生成器

from contextlib import contextmanager

@contextmanager
def managed_resource(name):
    """使用生成器实现上下文管理器"""
    print(f"获取资源: {name}")
    resource = f"Resource-{name}"
    try:
        yield resource
    finally:
        print(f"释放资源: {name}")

# 使用上下文管理器
with managed_resource("database") as res:
    print(f"使用{res}")

五、迭代器工具函数

Python的itertools模块提供了许多强大的迭代器工具：

import itertools

# 无限计数器
counter = itertools.count(start=10, step=2)
print(list(next(counter) for _ in range(5)))  # [10, 12, 14, 16, 18]

# 循环迭代
cycle_iter = itertools.cycle(['A', 'B', 'C'])
print(list(next(cycle_iter) for _ in range(7)))  # ['A', 'B', 'C', 'A', 'B', 'C', 'A']

# 组合
items = ['A', 'B', 'C']
print(list(itertools.combinations(items, 2)))  # [('A', 'B'), ('A', 'C'), ('B', 'C')]
print(list(itertools.permutations(items, 2)))  # [('A', 'B'), ('A', 'C'), ('B', 'A'), ...]

# 分组
data = [('A', 1), ('A', 2), ('B', 3), ('B', 4)]
for key, group in itertools.groupby(data, key=lambda x: x[0]):
    print(f"{key}: {list(group)}")

六、总结

特性	迭代器	生成器
定义方式	类实现__iter__和__next__	函数使用yield关键字
内存占用	低（按需生成）	极低（惰性计算）
代码复杂度	较复杂	简洁优雅
状态保持	手动管理	自动保存状态
适用场景	需要复杂逻辑的迭代	大数据处理、流式计算

最佳实践

1. 处理大数据时使用生成器：避免内存溢出
2. 使用生成器表达式代替列表推导式：当只需要遍历时
3. 利用yield from简化嵌套生成器：提高代码可读性
4. 结合itertools模块：使用成熟的迭代器工具

迭代器和生成器是Python中处理序列数据的利器，掌握它们能让你的代码更高效、更优雅！

---

本文由AI辅助生成，仅供学习参考。