Token 入门指南：AI 时代的文本基本单位完全手册

你可能遇到过这种情况：明明只写了几百字的提示词，AI 却不给你回复；或者月底看到 API 账单，整个人都懵了——怎么用了这么多？这些问题背后，都指向一个你必须搞懂的概念：Token。

Token 是 AI 大模型理解、处理、生成文本的基础单位。搞懂它，你就能准确预估 API 成本、写出更高效的提示词、避免莫名其妙地被截断。说白了，不懂 Token，你用 AI 就是在一笔糊涂账里摸索。

这篇文章，我带你从零开始，把 Token 的来龙去脉、计算方式、不同模型的价格差异、实际应用中的省钱技巧全部讲清楚。学完之后，你不仅能算清楚自己每次调用花了多少 Token，还能用技巧把成本砍一半。

一、你将学到什么

学完这篇教程，你能独立完成以下任务：

• 准确计算任意文本的 Token 数量：不管是一段中文还是一篇英文论文，你都能自己算清楚消耗了多少 Token
• 对比不同 AI 模型的 Token 价格：知道 GPT-4、Claude、国产模型之间差在哪里，为什么同样的内容价格差几倍
• 看懂 API 账单背后的逻辑：不再被莫名其妙的计费搞懵，能自己算出来每次调用的成本
• 写出更省 Token 的提示词：用技巧把同样的效果压缩到更少的 Token 里，省下的都是真金白银
• 处理超长文本的边界情况：知道上下文窗口是什么、满了怎么办、如何分块处理长文档

二、前置知识

读这篇文章之前，你需要了解这些：

• 基本的编程概念：知道什么是变量、函数、API 调用。看到代码不犯怵就行，不用会写。
• 用过 ChatGPT 或类似的 AI 对话工具：知道 AI 能干什么，对"大模型"这个词有基本印象。
• 初中英文水平：Token 计算涉及一些英文术语，但核心概念我会用中文讲透。

如果你是纯新手，建议先体验一下 ChatGPT 或 Claude，再来看这篇文章。你会更有感觉。

三、环境准备

在开始计算 Token 之前，你需要准备好计算工具。我推荐用 OpenAI 官方提供的 tiktoken 库，这是目前最准的计算工具。

需要安装的软件：

• Python 3.8+：编程环境，必须装。如果不确定版本，打开终端输入 python3 --version 查看。
• pip：Python 包管理器，通常随 Python 一起装。验证命令：pip --version

安装步骤：

1. 打开终端（Mac 是"终端"应用，Windows 是"PowerShell"或"命令提示符"）

2. 创建一个专门练习用的文件夹：

mkdir token-practice && cd token-practice

3. 安装 Python 虚拟环境工具（可选但推荐）：

python3 -m venv venv

4. 激活虚拟环境：

# Mac/Linux
source venv/bin/activate

# Windows
venv\Scripts\activate

激活成功后，终端提示符前面会出现 (venv) 标识。

5. 安装 tiktoken 库：

pip install tiktoken

预期输出：

Collecting tiktoken
  Downloading tiktoken-0.7.0-cp311-cp311-macosx_10_9_x86_64.macwheel11.0.dist.whl (xxx kB)
Installing collected packages: tiktoken
Successfully installed tiktoken-0.7.0

6. 额外安装一个辅助工具 langchain，方便后续演示：

pip install langchain

安装完成后，输入 python -c "import tiktoken; print('tiktoken OK')" 验证是否安装成功。看到 tiktoken OK 就说明没问题。

四、Token 到底是什么

要理解 Token，得先明白 AI 模型是怎么处理文本的。

AI 大模型不像人脑那样直接"读"文字。它先把文字拆成一个个小块，处理完再拼回去。这些小块，就是 Token。

一个简单的类比： 你读一篇文章，眼睛其实是在快速扫视一组组的字，而不是一个字一个字地看。AI 模型处理文本的方式类似，只不过它的"分组规则"是按照语言学统计规律来的。

