零基础入门 DeepSeek API 流式传输：兼容 OpenAI SDK 调用、核心工作原理解析、流事件处理与文本提取、Token 用量统计、首个 Token 时间性能对比、自定义流处理器与多轮流式

酉鬼女又兒

342人浏览 · 2026-07-19 23:28:21

酉鬼女又兒 · 2026-07-19 23:28:21 发布

📌 全文精简速览（复习专用）本文是面向编程小白的 DeepSeek 流式 API 全攻略，核心内容可浓缩为 7 点：

DeepSeek API 完全兼容 OpenAI SDK，仅需修改base_url为https://api.deepseek.com即可快速初始化客户端，支持 dotenv 管理密钥。

流式传输核心是stream=True参数，可让 AI 生成内容边输出边展示，无需等待全部生成完成，大幅优化用户感知体验。

流式响应为统一的ChatCompletionChunk对象，文本内容存于choices[0].delta.content，需判断非空后逐段拼接或实时打印。

Token 统计有两种方案：非流式二次调用精准统计、流式循环中近似累计，部分 API 版本可从结束 chunk 直接读取 usage 数据。

流式传输可将首个 Token 响应时间（TTFT）从数秒压缩到 1 秒内，但总生成时长与非流式基本一致，并不加快模型本身生成速度。

可通过封装自定义流处理器类，统一管理文本输出、事件回调与结果缓存，提升代码复用性，还可搭配 ANSI 颜色优化终端显示。

维护会话历史列表 + 流式输出，可快速实现带上下文记忆、实时打字机效果的多轮聊天机器人，支持输入 quit 退出。

📦 一、环境准备：DeepSeek 客户端初始化

DeepSeek API 100% 兼容 OpenAI 的 SDK 格式，不用学习新的调用语法，只需修改接口地址即可快速上手。

📊 知识点汇总表

对比项	Claude API	DeepSeek API（兼容 OpenAI）
依赖安装	`pip install anthropic`	`pip install openai python-dotenv`
客户端类	`Anthropic()`	`OpenAI()`
核心配置	仅需配置 api_key	需同时配置 api_key + base_url
密钥管理	支持环境变量	支持环境变量，推荐 dotenv 文件管理

📝 完整代码样例

# 导入依赖：dotenv读取环境变量，OpenAI为官方SDK，os用于系统交互
from dotenv import load_dotenv
from openai import OpenAI
import os
加载项目根目录.env文件中的配置，避免密钥硬编码泄露
load_dotenv()
初始化DeepSeek客户端，完全复用OpenAI SDK语法
client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),  # 从环境变量读取API密钥
base_url="https://api.deepseek.com"       # DeepSeek官方接口地址
)

💡 代码逐行解释

依赖导入：python-dotenv是密钥管理工具，可将 API 密钥写在.env文件中，避免直接写在代码里造成泄露；OpenAI是官方 SDK，DeepSeek 完全兼容其接口规范。
加载环境变量：load_dotenv()会自动读取当前目录下.env文件的配置，例如文件内写入DEEPSEEK_API_KEY=sk-你的密钥即可。
客户端初始化：和原生 OpenAI 调用的唯一区别是base_url参数，将地址指向 DeepSeek 官方接口，后续所有调用语法和 OpenAI 完全一致。
小白提示：本地测试时如果没有配置环境变量，也可以直接填写密钥字符串api_key="sk-xxx"，但生产环境强烈不推荐。

⚡ 二、基础调用：非流式 vs 流式传输

流式传输是本文的核心概念。普通非流式调用必须等 AI 生成完全部内容才会返回结果，而流式传输可以生成一段、返回一段，实现类似打字机的实时效果。

📊 知识点汇总表

对比项	非流式调用	流式调用
核心参数	无特殊参数	`stream=True`
返回类型	完整响应对象，包含全部文本	Stream 生成器对象，逐段返回文本片段
展示时机	全部生成完成后一次性展示	生成一段展示一段，实时输出
适用场景	短文本、后台批量调用、需完整结果再处理	前端对话界面、长文本生成、优化用户体验
用户感知	等待时间长，易产生卡顿感	首字响应快，感知上更流畅

📝 代码样例 1：非流式调用（基础版）

