做摄影的网站知乎发外链比较好的平台

你有没有见过像 ChatGPT 这样的 AI 回答问题时，文字不是一下子全出来，而是一段一段、甚至一个词一个词地蹦出来？这种像打字一样的效果，叫做“流式响应”。在 Python 程序里，要实现这种效果，经常会用到一个特别的关键字：yield。

yield 这个词看起来有点陌生，但它其实是 Python 中一个非常巧妙的设计。要理解它，我们先得把它和大家熟悉的 return 做个对比。

在一个普通的 Python 函数里，return 语句表示函数的终点。一旦执行 return，函数就彻底结束了，并且把 return 后面的值交出去。比如：

def add_numbers(a, b):print("开始计算...")result = a + bprint("计算完成！")return result # 函数在这里结束，返回 resultsum_value = add_numbers(5, 3)
print(f"得到结果: {sum_value}")
# 输出：
# 开始计算...
# 计算完成！
# 得到结果: 8

这个函数从头跑到尾，执行 return 后就“寿终正寝”了。

但是，如果函数里用了 yield，事情就变得不一样了。包含 yield 的函数不再是一个普通函数，它变成了一个“生成器函数”。yield 的作用是：

1. 像 return 一样，它也会“产出”一个值。
2. 但它不会结束函数！函数会在这里“暂停”，像按了暂停键一样，记住它停在哪儿了，以及当时所有变量的状态。
3. 等着下次被“唤醒”时，它会从上次暂停的地方继续往下执行。

听起来有点神奇？我们来看个例子。

def simple_counter(max_num):print("计数器启动！")n = 0while n < max_num:print(f"准备产出 {n}...")yield n  # 产出 n，然后暂停在这里！print(f"刚产出了 {n}，继续...")n += 1print("计数器结束。")# 调用生成器函数，不会马上执行，而是得到一个“生成器对象”
my_gen = simple_counter(3)
print(f"得到生成器对象: {my_gen}") # 这时函数体内的代码还没执行print("\n第一次请求值:")
value1 = next(my_gen) # 用 next() 唤醒生成器，执行到第一个 yield
print(f"收到值: {value1}")print("\n第二次请求值:")
value2 = next(my_gen) # 从上次暂停处继续，执行到第二个 yield
print(f"收到值: {value2}")print("\n第三次请求值:")
value3 = next(my_gen) # 再次从暂停处继续，执行到第三个 yield
print(f"收到值: {value3}")# 如果我们再用 next(my_gen)，因为循环结束，函数会执行完并抛出 StopIteration 异常
# 通常我们用 for 循环更方便，它会自动处理这个结束信号print("\n用 for 循环遍历生成器:")
# 重新创建一个生成器对象来演示 for 循环
for number in simple_counter(2): # for 循环会自动调用 next()print(f"循环拿到: {number}")

输出会是这样的：

得到生成器对象: <generator object simple_counter at 0x...>第一次请求值:
计数器启动！
准备产出 0...
收到值: 0第二次请求值:
刚产出了 0，继续...
准备产出 1...
收到值: 1第三次请求值:
刚产出了 1，继续...
准备产出 2...
收到值: 2用 for 循环遍历生成器:
计数器启动！
准备产出 0...
循环拿到: 0
刚产出了 0，继续...
准备产出 1...
循环拿到: 1
刚产出了 1，继续...
计数器结束。

看到了吗？函数 simple_counter 并不是一口气执行完的。每次我们通过 next() 或 for 循环向它要值时，它才执行一小段，直到遇到 yield，就把值交出来然后暂停。下次再要，它就从暂停的地方接着跑。

yield 有什么好处呢？

最大的好处是节省内存和实现惰性计算。想象一下，你要处理一个超级大的文件，或者生成一个包含一百万个元素的序列。

如果用传统方法，比如创建一个巨大的列表：

def create_big_list(count):# 想象这里要存储一百万个数字print("开始创建大列表...")result = []for i in range(count):result.append(i * i) # 所有的结果都算出来存到列表里print("大列表创建完毕！")return result# big_list = create_big_list(1_000_000) # 这会瞬间占用大量内存！
# print("列表创建完成")

这需要一次性把所有结果都计算出来并放在内存里，数据量一大，内存可能就爆了。

但如果用 yield：

