AI大模型应用开发前置知识:Python迭代器和生成器深入详解

文章代码排版一般，如果对对排版有要求，请复制下面链接到浏览器查看:

https://blog.csdn.net/qq_34232889/article/details/158180253?sharetype=blog&shareId=158180253&sharerefer=APP&sharesource=qq_34232889&sharefrom=link

在 AI 大模型应用开发、RAG 检索、流式输出、大数据处理、高并发接口开发中，迭代器与生成器是 Python 最核心、最底层、最不能缺少的技能。大模型返回的长文本、向量库的百万级数据、流式对话的逐字输出、超大文件的读取与处理，全部依赖迭代器与生成器实现。

本文不讲空话、不跳步骤、不简化原理，从底层机制到实战用法，从基础语法到大模型开发场景，一次性把迭代器、可迭代对象、生成器、yield、生成器表达式、高级用法、常见坑点全部讲透，让你真正做到学完就能在大模型项目中熟练使用、写出高性能、低内存占用的专业代码。



一、先搞懂：什么是可迭代对象（Iterable）？

在 Python 中，能够直接被 for...in... 循环遍历的对象，统称为可迭代对象。这是学习迭代器与生成器的第一步，也是最基础的概念。

常见的可迭代对象

1 列表 list：[1,2,3]

1 字符串 str："hello"

1 元组 tuple：(1,2,3)

1 字典 dict：{"a":1}

1 集合 set：{1,2,3}

1 文件对象 file

1 生成器 generator

1 迭代器 iterator

可迭代对象的底层判定标准

一个对象只要内部实现了 __iter__() 方法，它就是可迭代对象。

我们可以通过代码验证：

Python

from collections.abc import Iterable



# 验证是否为可迭代对象

print(isinstance([1, 2, 3], Iterable))   # True

print(isinstance("python", Iterable))  # True

print(isinstance(123, Iterable))        # False（数字不是可迭代对象）

数字、布尔值不是可迭代对象，因此不能写 for i in 100:，否则会直接报错。

可迭代对象的核心特点

1 支持 for 循环遍历

1 可以通过 iter() 函数转换为迭代器

1 支持重复遍历（例如列表可以循环多次）

1 数据会一次性加载到内存中（大数据场景下会占用大量内存）



二、核心概念：什么是迭代器（Iterator）？

迭代器是可迭代对象的升级版，是 Python 中真正负责逐个取出数据、控制遍历流程的工具，也是所有遍历操作的底层实现。

在大模型开发中，迭代器最大的价值是：不用把所有数据一次性加载到内存，而是用到一个取一个，极大节省内存。

迭代器必须满足的两个硬性条件

1 实现了 __iter__() 方法

1 实现了 __next__() 方法

只有同时具备这两个方法，才是 Python 标准迭代器。

迭代器的核心能力：__next__()

__next__() 是迭代器最关键的方法，它的作用是：

1 每次调用，只返回一个数据

1 没有数据可取时，抛出 StopIteration 异常

1 遍历顺序严格按照定义顺序执行

手动创建与使用迭代器

我们可以通过 iter() 函数，把一个可迭代对象转换成迭代器：

Python

# 定义一个列表（可迭代对象）

data = [10, 20, 30]



# 转换为迭代器（两种写法完全等价）

it = iter(data)

# it = data.__iter__()  # 底层写法



# 手动从迭代器中取值

print(next(it))  # 10

print(next(it))  # 20

print(next(it))  # 30

print(next(it))  # 抛出 StopIteration 异常（无数据可取）

for 循环的底层本质（必须理解）

我们平时写的 for 循环，底层完全依赖迭代器实现：

1 调用 iter() 把可迭代对象转为迭代器

1 不断调用 next() 取值

1 自动捕获 StopIteration 异常并停止循环

所以：for 循环 = 自动迭代器。

迭代器最重要的特性：一次性使用

迭代器是消耗品，遍历完成后就会变空，不能回头、不能重复遍历。

Python

it = iter([1, 2, 3])



print(list(it))  # [1,2,3]

print(list(it))  # []  空了！无法再次遍历

这是迭代器与普通列表最大的区别，也是大模型流式处理必须掌握的特性。



三、手写一个迭代器（彻底理解底层原理）

要真正掌握迭代器，最好的方式是自己写一个。下面我们实现一个从 1 计数到 N 的自定义迭代器，完全模拟 Python 底层迭代逻辑。

Python

class NumberIterator:

    """自定义迭代器：从 1 计数到指定最大值"""

    def __init__(self, max_num):

        self.max_num = max_num  # 设定最大值

        self.current = 1        # 当前计数位置



    # 必须实现 __iter__ 方法，返回自身

    def __iter__(self):

        return self



    # 必须实现 __next__ 方法，控制取值逻辑

    def __next__(self):

        if self.current > self.max_num:

            # 无数据时抛出异常

            raise StopIteration

       

        value = self.current

        self.current += 1

        return value