from dotenv import load_dotenv
from openai import OpenAI
import os
load_dotenv()
client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)
发起非流式请求，语法和OpenAI完全一致
response = client.chat.completions.create(
messages=[{"role": "user", "content": "请写一篇关于亚马逊金刚鹦鹉和黏土食的短文"}],
model="deepseek-chat",
max_tokens=1000,      # 限制最大生成token数
temperature=0,         # 温度为0，输出更确定、更严谨
)
print("我们已收到回复！")
print("========================")
直接读取完整响应文本
print(response.choices[0].message.content)

非流式调用运行截图

非流式调用完整响应截图

💡 代码解释

非流式是最基础的调用方式：发起请求后程序会阻塞等待，直到 AI 生成完全部内容，才返回完整的响应对象。文本固定存储在response.choices[0].message.content中，直接读取即可。缺点是生成长文本时，用户要等待数秒才能看到第一个字，体验较差。

📝 代码样例 2：流式调用（最简版）

from dotenv import load_dotenv
from openai import OpenAI
import os
load_dotenv()
client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)
仅需添加stream=True，即可开启流式传输
r_stream = client.chat.completions.create(
model="deepseek-chat",
max_tokens=1000,
temperature=0,
stream=True,
messages=[{"role": "user", "content": "请写一篇关于亚马逊金刚鹦鹉和黏土食的短文"}]
)
print("我们已收到回复！")
print("========================")
for chunk in r_stream:
print(chunk)
collected = []  # 用于收集所有文本片段
for chunk in r_stream:
# 判断当前片段是否包含文本内容（首尾chunk可能为空，仅含元数据）
if chunk.choices[0].delta.content is not None:
content = chunk.choices[0].delta.content
print(repr(content))  # 打印原始片段，带引号方便观察分段
collected.append(content)
拼接所有片段得到完整文本
print("\nFull response:", "".join(collected))

流式调用chunk结构截图

流式调用完整输出截图1

流式调用完整输出截图2

💡 代码解释

开启流式：请求参数中添加stream=True后，返回的不再是完整响应对象，而是一个可迭代的Stream生成器。
遍历数据块：通过for循环逐个读取chunk（数据块），每个 chunk 对应 AI 生成的一小段内容。
内容提取：流式片段的文本存储在chunk.choices[0].delta.content中，首尾 chunk 通常不含文本内容，因此必须加is not None判断，避免报错。
结果拼接：将所有非空文本片段存入列表，最后用"".join()拼接，即可得到和非流式一致的完整响应内容。

🎯 三、进阶处理：流式文本实时输出

流式传输最常用的场景是实时打字机效果，通过调整打印参数即可在终端实现边生成边显示的效果。

📊 知识点汇总表

对比项	Claude 流式事件	DeepSeek 流式事件
事件类型	5 种以上（开始、内容块、结束等）	仅 1 种：ChatCompletionChunk
文本字段	`event.delta.text`（需匹配事件类型）	`chunk.choices[0].delta.content`
结束标记	`MessageStopEvent` 事件	`finish_reason` 不为 None
上手难度	高，事件类型多逻辑复杂	低，结构简单易理解

📝 代码样例：终端打字机实时效果

stream = client.chat.completions.create(
    messages=[{"role": "user", "content": "大语言模型是怎么工作的？"}],
    model="deepseek-chat",
    max_tokens=1000,
    temperature=0,
    stream=True,
)
逐段实时打印，不换行，强制刷新缓冲区
for chunk in stream:
if chunk.choices[0].delta.content is not None:
# end="" 取消print默认换行；flush=True 强制立刻输出，不等待缓冲区
print(chunk.choices[0].delta.content, flush=True, end="")

💡 代码解释

end=""：Python 的print函数默认会在结尾添加换行符，使用end=""可以让所有文本在同一行连续输出，模拟打字机的连续显示效果。
flush=True：Python 输出默认会积攒到缓冲区满了才打印到终端，添加该参数可以让每一个文本片段生成后立刻显示，真正实现 "边生成边输出" 的实时体验。
小白提示：运行后会看到文字逐片段蹦出，和主流 AI 对话产品的显示效果完全一致。

💰 四、用量统计：Token 计数的两种实现方案