def generate_big_squares(count):print("生成器启动...")for i in range(count):# 只有当你需要下一个值时，这里才计算print(f"正在计算 {i} 的平方...")yield i * i # 产出一个就暂停，不保存所有结果print("生成器结束.")# 创建生成器对象，几乎不占内存，计算也还没开始
squares_gen = generate_big_squares(5) # 试试改成 1_000_000，也不会有问题print("开始迭代获取值:")
for square in squares_gen: # 每次循环才驱动生成器计算下一个值print(f"  得到一个平方值: {square}")if square > 10: # 可以随时停止处理print("  值够大了，停止处理。")break

输出：

生成器启动...
开始迭代获取值:
正在计算 0 的平方...得到一个平方值: 0
正在计算 1 的平方...得到一个平方值: 1
正在计算 2 的平方...得到一个平方值: 4
正在计算 3 的平方...得到一个平方值: 9
正在计算 4 的平方...得到一个平方值: 16值够大了，停止处理。

yield 方式是“要一个，给一个”，它只在需要的时候才计算和生成数据，并且每次只占用当前计算所需的少量内存。这就是所谓的惰性计算。

现在回到 LLM 的流式响应。

LLM 生成一大段文本是需要时间的。如果等它全部生成完再显示，用户就得干等着，体验不好。

流式响应就是，LLM 每生成一小部分（可能是一个词，一句话），就立刻把它发送出来。接收方（比如我们的 Python 后端程序）收到这一小部分后，不是囤着，而是立刻再把它发给最终用户（比如网页）。

yield 在这里扮演了关键角色。我们可以写一个 Python 函数（生成器函数）来处理从 LLM 过来的数据流：

import time
import random# 这是一个模拟，实际中会是从网络接收 LLM 数据
def llm_response_stream_simulator(prompt):print(f"模拟 LLM 收到提示: '{prompt}'")full_response = ["你好！", "我是一个", "大型语言模型。", "很高兴", "为您服务。"]for chunk in full_response:# 模拟 LLM 生成每个片段需要的时间delay = random.uniform(0.2, 0.8)print(f"   (模拟 LLM 思考 {delay:.2f} 秒...)")time.sleep(delay)print(f"   模拟 LLM 生成了片段: '{chunk}'")yield chunk # 关键！拿到一小块，立刻通过 yield 发出去print("模拟 LLM 响应结束。")# 使用这个生成器
print("向 LLM 请求...")
response_generator = llm_response_stream_simulator("打个招呼")print("\n开始接收并显示流式响应:")
all_text = ""
for text_chunk in response_generator: # 每次循环，驱动模拟器生成并 yield 下一块print(f"  >> 前端收到: {text_chunk}")all_text += text_chunk # 逐渐拼凑完整响应
print("\n流式响应接收完毕！")
print(f"完整响应是: '{all_text}'")

输出（每次运行延迟会不同）：

向 LLM 请求...
得到生成器对象: <generator object llm_response_stream_simulator at 0x...>开始接收并显示流式响应:
模拟 LLM 收到提示: '打个招呼'(模拟 LLM 思考 0.45 秒...)模拟 LLM 生成了片段: '你好！'>> 前端收到: 你好！(模拟 LLM 思考 0.62 秒...)模拟 LLM 生成了片段: '我是一个'>> 前端收到: 我是一个(模拟 LLM 思考 0.28 秒...)模拟 LLM 生成了片段: '大型语言模型。'>> 前端收到: 大型语言模型。(模拟 LLM 思考 0.71 秒...)模拟 LLM 生成了片段: '很高兴'>> 前端收到: 很高兴(模拟 LLM 思考 0.33 秒...)模拟 LLM 生成了片段: '为您服务。'>> 前端收到: 为您服务。
模拟 LLM 响应结束。流式响应接收完毕！
完整响应是: '你好！我是一个大型语言模型。很高兴为您服务。'

在这个模拟里，llm_response_stream_simulator 函数就像是接收 LLM 数据并处理的后端逻辑。它每收到（或模拟生成）一小块文本 chunk，就立刻用 yield chunk 把它“产出”。外面的 for 循环则模拟了接收并显示这些文本块的过程。这样一来，用户就能看到文字一点点出现，而不是等待最后的结果。

总结一下：

Python 的 yield 关键字能让函数变成一个可以暂停和恢复的生成器。这使得我们可以写出内存效率极高的代码来处理大量数据，并且非常适合实现像 LLM 那样的流式数据处理，因为它允许我们“来多少，处理多少，传递多少”，从而给用户带来更流畅、更即时的体验。下次再看到那种“打字机”效果，你就可以想到，背后很可能就是 yield 在默默工作呢！