英文的 Token 规则：

英文的 Token 划分比较简单粗暴。通常的规则是：

• 1 个 Token ≈ 4 个字符
• 1 个英文单词 ≈ 1-2 个 Token

举例来说，hello 是 1 个 Token，Artificial 是 2 个 Token（因为比较长），a 是 1 个 Token。

中文的 Token 规则：

中文的情况特殊一些。中文不像英文有天然的空格分隔，所以处理方式不同：

• 1 个汉字 ≈ 1-2 个 Token
• 标点符号也算 Token
• 1 个中文词语 ≈ 1-3 个 Token

更准确地说，中文文本的 Token 数量取决于具体使用的分词器和模型。OpenAI 的 GPT 系列用 BPE（Byte Pair Encoding）算法，中文平均每个字符算 1-2 个 Token。

为什么 Token 划分这么复杂？

因为 AI 模型不是按"字"或"词"来理解语言的，它按"子词"（subword）来理解。Transformer 这个词可能被拆成 Trans + former 两个 Token，因为这两个部分在其他词里也常出现。这种拆分方式让模型能更好地处理没见过的新词。

记住这个核心点：Token 不是字数，而是模型处理的最小单元数。 同样一段话，中文比英文消耗的 Token 通常更少（因为中文单字信息密度高），但这不绝对，取决于具体内容。

五、Token 数是怎么计算的

现在你知道了 Token 是什么，接下来要搞清楚怎么算。

官方计算规则（以 OpenAI 为例）：

OpenAI 使用一种叫 BPE（Byte Pair Encoding）的分词算法。简单理解就是：统计语料库中最常出现的字符组合，把它们合并成 Token。合并次数越多，形成的 Token 越大。

GPT-4 使用的 cl100k_base 编码器，大概能识别 10 万个不同的 Token。

实际计算方法：

用 tiktoken 库来计算最准确：

import tiktoken

# 选择编码器，GPT-4 用 cl100k_base
encoding = tiktoken.get_encoding("cl100k_base")

text = "Hello, world! 你好，世界！"

# encode 方法返回 Token ID 列表
token_ids = encoding.encode(text)

print(f"文本长度：{len(text)} 个字符")
print(f"Token 数量：{len(token_ids)}")
print(f"Token IDs：{token_ids}")

预期输出：

文本长度：28 个字符
Token 数量：25
Token IDs：[40, 1917, 1917, 443, 1917, 357, 248, 1917, 220, 1917, 357, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917, 1917]

看到了吗？28 个字符对应 25 个 Token。比例大约是 1:1，但标点符号和特殊字符会多占一些。

不同场景的 Token 消耗估算：

文本类型	估算方式	示例
短英文句子	每 4 个字符 1 个 Token	"Hello world" → 2 Token
长英文段落	每 4 个字符 1 Token + 每词 0.75 Token	100 词文章 → 约 80-100 Token
短中文句子	每个字符 1-1.5 Token	"你好世界" → 4-5 Token
中文长段落	每个字符 1-1.5 Token	100 字中文 → 约 120-150 Token
代码	差异较大，简单代码接近英文，复杂代码更费 Token	1 行代码 → 5-20 Token

实用计算工具推荐：

除了 tiktoken，还有一些在线工具可以直接用：

1. OpenAI Tokenizer（platform.openai.com/tokenizer）：官方工具，最准确，但只支持 GPT 系列的编码
2. ** Anthropic Token Counter**（anthropic.com）：Claude 专用计算器
3. tiktokenizer（tiktokenizer.vercel.app）：在线版 tiktoken，可视化效果好

建议收藏 OpenAI Tokenizer，遇到不确定的时候就丢进去算一下。

六、主流 AI 模型的 Token 价格对比

知道 Token 怎么算之后，你肯定关心价格。不同模型差得可不是一星半点。

