python基础之迭代器与生成器

《Python基础之迭代器与生成器》

在Python编程中，迭代器（Iterator）与生成器（Generator）是处理数据序列的高效工具，它们不仅简化了循环操作的实现，还能显著节省内存资源。本文将从基础概念出发，结合实际案例，深入探讨迭代器与生成器的原理、用法及优化技巧，帮助读者掌握这一核心知识。

一、迭代器：从可迭代对象到遍历工具

迭代器是Python中实现惰性求值（Lazy Evaluation）的关键机制。它通过`__iter__()`和`__next__()`方法，将可迭代对象（如列表、元组、字符串）转换为可逐项访问的序列。

1.1 可迭代对象与迭代器的区别

可迭代对象（Iterable）是实现了`__iter__()`方法的对象，例如：

my_list = [1, 2, 3]
print(hasattr(my_list, '__iter__'))  # 输出 True

而迭代器（Iterator）不仅实现了`__iter__()`，还实现了`__next__()`方法，用于逐个返回元素。可通过`iter()`函数将可迭代对象转换为迭代器：

list_iterator = iter(my_list)
print(next(list_iterator))  # 输出 1
print(next(list_iterator))  # 输出 2

1.2 手动实现迭代器

通过继承`Iterator`类或直接实现`__iter__`和`__next__`方法，可以自定义迭代器。例如，实现一个计数器迭代器：

class Counter:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current > self.end:
            raise StopIteration
        value = self.current
        self.current += 1
        return value

counter = Counter(1, 5)
for num in counter:
    print(num)  # 输出 1到5

1.3 内置迭代器工具

Python提供了`itertools`模块，包含大量高效迭代器工具。例如，无限迭代器`count()`和`cycle()`：

from itertools import count, cycle

# 无限计数器
for i in count(start=10, step=2):
    if i > 20:
        break
    print(i)  # 输出10,12,...,20

# 循环迭代
colors = ['red', 'green']
for i, color in enumerate(cycle(colors), 1):
    if i > 5:
        break
    print(i, color)  # 输出 (1, 'red'), (2, 'green'), ...

二、生成器：更简洁的迭代器实现

生成器是Python中一种特殊的迭代器，通过`yield`关键字实现，无需显式定义`__iter__`和`__next__`方法。生成器函数在执行到`yield`时会暂停，并返回一个值，下次调用时从暂停处继续执行。

2.1 生成器函数与生成器表达式

生成器函数使用`yield`返回值：

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci(10):
    print(num)  # 输出前10个斐波那契数

生成器表达式类似于列表推导式，但使用圆括号：

gen_exp = (x**2 for x in range(5))
print(list(gen_exp))  # 输出 [0, 1, 4, 9, 16]

2.2 生成器的状态保存

生成器在暂停时会保存局部变量和执行位置。例如，实现一个可重置的生成器：

def resettable_counter(start):
    current = start
    while True:
        reset = yield current
        if reset:
            current = start
        current += 1

counter = resettable_counter(0)
next(counter)  # 初始化
print(counter.send(False))  # 输出0
print(counter.send(False))  # 输出1
print(counter.send(True))   # 重置，输出0

2.3 生成器的高级用法

生成器可与`yield from`结合，实现委托生成器：

def flat_list(nested_list):
    for sublist in nested_list:
        yield from sublist

data = [[1, 2], [3, 4], [5]]
print(list(flat_list(data)))  # 输出 [1, 2, 3, 4, 5]

三、迭代器与生成器的应用场景

3.1 处理大数据流

生成器可逐行读取大文件，避免内存溢出：

def read_large_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()

for line in read_large_file('huge_file.txt'):
    process(line)  # 逐行处理

3.2 实现管道式数据处理

通过生成器链式调用，实现类似Unix管道的操作：

def filter_even(numbers):
    for num in numbers:
        if num % 2 == 0:
            yield num

def square(numbers):
    for num in numbers:
        yield num ** 2

data = range(10)
pipeline = square(filter_even(data))
print(list(pipeline))  # 输出 [0, 4, 16, 36, 64]

3.3 协程与异步编程

生成器可作为协程（Coroutine）使用，配合`asyncio`实现异步IO：

import asyncio

async def async_generator():
    for i in range(3):
        await asyncio.sleep(1)
        yield i

async def main():
    async for item in async_generator():
        print(item)

asyncio.run(main())  # 每隔1秒输出0,1,2

四、性能对比与优化

4.1 内存占用对比

生成器在处理大规模数据时内存效率更高。例如，比较列表与生成器：

import sys

# 列表占用内存
large_list = [x for x in range(1000000)]
print(sys.getsizeof(large_list))  # 输出约9000000字节

# 生成器占用内存
large_gen = (x for x in range(1000000))
print(sys.getsizeof(large_gen))  # 输出约112字节

4.2 执行效率优化

使用生成器表达式替代列表推导式可提升性能：

import time

def benchmark():
    start = time.time()
    sum_list = sum([x**2 for x in range(1000000)])
    print(f"列表推导式耗时: {time.time()-start:.2f}秒")

    start = time.time()
    sum_gen = sum(x**2 for x in range(1000000))
    print(f"生成器表达式耗时: {time.time()-start:.2f}秒")

benchmark()  # 生成器通常更快

五、常见误区与解决方案

5.1 迭代器耗尽问题

迭代器只能遍历一次，重复遍历需重新创建：

iterator = iter([1, 2, 3])
print(list(iterator))  # 输出 [1, 2, 3]
print(list(iterator))  # 输出 []（已耗尽）

解决方案：转换为列表或重新生成迭代器。

5.2 生成器中的异常处理

生成器内部需正确处理异常，避免中断：

def safe_div(numbers):
    for a, b in numbers:
        try:
            yield a / b
        except ZeroDivisionError:
            yield float('inf')

data = [(4, 2), (3, 0), (5, 1)]
print(list(safe_div(data)))  # 输出 [2.0, inf, 5.0]

六、总结与扩展

迭代器与生成器是Python中实现高效循环的核心工具。迭代器通过`__iter__`和`__next__`方法提供遍历能力，而生成器通过`yield`简化实现。它们在内存优化、大数据处理和异步编程中具有显著优势。掌握这些概念后，可进一步探索`itertools`的高级功能或结合异步生成器（`async generator`）实现更复杂的逻辑。

关键词：迭代器、生成器、Python、惰性求值、yield、itertools、协程、内存优化

简介：本文详细介绍了Python中迭代器与生成器的核心概念，包括可迭代对象与迭代器的区别、生成器函数的实现、生成器表达式的高级用法，以及它们在大数据处理、管道式编程和异步编程中的应用。通过代码示例和性能对比，帮助读者理解如何利用迭代器与生成器优化内存使用和提升执行效率。