# 使用自定义迭代器

counter = NumberIterator(5)



# 手动取值

print(next(counter))  # 1

print(next(counter))  # 2



# for 循环遍历

for num in counter:

    print(num)

运行结果：

Plain Text

1

2

3

4

5

所有 Python 内置迭代器（列表迭代器、文件迭代器、字符串迭代器），底层都是这套逻辑。



四、迭代器核心知识总结（必须牢记）

1 可迭代对象：能 for 循环，有 __iter__()，可重复遍历

1 迭代器：可迭代对象 + __next__()，一次性使用、节省内存

1 iter()：将可迭代对象转换为迭代器

1 next()：从迭代器中获取下一个值

1 无数据时抛出：StopIteration

1 迭代器惰性获取数据，不一次性占满内存

1 文件对象本身就是迭代器，适合读取超大文件

1 所有迭代器都是可迭代对象，但可迭代对象不一定是迭代器



第二部分：生成器（Generator）—— 大模型开发必备神器

一、什么是生成器？

生成器 = 语法更简洁、功能更强大的专用迭代器。

它不需要写类、不需要实现 __iter__ 和 __next__，只需要一个函数 + yield 关键字，就能快速创建迭代器。

在 AI 大模型开发中：

1 流式对话输出

1 RAG 检索数据流

1 大文本分块处理

1 百万级向量数据加载

1 低内存占用的数据管道

全部依赖生成器实现。

生成器的核心特点

1 本质是迭代器（拥有迭代器所有特性）

1 写法极简，比手写迭代器简单 10 倍

1 惰性计算：用到一个数据，才生成一个

1 内存占用极低，可处理无限序列、超大文件

1 只能遍历一次

1 支持 send()、throw()、close() 高级控制

二、生成器函数：使用 yield 创建

普通函数用 return 返回值并结束函数；

生成器函数用 yield 返回值并暂停函数，保留所有状态。

只要函数内部出现 yield，它就不再是普通函数，而是生成器函数。

最简单的生成器示例

Python

def simple_generator():

    yield 1

    yield 2

    yield 3



# 创建生成器对象（不会执行任何代码）

gen = simple_generator()



# 查看类型

print(type(gen))  #<class 'generator'>



# 手动取值

print(next(gen))  # 1

print(next(gen))  # 2

print(next(gen))  # 3

yield 的核心作用（必须彻底理解）

1 返回一个值

1 暂停函数执行，保存所有变量、状态、执行位置

1 下次调用 next()，从暂停位置继续执行

它是 Python 中唯一能让函数“暂停—恢复”的关键字，也是生成器的灵魂。

三、生成器执行流程逐行拆解

我们通过一段代码，清晰观察生成器 执行 → 暂停 → 恢复 → 暂停 → 结束 的完整过程：

Python

def generator_demo():

    print("第一步：函数开始执行")

    yield 10    # 暂停，返回10

   

    print("第二步：从暂停处恢复执行")

    yield 20    # 暂停，返回20

   

    print("第三步：再次恢复")

    yield 30



# 创建生成器（不执行代码）

g = generator_demo()



# 第一次调用：执行到第一个 yield

print(next(g))

# 输出：

# 第一步：函数开始执行

# 10



# 第二次调用：从第一个 yield 恢复到第二个 yield

print(next(g))

# 输出：

# 第二步：从暂停处恢复执行

# 20



# 第三次调用：执行到结束

print(next(g))

# 输出：

# 第三步：再次恢复

# 30

你可以清晰看到：生成器不会一次性运行完，而是分段执行。这种特性完美适配大模型的流式逐字输出。

四、生成器的最大优势：惰性计算（大模型必学）

生成器最大的价值是 惰性计算：

不调用、不生成；调用一个、生成一个。

这让生成器可以轻松处理：

1 无限长度的数据序列

1 GB 级超大文本、日志、语料文件

1 大模型返回的超长文本

1 百万、千万级向量数据库数据

而不会爆内存。

示例：无限计数生成器（列表绝对无法实现）

Python

def infinite_counter():

    n = 0

    while True:

        yield n

        n += 1



# 创建无限生成器

gen = infinite_counter()



# 永远取之不尽

print(next(gen))  # 0

print(next(gen))  # 1

print(next(gen))  # 2

print(next(gen))  # 3

# ... 可以无限执行

普通列表无法存储无限数据，会直接占满内存崩溃，但生成器可以轻松实现。



五、生成器表达式：一行代码创建生成器

除了使用函数 + yield，我们还可以用生成器表达式快速创建生成器，语法与列表推导式几乎一样，只是把方括号换成圆括号。