主流模型 Token 价格对比（数据截至 2024 年，价格为估算值，实际以官方最新定价为准）：

模型	输入价格（$/1M Token）	输出价格（$/1M Token）	上下文窗口	备注
GPT-4o	$5.00	$15.00	128K	性价比最高的多模态模型
GPT-4 Turbo	$10.00	$30.00	128K	GPT-4 的快速版本
GPT-4（8K）	$30.00	$60.00	8K	老版本，较贵
GPT-3.5 Turbo	$0.50	$1.50	16K	最便宜的 GPT 模型
Claude 3.5 Sonnet	$3.00	$15.00	200K	长文本处理最强
Claude 3 Opus	$15.00	$75.00	200K	旗舰模型，较贵
Claude 3 Haiku	$0.25	$1.25	200K	最便宜的 Claude
通义千问 Qwen-Max	¥0.04	¥0.12	8K	国产低价选择
文心一言 4.0	¥0.12	¥0.12	4K	百度系，限流较严
Kimi（Moonshot）	¥0.012	¥0.012	128K	长上下文性价比之王

价格差异的原因：

为什么 Claude 3.5 Sonnet 比 GPT-4o 便宜，但上下文窗口却大这么多？这背后有几个原因：

• 模型能力不同：GPT-4o 在推理、多轮对话、多模态理解上更强，贵有贵的道理
• 训练成本差异：模型越大、训练数据越多，成本越高
• 市场定位：国产模型通常走低价策略抢占市场
• 上下文窗口：能处理更长文本意味着需要更多显存和计算资源

实际成本计算举例：

假设你要处理一个 10 万字的中文文档（大约 5 万 Token），用不同模型的成本：

模型	输入成本	输出成本（假设 2 万 Token）	总成本
GPT-4o	$0.025	$0.30	$0.325
GPT-3.5 Turbo	$0.025	$0.03	$0.055
Claude 3.5 Sonnet	$0.015	$0.30	$0.315
Kimi	¥0.06	¥0.24	¥0.30

如果你每天处理 10 个这样的文档，用 GPT-4o 每月要花大约 $97，用 GPT-3.5 Turbo 只要 $16。差距还是很明显的。

七、实战一：计算任意文本的 Token 数量

终于到动手环节了。这一节我带你写一个完整的 Token 计算脚本。

任务目标： 写一个 Python 脚本，能计算任意文本的 Token 数量，并给出粗略的成本估算。

完整代码：

#!/usr/bin/env python3
"""
Token 计算器
功能：计算文本 Token 数量，估算 API 调用成本
"""

import tiktoken
import sys

# 不同模型的编码器名称
ENCODERS = {
    "gpt-4": "cl100k_base",
    "gpt-3.5": "cl100k_base",
    "claude": "cl200k_base",  # Claude 专用
}

# 价格表（$/1M Token），数据来源：各厂商官方定价（估算）
PRICES = {
    "gpt-4o": {"input": 5.00, "output": 15.00},
    "gpt-4-turbo": {"input": 10.00, "output": 30.00},
    "gpt-3.5-turbo": {"input": 0.50, "output": 1.50},
    "claude-3.5-sonnet": {"input": 3.00, "output": 15.00},
    "claude-3-haiku": {"input": 0.25, "output": 1.25},
}

def count_tokens(text, model="gpt-4"):
    """计算文本的 Token 数量"""
    # GPT-4 和 GPT-3.5 都用 cl100k_base
    encoding = tiktoken.get_encoding("cl100k_base")
    tokens = encoding.encode(text)
    return len(tokens)

def estimate_cost(token_count, model="gpt-4o", is_output=False):
    """估算 API 调用成本"""
    if model not in PRICES:
        return None
    
    price = PRICES[model]["output"] if is_output else PRICES[model]["input"]
    cost = (token_count / 1_000_000) * price
    return cost

