Python 迭代器和生成器

用户11081884

发布于 2026-07-20 18:52:58

450

文章被收录于专栏：用户11081884的专栏用户11081884的专栏

Python中的迭代器和生成器是高效处理数据流的重要工具，它们与容器、可迭代对象共同构成了Python迭代体系的核心。以下是关键知识点解析：

一、核心概念

1. 容器（Container）

存储元素的集合对象（列表/元组/字典/集合）

特点：所有元素存储在内存中，可直接访问

# 容器示例
my_list = [1, 2, 3, 4, 5]  # 列表容器
my_dict = {'a': 1, 'b': 2}  # 字典容器

2. 可迭代对象（Iterable）

实现了 iter() 方法的对象

特点：可通过for循环遍历，但不保存迭代状态

# 可迭代对象示例
class MyIterable:
    def __init__(self, data):
        self.data = data
    
    def __iter__(self):
        return iter(self.data)

my_iterable = MyIterable([1, 2, 3])
for item in my_iterable:
    print(item)  # 输出: 1 2 3

3. 迭代器（Iterator）

实现了 next() 方法的对象

特点：

保存迭代状态（指针位置）
只能单向遍历
遍历完会触发StopIteration

# 自定义迭代器示例
class CountIterator:
    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 = CountIterator(1, 4)
print(next(counter))  # 1
print(next(counter))  # 2
print(next(counter))  # 3

4. 生成器（Generator）

特殊迭代器（通过yield创建）

核心优势：

延迟计算（按需生成）
内存效率高（不预存全部结果）
支持无限序列

# 生成器函数示例
def simple_generator():
    yield 1
    yield 2
    yield 3

gen = simple_generator()
print(next(gen))  # 1
print(next(gen))  # 2

二、生成器特性

1. 内存优化

对比列表推导式 [] ，生成器表达式 () 内存占用恒定：

import sys

# 列表推导式 - 占用大量内存
list_comp = [i for i in range(1000000)]
print(f"列表大小: {sys.getsizeof(list_comp)} bytes")  # 约85MB

# 生成器表达式 - 内存占用极小
gen_exp = (i for i in range(1000000))
print(f"生成器大小: {sys.getsizeof(gen_exp)} bytes")  # 仅128字节

2. 执行流程控制

通过yield实现协程式控制：

def countdown(n):
    """倒计时生成器"""
    while n > 0:
        yield n
        n -= 1
    yield "Blastoff!"

# 使用示例
for message in countdown(3):
    print(message)
# 输出: 3 2 1 Blastoff!

3. 双向通信支持

send() 方法传值：

def accumulator():
    """累加器生成器，支持双向通信"""
    total = 0
    while True:
        value = yield total
        if value is None:
            break
        total += value

# 使用示例
acc = accumulator()
next(acc)  # 启动生成器
print(acc.send(10))  # 10
print(acc.send(20))  # 30
print(acc.send(5))   # 35

4. 生成器表达式

简洁的生成器创建方式：

# 生成器表达式示例
squares = (x*x for x in range(10))
print(sum(squares))  # 输出: 285

# 等效的生成器函数
def squares_generator():
    for x in range(10):
        yield x*x

三、应用场景

1. 大数据流处理

def log_processor(log_file):
    """处理大型日志文件的生成器"""
    with open(log_file, 'r') as file:
        for line in file:
            if 'ERROR' in line:
                yield line.strip()

# 逐行处理，不加载整个文件到内存
for error_line in log_processor('app.log'):
    process_error(error_line)

2. 无限序列生成

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

# 获取前10个斐波那契数
fib_gen = fibonacci()
first_10 = [next(fib_gen) for _ in range(10)]
print(first_10)  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

3. 管道式数据处理

def read_data(source):
    """数据读取阶段"""
    for item in source:
        yield item

def filter_data(data):
    """数据过滤阶段"""
    for item in data:
        if item % 2 == 0:  # 只保留偶数
            yield item

def transform_data(data):
    """数据转换阶段"""
    for item in data:
        yield item * 2

# 构建数据处理管道
pipeline = transform_data(filter_data(read_data(range(10))))
result = list(pipeline)
print(result)  # [0, 4, 8, 12, 16]

4. 状态机实现

def traffic_light():
    """交通灯状态机生成器"""
    states = ['RED', 'GREEN', 'YELLOW']
    while True:
        for state in states:
            yield state

light = traffic_light()
print(next(light))  # RED
print(next(light))  # GREEN
print(next(light))  # YELLOW

四、注意事项

1. 生成器单次遍历特性

gen = (x for x in range(3))
print(list(gen))  # [0, 1, 2]
print(list(gen))  # [] 需重新创建


# 解决方案：重新创建生成器
gen = (x for x in range(3))
print(list(gen))  # [0, 1, 2]

2. 迭代器协议实现

自定义迭代器需同时实现：

class CustomIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.index >= len(self.data):
            raise StopIteration
        value = self.data[self.index]
        self.index += 1
        return value

# 使用示例
iterator = CustomIterator([10, 20, 30])
for item in iterator:
    print(item)

3. Python版本差异

Python 3.5+支持async/await协程
yield from 语法实现生成器委托

# yield from 示例
def sub_generator():
    yield from range(3)

def main_generator():
    yield 'Start'
    yield from sub_generator()
    yield 'End'

print(list(main_generator()))  # ['Start', 0, 1, 2, 'End']

4. 使用抽象基类规范实现

# yield from 示例
def sub_generator():
    yield from range(3)

def main_generator():
    yield 'Start'
    yield from sub_generator()
    yield 'End'

print(list(main_generator()))  # ['Start', 0, 1, 2, 'End']

理解这些概念的区别与联系，能帮助开发者更高效地处理数据流任务，在内存敏感场景（如物联网设备/移动端）尤其重要。建议：

1、优先使用生成器处理大型数据集

2、利用生成器表达式简化代码

3、遵循迭代器协议实现自定义迭代器

4、使用抽象基类确保实现规范性

通过合理运用迭代器和生成器，可以显著提升Python程序的性能和内存使用效率。

“无他，惟手熟尔”！有需要就用起来。

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2025-10-31，如有侵权请联系 cloudcommunity@tencent.com 删除

遍历