语法格式：

Python

(表达式 for 变量 in 可迭代对象 if 条件)

示例对比：

Python

# 列表推导式（一次性加载所有数据，占内存）

list_comp = [x * 2 for x in range(10)]



# 生成器表达式（惰性计算，几乎不占内存）

gen_comp = (x * 2 for x in range(10))



print(type(gen_comp))  #<class 'generator'>

使用方式完全相同：

Python

print(next(gen_comp))  # 0

print(next(gen_comp))  # 2

print(next(gen_comp))  # 4

生成器表达式是大模型数据预处理、数据过滤最常用的极简写法。



六、生成器高级用法：send、throw、close

生成器比普通迭代器更强大，支持三个高级方法，在大模型流式控制中非常有用。

1. send() —— 向生成器内部发送数据

可以从外部向暂停的生成器传入数据，实现双向通信：

Python

def data_generator():

    print("启动生成器")

    msg = yield "准备就绪"

    print("外部传入消息：", msg)

    yield "处理完成"



gen = data_generator()

print(next(gen))    # 启动生成器，输出：准备就绪

gen.send("你好，大模型")  # 发送数据

2. throw() —— 主动向生成器抛出异常

Python

gen.throw(ValueError("数据处理异常"))

3. close() —— 手动关闭生成器

Python

gen.close()



七、大模型开发中生成器的经典实战场景

场景 1：流式输出大模型回复（ChatGPT 逐字效果）

Python

def llm_stream_response(response_text):

    """模拟大模型流式逐字输出"""

    for char in response_text:

        # 模拟模型逐字生成

        yield char

        # 真实场景中可加入延迟：await asyncio.sleep(0.01)



# 使用

response = "我是AI大模型，这是我的流式回复"

for char in llm_stream_response(response):

    print(char, end="", flush=True)

场景 2：读取超大文本文件（GB 级语料库）

Python

def read_big_corpus(file_path):

    """读取超大文件，不占内存"""

    with open(file_path, 'r', encoding='utf-8') as f:

        for line in f:

            yield line.strip()

场景 3：RAG 数据分块、流式处理

Python

def split_text_stream(text, chunk_size=200):

    """流式文本分块，用于RAG检索"""

    for i in range(0, len(text), chunk_size):

        yield text[i:i+chunk_size]

场景 4：管道式数据处理（大模型预处理）

Python

# 多级流式处理

step1 = (x for x in raw_data)

step2 = (clean_text(x) for x in step1)

step3 = (chunk_text(x) for x in step2)

全程不占内存，处理千万级数据毫无压力。



八、迭代器 vs 生成器 完整对比表

对比维度 迭代器（Iterator） 生成器（Generator）

写法 自定义类，实现 __iter__、__next__ 函数 + yield / 生成器表达式

难度 复杂、代码量大 极简、一行即可创建

内存占用 低 极低（惰性计算）

可重复遍历 不可以 不可以

功能 基础迭代 支持 send/throw/close

适用场景 复杂自定义迭代逻辑 大模型流式输出、大数据、文件处理

关系 生成器属于迭代器 生成器是迭代器的语法糖

一句话记忆：生成器是最优雅的迭代器，迭代器是生成器的底层。



九、迭代器与生成器最常见的 8 个坑（90% 开发者都会踩）

1 生成器只能遍历一次，遍历完就空了

1 调用生成器函数不会执行代码，只有调用 next() 才执行

1 不要多次使用 list(gen)，会直接耗尽生成器

1 yield 不是 return，不会结束函数，只是暂停

1 for 循环会自动捕获 StopIteration，不会报错

1 生成器不支持索引访问，不能写 gen[0]

1 send() 必须在生成器暂停后使用，第一次必须用 next()

1 文件对象本身是迭代器，读取大文件千万不要用 readlines()



十、全文最终总结（大模型开发核心要点）

1 可迭代对象：能 for 循环，有 __iter__()，可重复遍历

1 迭代器：可迭代对象 + __next__()，一次性、省内存

1 iter() 转迭代器，next() 取值，无数据抛 StopIteration

1 生成器：Python 最优雅的迭代器，大模型开发必备

1 yield：返回值 + 暂停函数，是生成器核心

1 惰性计算：用到才生成，不占内存，可处理无限数据

1 生成器适用场景：流式输出、大数据、大文件、RAG、数据管道

1 所有生成器都是迭代器，但迭代器不一定是生成器

1 大模型项目中：能用生成器就不用列表，能流式处理就不一次性加载

1 迭代器与生成器是写出高性能、低内存、高并发 AI 服务的基础

掌握本篇内容，你就完全具备了大模型应用开发所需的 Python 底层迭代与数据流处理能力，可以轻松应对流式对话、RAG 检索、大数据集处理、高并发接口等所有核心场景。