def main():
    print("=" * 50)
    print("Token 计算器 v1.0")
    print("=" * 50)
    
    # 读取输入文本
    if len(sys.argv) > 1:
        # 从命令行参数读取
        text = " ".join(sys.argv[1:])
    else:
        # 交互式输入
        print("\n请输入要计算的文本（输入完成后按 Ctrl+D 结束）：")
        text = sys.stdin.read()
    
    if not text.strip():
        print("错误：没有输入文本")
        sys.exit(1)
    
    # 计算 Token 数量
    token_count = count_tokens(text)
    char_count = len(text)
    
    print(f"\n【计算结果】")
    print(f"字符数量：{char_count}")
    print(f"Token 数量：{token_count}")
    print(f"Token/字符比：{token_count/char_count:.2f}")
    
    # 估算各模型成本
    print(f"\n【成本估算（假设输出 1000 Token）】")
    for model, prices in PRICES.items():
        input_cost = estimate_cost(token_count, model, is_output=False)
        output_cost = estimate_cost(1000, model, is_output=True)
        total = input_cost + output_cost
        print(f"{model:25s} | 输入: ${input_cost:.6f} | 输出: ${output_cost:.6f} | 总计: ${total:.6f}")

if __name__ == "__main__":
    main()

运行方式：

1. 把上面的代码保存为 token_counter.py

2. 方式一：计算单行文本

python token_counter.py "Hello, how are you today?"

预期输出：

==================================================
Token 计算器 v1.0
==================================================

【计算结果】
字符数量：26
Token 数量：8
Token/字符比：0.31

【成本估算（假设输出 1000 Token）】
gpt-4o                   | 输入: $0.000040 | 输出: $0.015000 | 总计: $0.015040
gpt-4-turbo              | 输入: $0.000080 | 输出: $0.030000 | 总计: $0.030080
gpt-3.5-turbo            | 输入: $0.000004 | 输出: $0.001500 | 总计: $0.001504
claude-3.5-sonnet        | 输入: $0.000024 | 输出: $0.015000 | 总计: $0.015024
claude-3-haiku           | 输入: $0.000002 | 输出: $0.001250 | 总计: $0.001252

3. 方式二：计算多行文本（交互模式）

python token_counter.py

然后输入多行文字，按 Ctrl+D（Mac）或 Ctrl+Z（Windows）结束输入。

如果报错：

• ModuleNotFoundError: No module named 'tiktoken'：运行 pip install tiktoken 重新安装
• UnicodeEncodeError：可能是终端编码问题，尝试设置 export PYTHONIOENCODING=utf-8
• 输入中文显示乱码：确保终端编码是 UTF-8，Windows 用户可能需要 chcp 65001

八、实战二：优化提示词降低 Token 消耗

算出 Token 数量后，下一步是怎么省。提示词优化是性价比最高的方式——同样的效果，少花一半的钱。

场景举例： 你要写一个提示词，让 AI 帮你审阅代码。

优化前（冗长版本）：

请你帮我审查下面这段代码。我会给你一段 Python 代码，你需要从以下几个方面进行审查：

1. 代码的正确性：检查代码是否能正常运行，有没有语法错误或逻辑错误
2. 代码的安全性：检查有没有安全漏洞，比如 SQL 注入、XSS 等
3. 代码的性能：检查有没有明显的性能问题，比如不必要的循环、低效的算法等
4. 代码的可读性：检查代码是否易于理解，变量命名是否清晰，注释是否充分
5. 代码的规范性：检查是否符合 PEP8 规范，命名规范是否一致

请对每个方面都给出详细的分析，如果发现问题，请指出具体的行号和问题描述。
最后请给出一个总体评价，从 1-10 分打分，并说明理由。

以下是代码：
def calculate_sum(numbers):
    result = 0
    for i in range(len(numbers)):
        result = result + numbers[i]
    return result

请仔细审查。