Token 是大模型的计费单位，流式场景下无法直接从响应对象读取用量，有两种主流的统计方案。

📊 知识点汇总表

方案	实现方式	优点	缺点
方案一：非流式二次查询	流式输出后，再发起一次非流式请求获取 usage	计数 100% 精准	额外产生一次 API 调用，增加费用
方案二：流式循环累计	遍历 chunk 时逐段计数，结束时尝试读取 chunk 的 usage	无额外调用，零成本	手动计数为近似值，仅部分 API 版本返回结束 chunk 的 usage

📝 代码样例 1：非流式精准统计

from dotenv import load_dotenv
from openai import OpenAI
import os
load_dotenv()
client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)
发起非流式请求，限制生成长度，主要用于获取精准token统计
usage_response = client.chat.completions.create(
messages=[
{"role": "user", "content": "用中文回答 How do large language models work? 简要的用中文回答这个英文问题"}
],
model="deepseek-v4-flash",
max_tokens=1000,
temperature=0,
max_completion_tokens=1,  # 仅生成1个token，最小成本获取输入token统计
)
print("\n========================")
print(f"Input tokens: {usage_response.usage.prompt_tokens}")
print(f"Output tokens: {usage_response.usage.completion_tokens}")
print(f"Total tokens: {usage_response.usage.total_tokens}")

非流式精准统计输出截图

💡 代码解释

max_completion_tokens=1：限制 AI 只生成 1 个输出 token，以最低成本拿到输入 token 的精准计数。
usage对象包含三个核心数据：prompt_tokens是用户输入的 token 数，completion_tokens是 AI 生成的 token 数，total_tokens为两者之和，是计费的核心依据。
适用场景：需要精准核算费用、做账单统计的生产环境。

🔢 Token 类型大白话解释

🟢 1. Input tokens（输入令牌数）—— 你发的消息

打印的是：usage.prompt_tokens
大白话：你发给 AI 的那句提问被模型拆解后，总共占了多少个 Token。
类比：相当于你寄快递时，包裹的重量（不含回信）。

🔵 2. Output tokens（输出令牌数）—— AI 回的答案

打印的是：usage.completion_tokens
大白话：AI 生成的回答一共消耗了多少个 Token。
类比：相当于你收到回信时，回信包裹的重量。

🟣 3. Total tokens（总令牌数）—— 本次对话总计

打印的是：usage.total_tokens
大白话：上面两个加起来的总和（Input + Output）。
类比：相当于本次聊天总的流量消耗。

📝 代码样例 2：流式近似统计 + 结束 chunk 读取

from dotenv import load_dotenv
from openai import OpenAI
import os
load_dotenv()
client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)
stream = client.chat.completions.create(
model="deepseek-chat",
max_tokens=1000,
messages=[
{"role": "user", "content": "用中文回答 How do large language models work? 简要的用中文回答这个英文问题"}
],
stream=True
)
output_tokens = 0
for chunk in stream:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
output_tokens += 1  # 近似数
# 判断是否为结束chunk，部分API版本会在此返回完整usage
if chunk.choices[0].finish_reason is not None:
if hasattr(chunk, 'usage') and chunk.usage:
print(f"\nUsage: {chunk.usage}")

流式近似统计输出截图

💡 代码解释

近似计数：每个带文本的 chunk 大致对应 1 个 token，循环中累加计数，可得到输出 token 的近似值，适合做进度预估。
结束判断：当finish_reason不为None时，代表生成结束（通常值为stop，表示正常结束）。
读取 usage：部分 DeepSeek API 版本会在最后一个 chunk 中附带完整的 usage 数据，用hasattr判断属性是否存在，存在则直接读取，精准且无额外成本。

💾 缓存机制（DeepSeek 特有的省钱妙招）

下面这一坨看起来复杂的字段，其实是 DeepSeek 的上下文缓存（Prompt Caching）技术。简单说就是：如果你短时间内问相同或类似的问题，AI 不用重新计算，直接调取缓存，价格会便宜很多（通常打 1 折）。