优化后（精简版本）：

审查这段 Python 代码：检查正确性、安全性、性能、可读性、规范性。指出具体问题，1-10分总体评价。

代码：
def calculate_sum(numbers):
    result = 0
    for i in range(len(numbers)):
        result = result + numbers[i]
    return result

对比结果：

版本	字符数	Token 数	节省比例
优化前	482	142	-
优化后	147	52	63%

优化技巧总结：

• 删掉废话：AI 能理解简洁指令，不需要"请你"、"请仔细"这种客套话
• 合并重复要求：原来说了 5 个方面，其实"审查"两个字就能概括
• 去掉示例格式：如果 AI 输出格式要求不严格，就别写太详细
• 直接切入主题："审查代码"比"帮我审查代码，从以下几个方面"简洁得多
• 用缩写和代号：比如"1-10分"比"从一到十分打分"更省

另一个实战案例：结构化输出的优化

假设你要让 AI 返回 JSON 格式的数据：

优化前：

请帮我生成一个用户信息，数据包括用户名、邮箱、年龄、手机号，格式是 JSON。请确保邮箱格式正确，年龄是数字，手机号是 11 位数字。如果有任何字段不符合要求，请告诉我。

优化后：

生成用户 JSON：{"name":"","email":"","age":0,"phone":""}。邮箱需符合格式，年龄为数字，phone 为 11 位。

Token 从 68 降到 31，节省 54%，效果几乎一样。

九、关键配置：上下文窗口与 Token 限制

除了单次调用的 Token 消耗，还有一个重要概念：上下文窗口（Context Window）。

什么是上下文窗口？

上下文窗口是指 AI 一次能处理的 Token 总数上限。包括你输入的提示词 + AI 之前的所有回复 + 当前回复。

举例：GPT-4o 的上下文窗口是 128K Token，意思是单次对话中，历史上所有内容的总和不能超过 12.8 万个 Token。

为什么这个限制很重要？

因为 AI 不是无限记忆的。当你对话太长，超过上下文窗口后：

• 老的内容会被"挤掉"（丢弃最早的消息）
• 或者直接报错，不让你继续输入

不同模型的上下文窗口对比：

模型	上下文窗口	约等于多少文字
GPT-4o	128K	约 10 万汉字
GPT-3.5 Turbo	16K	约 1.2 万汉字
Claude 3.5 Sonnet	200K	约 15 万汉字
Claude 3 Opus	200K	约 15 万汉字
Kimi	128K	约 10 万汉字

超出限制怎么办？

场景：你有一篇 20 万字的文章要 AI 总结，但模型上下文窗口只有 12.8 万 Token。

解决方案：分块处理

def chunk_text(text, max_tokens=3000, overlap=100):
    """
    将长文本分块，每块不超过 max_tokens
    overlap 是块之间的重叠 Token 数，用于保持上下文连续性
    """
    encoding = tiktoken.get_encoding("cl100k_base")
    tokens = encoding.encode(text)
    
    chunks = []
    start = 0
    
    while start < len(tokens):
        end = start + max_tokens
        chunk_tokens = tokens[start:end]
        chunk_text = encoding.decode(chunk_tokens)
        chunks.append(chunk_text)
        
        # 移动窗口，加上重叠部分
        start = end - overlap
    
    return chunks

# 使用示例
long_text = """这里是一篇很长的文档内容...
（省略 20 万字）"""

chunks = chunk_text(long_text, max_tokens=3000, overlap=200)
print(f"文档被分成 {len(chunks)} 个块")

# 逐块处理
for i, chunk in enumerate(chunks):
    print(f"\n处理第 {i+1} 块（{len(encoding.encode(chunk))} Token）...")
    # 这里调用 AI API 处理每一块

实战技巧：

• 处理长文档时，每块的 Token 数建议留 20% 余量（比如限制 3000，实际用 2400）
• 用重叠（overlap）保证块之间的内容不会割裂
• 可以在每块开头加一句"前文摘要"，让 AI 知道上下文

十、常见问题与排错

这一节列出几个实际使用中容易踩的坑。

问题一：tiktoken 计算结果和 API 返回的不一样

• 原因：API 计费时会把消息格式（role、content 等字段）也算进去，不只是文本内容本身
• 解决方法：如果要精确匹配 API 计费，用 len(response.usage) 获取 API 返回的真实 Token 数，而不是自己计算
• 代码示例：

import openai

response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "你的问题"}]
)

# 从 API 响应中获取准确 Token 数
print(f"输入 Token: {response.usage.prompt_tokens}")
print(f"输出 Token: {response.usage.completion_tokens}")
print(f"总 Token: {response.usage.total_tokens}")

问题二：Claude 的 Token 计算和 GPT 不一样

• 原因：Claude 使用不同的分词器（tiktoken 不支持 Claude 的编码）
• 解决方法：用 Anthropic 官方工具或估算值（Claude 的编码大约是每字符 3-4 个 Token，比 GPT 的 BPE 更紧凑）
• 估算公式：Claude Token 数 ≈ 字符数 × 0.75（中文）或 字符数 / 4（英文）

问题三：提示词太长被截断

• 报错信息：This model's maximum context window is 128000 tokens
• 原因：提示词 + 历史对话 + 期望输出超过了模型的上下文限制
• 解决方法：
  1. 缩短提示词（用本文第八节的优化技巧）
  2. 清理对话历史，删掉不重要的消息
  3. 如果是单次调用就超限，用分块处理（见第九节）

问题四：API 返回 400 Bad Request 或 413 错误

• 原因：请求体超过了模型允许的最大 Token 数
• 解决方法：检查提示词长度，确保总 Token 数 < 上下文窗口限制 × 0.9（留 10% 给输出）
• 调试代码：

def check_limit(prompt, model_max_tokens, output_estimate=500):
    """检查是否会超出限制"""
    prompt_tokens = count_tokens(prompt)
    total_needed = prompt_tokens + output_estimate
    
    if total_needed > model_max_tokens * 0.9:
        print(f"警告：需要 {total_needed} Token，可能超出限制")
        print(f"建议：减少约 {total_needed - int(model_max_tokens * 0.9)} Token")
    else:
        print(f"安全：使用 {total_needed} Token，剩余 {int(model_max_tokens * 0.9 - total_needed)} Token")

问题五：输出被意外截断

• 原因：输出太长，触发了模型的输出限制（不是上下文限制）
• 解决方法：在提示词中明确要求"简洁"或分段输出，或者用 max_tokens 参数限制输出长度

十一、进阶方向

学完基础之后，你可以往这些方向继续探索：

方向一：构建 Token 优化的自动化管道

把 Token 计算集成到提示词开发流程中，每次修改提示词都自动检测 Token 消耗和成本。比如写一个脚本，当 Token 数超过阈值时自动报警。

方向二：学习不同模型的分词原理

如果你对技术细节感兴趣，可以研究 BPE、WordPiece、SentencePiece 等分词算法的原理。理解底层原理能帮你更精准地优化提示词。

方向三：探索长上下文优化的最新技术

RAG（检索增强生成）、MapReduce 模式、反思模式等，都是处理长文档的高级技巧。这些方法能让你用更低的成本处理超长文本。

方向四：成本监控与预算管理

在生产环境中，建议搭建 Token 消耗的监控看板。记录每次 API 调用的成本，设置预算告警，避免月底账单爆炸。

---

Token 看起来是个小概念，但它是 AI 使用的底层逻辑。搞懂它，你用 AI 的效率能提升一大截，成本能降不少。希望这篇教程对你有帮助。

如果有什么没讲清楚的地方，或者你在实际操作中遇到了其他问题，欢迎在评论区聊聊。