字段	数值	大白话解释
`prompt_cache_hit_tokens`	0	命中了缓存的 Token 数量。这里是 0，意味着你的提问是全新的，没有命中缓存，所以这次没有享受到折扣。
`prompt_cache_miss_tokens`	23	未命中缓存的 Token 数量。这里也是 23，意味着你输入的 23 个 Token 全部需要重新计算，所以按原价收费。
`cached_tokens`（在`prompt_tokens_details`里）	0	这个和上面的`hit`是一个意思，就是命中了 0 个。

💡 简单数学：prompt_tokens (23) = prompt_cache_hit_tokens (0) + prompt_cache_miss_tokens (23)。

❓ 那些 None 和看不懂的细节

字段	数值	解释
`completion_tokens_details`	None	这个是用来记录输出（回答）里有没有特殊音频或视频 Token 的。你这里是纯文字，所以是空（`None`），不用管。
`audio_tokens`	None	同上，你没有输入音频，所以为空。

🛡️ 安全判断：两层防护

🛡️ 第一层：`hasattr(chunk, 'usage')`

字面意思：检查这个chunk（数据包）有没有一个叫做usage的属性。
通俗类比：就像拆快递时，先看看包裹上有没有贴"发票清单"。如果没有这个标签，你就别去撕它，否则会撕坏包装（程序报错）。

✅ 第二层：`and chunk.usage`

字面意思：如果确实有这个属性，再进一步检查这个属性里面的内容是不是存在（不为空、不为None、不为 0）。
通俗类比：就算贴了"发票清单"标签，你还要看一眼清单上是不是真的写了字（有数据）。如果只是个空白的标签，那也没用，不需要打印。

⚡ 五、性能对比：首个 Token 时间（TTFT）

流式传输最大的价值是优化首个 Token 时间（TTFT），这是衡量 AI 对话体验的核心指标。

📊 知识点汇总表

指标	非流式调用	流式调用
首个 Token 时间（TTFT）	~3-5 秒（与完整响应时间一致）	~0.5-1 秒
完整响应总时长	~3-5 秒	~3-5 秒
生成 token 总数	相同	相同
用户感知速度	慢，需等待全部生成	快，立刻能看到内容

💡 核心概念

TTFT（Time To First Token）：从发起请求到收到第一个生成文本片段的时间。流式传输并不会加快模型的总生成速度，但能让用户更快看到第一句话，大幅降低等待的焦虑感，感知上 "AI 反应更快"。

📝 代码样例 1：非流式 TTFT 测试

import time
start_time = time.time()  # 记录请求开始时间
response = client.chat.completions.create(
max_tokens=500,
messages=[{"role": "user", "content": "写一篇长文介绍美国独立战争的历史"}],
temperature=0,
model="deepseek-chat",
)
response_time = time.time() - start_time  # 计算总耗时
print(f"首个token时间: {response_time:.3f} 秒")
print(f"完整响应总时间: {response_time:.3f} 秒")
print(f"生成总token数: {response.usage.completion_tokens}")
print(response.choices[0].message.content[:200] + "...")  # 仅打印前200字

💡 代码解释

非流式模式下，第一个 token 和最后一个 token 会同时返回，因此首个 token 时间等于完整响应总时间。生成长文本时，用户需要等待数秒才能看到任何内容，体验较差。

📝 代码样例 2：流式 TTFT 测试

def measure_streaming_ttft():
    start_time = time.time()
    stream = client.chat.completions.create(
        max_tokens=500,
        messages=[{"role": "user", "content": "写一篇长文介绍美国独立战争的历史"}],
        temperature=0,
        model="deepseek-chat",
        stream=True
    )
have_received_first_token = False
ttft = 0
output_tokens = 0
for chunk in stream:
if chunk.choices[0].delta.content is not None:
# 第一次收到文本时，记录TTFT
if not have_received_first_token:
ttft = time.time() - start_time
have_received_first_token = True
    print(chunk.choices[0].delta.content, flush=True, end="")
    output_tokens += 1
total_time = time.time() - start_time
print(f"\n\n首个token时间: {ttft:.3f} 秒", flush=True)
print(f"完整响应总时间: {total_time:.3f} 秒", flush=True)
print(f"生成总token数（近似）: {output_tokens}", flush=True)
measure_streaming_ttft()

💡 代码解释

用布尔变量have_received_first_token标记是否收到第一个文本片段。
第一次进入内容判断时，计算从请求开始到当前的时间差，即为 TTFT。
最终可观察到：流式的 TTFT 通常不到 1 秒，但总生成时长和非流式几乎一致。流式的本质是 "边做边上菜"，而不是 "做饭更快"。

🧩 六、进阶封装：自定义流处理器

当项目中频繁使用流式调用时，重复编写 chunk 判断、文本拼接的代码会很冗余，可以封装成通用的流处理器类。

📊 知识点汇总表

功能	说明
统一事件处理	封装 chunk 解析、内容提取、结束判断，主代码更简洁
自定义回调	可给文本加颜色、触发日志、调用业务函数
结果自动缓存	自动拼接完整响应，无需手动维护列表
高可复用性	一次封装，所有流式调用场景均可复用

📝 代码样例：自定义 StreamHandler 类

class StreamHandler:
    """自定义流处理器，封装流式响应全流程处理逻辑"""
    def __init__(self):
        self.full_content = []  # 缓存完整响应文本
def on_content(self, text):
    """处理每一段文本：绿色打印 + 存入缓存"""
    print(f"\033[92m{text}\033[0m", end="", flush=True)
    self.full_content.append(text)
def on_complete(self):
"""流式传输结束时的回调处理"""
print("\n\n✅ 生成完成！")
return "".join(self.full_content)
使用示例
handler = StreamHandler()
stream = client.chat.completions.create(
messages=[{"role": "user", "content": "大语言模型是怎么工作的？"}],
model="deepseek-chat",
max_tokens=1000,
temperature=0,
stream=True,
)
for chunk in stream:
if chunk.choices[0].delta.content is not None:
handler.on_content(chunk.choices[0].delta.content)
full_response = handler.on_complete()
print(f"\n完整响应长度: {len(full_response)} 字符")

💡 代码解释

类封装思想：将所有流式处理逻辑封装进StreamHandler类，外部调用只需创建实例、循环传入 chunk 即可，代码更整洁。
事件回调：on_content、on_complete属于回调函数，对应流式过程中的不同阶段，可在函数内自定义业务逻辑，比如存入数据库、触发消息通知。
ANSI 颜色代码：\033[92m等是终端 ANSI 转义序列，可控制文字颜色和样式，丰富终端显示效果。

🚀 七、实战项目：多轮流式聊天机器人

结合前面所有知识点，我们可以实现一个带上下文记忆、实时打字机效果的终端聊天机器人。

📊 功能汇总表

功能点	实现方式
多轮上下文记忆	用列表维护会话历史，每次请求携带全部历史消息
实时打字机效果	流式传输 + end="" + flush=True
角色视觉区分	ANSI 颜色代码，用户蓝色、AI 绿色
退出机制	输入 quit 关键词跳出循环
会话持久化	每轮结束后将 AI 完整回复追加到会话列表

📝 完整代码样例

from openai import OpenAI
import os

# 初始化 DeepSeek 客户端
client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com"
)

# ANSI 颜色代码
BLUE = "\033[94m"
GREEN = "\033[92m"
RESET = "\033[0m"

def chat_with_deepseek():
    print("欢迎使用 DeepSeek 聊天机器人！")
    print("输入 'quit' 退出聊天。\n")

    conversation=[]

    while True:
        user_input=input(f"{BLUE}You:{RESET}")

        if user_input.lower()=='quit':
            print("再见！")
            break

        conversation.append({"role":"user","content":user_input})

        print(f"{GREEN}DeepSeek:{RESET}",end="",flush=True)

        stream=client.chat.completions.create(
            model="deepseek-chat",
            max_tokens=1000,
            messages=conversation,
            stream=True
        )

        assistant_response = ""
        for chunk in stream:
            if chunk.choices[0].delta.content is not None:
                content=chunk.choices[0].delta.content
                print(f"{GREEN}{content}{RESET}",end="",flush=True)
                assistant_response+=content

        print() #完整响应后换行

        conversation.append({"role":"assistant","content":assistant_response})

if __name__=="__main__":
    chat_with_deepseek()

聊天机器人运行截图

💡 代码逐部分解释

会话管理：conversation列表是多轮对话的核心，按顺序存储所有用户提问和 AI 回复，每次请求都将完整列表传给 API，AI 即可记住之前的对话内容。
输入循环：while True构建无限循环，持续等待用户输入，直到输入quit触发break跳出循环。
流式输出：复用前文的流式打印逻辑，配合 ANSI 颜色代码实现蓝色用户、绿色 AI 的视觉区分。

🔍 quit 判断机制详解

用户输入	`.lower()` 转换后	是否等于 `'quit'`？	结果
`quit`	`'quit'`	✅ 是	退出程序
`Quit`	`'quit'`	✅ 是	退出程序
`QUIT`	`'quit'`	✅ 是	退出程序
`qUiT`	`'quit'`	✅ 是	退出程序
`exit`	`'exit'`	❌ 否	当成聊天内容发给 AI

聊天机器人效果展示

📋 八、总览：DeepSeek vs Claude API 核心差异

📊 差异汇总表

对比维度	Claude (Anthropic)	DeepSeek (OpenAI 兼容)
SDK 安装命令	`pip install anthropic`	`pip install openai`
客户端初始化	`Anthropic(api_key=...)`	`OpenAI(api_key=..., base_url="https://api.deepseek.com")`
非流式调用方法	`client.messages.create(...)`	`client.chat.completions.create(...)`
流式开启方式	`stream=True`	`stream=True`
非流式文本路径	`response.content[0].text`	`response.choices[0].message.content`
流式文本路径	`event.delta.text`（需匹配事件类型）	`chunk.choices[0].delta.content`
主流模型名称	`claude-3-haiku-20240307`等	`deepseek-chat`、`deepseek-reasoner`
系统提示设置	独立的`system`参数	放入 messages 列表，role 设为 system
流式事件复杂度	高，5 种以上事件类型	低，仅一种 chunk 结构，上手更快

🔍 流式传输核心概念详解：delta 是什么？

delta 是流式传输里最核心的概念，简单一句话：delta 就是"增加的那一小部分"，不是全部。

📦 先打个比方

你让 AI 写一句话（比如"今天天气真好"）。
如果不开流式（stream=False），AI 会一次性把整个箱子扔给你。
但你开了流式（stream=True），AI 就像发微信消息一样，一个字一个字地往外蹦（其实是按片段发）。

这段代码的作用就是：把这些蹦出来的字一个一个接住，最后拼成完整的一句话。

📝 核心代码示例

collected = []
for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        content = chunk.choices[0].delta.content
        print(repr(content))
        collected.append(content)
print("\nFull response:", "".join(collected))

🔍 逐行大白话解释

collected = []

意思：拿一个空盒子（列表）放这里。准备一会儿把收到的字都丢进这个盒子里。

for chunk in stream:

意思：stream就是 AI 给你发来的一串"快递包裹流"。for chunk in意思就是：快递员每送来一个小包裹（chunk），我就打开看一次。直到所有包裹送完为止。

if chunk.choices[0].delta.content is not None:

意思：打开包裹后，先看一眼里面有没有字。因为有的包裹只是说"我还在打字哦"，里面是空的（None）。这句代码就是过滤掉空包裹，只处理有内容的。

content = chunk.choices[0].delta.content

意思：确认包裹里有字后，把里面的那一小段文字拿出来，给它起个名字叫content（内容）。

print(repr(content))

意思：把拿到的这一小段字打印在屏幕上。这里的repr()有点讲究：它会带上引号打印，比如'今'、'天'。这样你就能清楚看到它收到了什么，连空格、换行都能看见（方便调试）。

collected.append(content)

意思：把这小段字放进刚才准备的空盒子（collected 列表）里。

print("\nFull response:", "".join(collected))

意思：等所有包裹都收完了（循环结束），把盒子里的小碎片全部拼接起来。"".join(collected)意思是：用空字符串""当做"胶水"，把列表里的字一个个粘起来。比如['今','天','好']变成"今天好"。最前面的\n是换行，让结果另起一行显示，更美观。

📊 概念速查表

概念	大白话解释
`chunk`	快递员送来的一次包裹
`delta`	这个包裹里装的新增的碎片（不是全部拼好的）
`content`	具体的那几个字（比如`"今"`、`"天"`）