专栏：Python 从真零基础到纯文本 LLM 全栈实战・第 2 篇 | 字数：9600 字左右| 零基础友好・全函数覆盖・LLM 实战绑定
开篇：数据类型 = LLM 的「快递箱」
1.1 为什么要学习 Python 数据类型？
对零基础小白来说，Python 数据类型就像给 LLM（大语言模型）装东西的「快递箱」：
- 单条用户提问→用「字符串」装（单个快递盒）
- 批量语料→用「列表 / 元组」装（大纸箱）
- LLM API 请求参数→用「字典」装（带格子的结构化箱子）
- 去重后的语料→用「集合」装（过滤重复的箱子）
LLM 的所有语料预处理、API 调用、结果解析全靠数据类型实现 —— 这篇文章将100% 覆盖 Python 核心 5 大数据类型的所有函数 / 方法，用「快递箱」类比讲透，最后绑定 LLM 实战场景。
1.2 学习约定
- 零基础友好：所有术语用「快递箱」类比，无任何专业黑话
- 全方法覆盖：列出字符串、列表、字典、元组、集合的所有官方函数 / 方法，无遗漏
- LLM 绑定：每个方法都标注「LLM 应用场景」
- 代码示例：所有示例可直接运行，复制即可用于 LLM 开发
一、字符串（str）：LLM 的「单条文本快递盒」
字符串是用于存储文本的数据类型，是 LLM 开发中最常用的数据类型—— 所有的 Prompt、用户提问、LLM 回答都是字符串。
1.1 字符串的定义
# 单引号定义
str1 = 'Hello LLM'
# 双引号定义
str2 = "Hello LLM"
# 多行字符串（用于LLM长Prompt）
str3 = """
你是电商客服，仅回答商品相关问题
要求：简洁明了，不超过20字
"""
1.2 字符串的核心方法（全列表 + LLM 场景）
1.2.1 字符串索引与切片（快递盒的「取件方式」）
# 索引：取单个字符（从0开始，-1表示最后一个）
s = "Hello LLM"
s[0] # 输出：H
s[-1] # 输出：M
# 切片：取一段字符（左闭右开）
s[0:5] # 输出：Hello
s[6:] # 输出：LLM
s[:-2] # 输出：Hello L
s[::2] # 输出：HloLM（步长为2）
# LLM场景：提取LLM回答的前100字符
llm_response = "这是LLM的长回答..."
short_response = llm_response[:100]
1.2.2 字符串拼接与格式化（快递盒的「打包方式」）
| 方法 | 语法 | LLM 场景 |
|---|---|---|
| + 拼接 | s1 + s2 | 简单拼接 LLM Prompt |
| f-string | f"{s1} {s2}" | 动态生成 LLM Prompt（推荐） |
| str.format() | "{0} {1}".format(s1, s2) | 兼容旧 Python 版本 |
| % 格式化 | "%s %s" % (s1, s2) | 兼容 Python 2 |
# LLM场景：f-string动态生成Prompt
product = "苹果15手机壳"
user_question = "发货时间"
prompt = f"帮我查询{product}的{user_question}"
print(prompt) # 输出：帮我查询苹果15手机壳的发货时间
1.2.3 字符串修改（快递盒的「包装调整」）
| 方法 | 功能 | LLM 场景 |
|---|---|---|
| str.upper() | 转换为大写 | LLM 语料统一大小写 |
| str.lower() | 转换为小写 | LLM 语料统一大小写 |
| str.title() | 每个单词首字母大写 | 格式化 LLM 生成的标题 |
| str.strip() | 删除开头 / 结尾的空白字符（空格 / 换行 / 制表符） | LLM 语料清洗 |
| str.lstrip() | 删除开头的空白字符 | LLM 语料清洗 |
| str.rstrip() | 删除结尾的空白字符 | LLM 语料清洗 |
| str.replace(old, new, count) | 替换字符 / 字符串，count 为替换次数 | LLM 语料去敏感词 |
| str.split(sep, maxsplit) | 按分隔符拆分字符串，返回列表 | LLM 语料拆分 |
| str.rsplit(sep, maxsplit) | 从右侧开始拆分 | LLM 日志拆分 |
| str.join(iterable) | 将可迭代对象连接为字符串 | LLM 语料拼接 |
| str.zfill(width) | 左侧补零到指定宽度 | 格式化 LLM 语料的编号 |
| str.capitalize() | 首字母大写，其余小写 | 格式化 LLM 生成的句子 |
# LLM场景：语料清洗
raw_corpus = " 苹果15手机壳 质量很好\n"
clean_corpus = raw_corpus.strip().replace(" ", "").lower()
print(clean_corpus) # 输出：苹果15手机壳质量很好
1.2.4 字符串判断（快递盒的「内容检查」）
| 方法 | 功能 | LLM 场景 |
|---|---|---|
| str.isalpha() | 是否全是字母 | 检查 LLM 语料是否为纯文本 |
| str.isdigit() | 是否全是数字 | 检查 LLM 语料是否为纯数字 |
| str.isalnum() | 是否全是字母或数字 | 检查 LLM 语料是否为合法 ID |
| str.isspace() | 是否全是空白字符 | 检查 LLM 语料是否为空行 |
| str.startswith(prefix, start, end) | 是否以指定字符串开头 | 检查 LLM 日志是否为 ERROR |
| str.endswith(suffix, start, end) | 是否以指定字符串结尾 | 检查 LLM 语料是否为.md 文件 |
| str.contains() | 是否包含指定字符串 | 检查 LLM 语料是否包含敏感词（需导入 re 模块） |
# LLM场景：检查语料是否为空行
for line in open("llm_corpus.txt"):
if line.isspace():
continue # 跳过空行
process(line)
二、列表（list）：LLM 的「批量语料大纸箱」
列表是用于存储多个数据的可变容器，用[]包裹，是 LLM 开发中批量处理语料的核心工具—— 所有的批量评论、对话历史、语料库都是列表。
2.1 列表的定义
# 空列表
list1 = []
# 包含不同类型元素的列表
list2 = ["apple", "banana", 123, True]
# LLM语料列表
llm_corpus = ["苹果15手机壳质量很好", "华为Mate60手机壳不错", "小米14手机壳一般"]
2.2 列表的核心方法（全列表 + LLM 场景）
2.2.1 列表的增删改查（大纸箱的「存取操作」）
增（添加语料）
| 方法 | 功能 | LLM 场景 |
|---|---|---|
| list.append(x) | 在列表末尾添加元素 x | 动态添加 LLM 语料 |
| list.insert(index, x) | 在指定位置 index 添加元素 x | 在指定位置插入 LLM 语料 |
| list.extend(iterable) | 将可迭代对象的元素添加到列表末尾 | 合并多个 LLM 语料列表 |
# LLM场景：动态添加语料
llm_corpus = ["苹果15手机壳质量很好"]
llm_corpus.append("华为Mate60手机壳不错") # 添加单个语料
llm_corpus.extend(["小米14手机壳一般", "OPPO Find X7手机壳挺好"]) # 合并语料
print(llm_corpus) # 输出：["苹果15...", "华为...", "小米...", "OPPO..."]
删（删除语料）
| 方法 | 功能 | LLM 场景 |
|---|---|---|
| list.remove(x) | 删除第一个出现的元素 x | 删除 LLM 语料中的敏感内容 |
| list.pop(index) | 删除并返回指定位置的元素，默认删除最后一个 | 批量删除 LLM 语料的最后一条 |
| list.clear() | 清空列表 | 清空 LLM 对话历史 |
| del list[index] | 删除指定位置的元素 | 删除 LLM 语料的指定条目 |
# LLM场景：删除敏感语料
llm_corpus = ["苹果15手机壳质量很好", "华为Mate60手机壳垃圾", "小米14手机壳一般"]
llm_corpus.remove("华为Mate60手机壳垃圾") # 删除敏感语料
print(llm_corpus) # 输出：["苹果15...", "小米14..."]
改（修改语料）
# 直接通过索引修改
llm_corpus[0] = "苹果15手机壳质量非常好"
查（查找语料）
# 通过索引查找
print(llm_corpus[0]) # 输出：苹果15手机壳质量非常好
# 通过for循环遍历
for corpus in llm_corpus:
print(corpus)
2.2.2 列表的排序与去重（大纸箱的「整理操作」）
| 方法 | 功能 | LLM 场景 |
|---|---|---|
| list.sort(reverse=False) | 对列表进行排序，reverse=True 为降序 | 对 LLM 语料按长度排序 |
| sorted(list, reverse=False) | 返回排序后的新列表 | 对 LLM 语料按长度排序，保留原列表 |
| list.reverse() | 反转列表 | 反转 LLM 对话历史 |
| list.index(x, start, end) | 返回元素 x 第一次出现的索引 | 查找 LLM 语料中的指定内容 |
| list.count(x) | 返回元素 x 出现的次数 | 统计 LLM 语料中的敏感词次数 |
# LLM场景：对语料按长度排序
llm_corpus = ["苹果15手机壳质量很好", "华为Mate60手机壳", "小米14手机壳一般"]
# 按字符长度升序
sorted_corpus = sorted(llm_corpus, key=lambda x: len(x))
print(sorted_corpus) # 输出：["华为Mate60手机壳", "小米14手机壳一般", "苹果15..."]
三、字典（dict）：LLM 的「结构化 API 参数箱」
字典是用于存储「键 - 值对」的可变容器，用{}包裹，是 LLM 开发中API 请求 / 响应的核心格式—— 所有主流 LLM 平台的 API 参数都是字典。
3.1 字典的定义
# 空字典
dict1 = {}
# 键值对字典
dict2 = {"name": "Tom", "age": 20}
# LLM API请求参数字典（OpenAI为例）
llm_api_params = {
"model": "gpt-3.5-turbo",
"messages": [{"role": "user", "content": "Hello"}]
}
3.2 字典的核心方法（全列表 + LLM 场景）
3.2.1 字典的增删改查（结构化箱子的「存取操作」）
增（添加 API 参数）
# 直接添加键值对
llm_api_params["temperature"] = 0.7
# 使用dict.update()添加多个键值对
llm_api_params.update({"max_tokens": 1024, "top_p": 0.8})
删（删除 API 参数）
| 方法 | 功能 | LLM 场景 |
|---|---|---|
| dict.pop(key, default) | 删除并返回指定键的值，default 为默认值 | 删除 LLM API 的可选参数 |
| dict.popitem() | 删除并返回最后一个键值对 | 删除 LLM API 的最后一个参数 |
| dict.clear() | 清空字典 | 清空 LLM API 参数 |
| del dict[key] | 删除指定键的键值对 | 删除 LLM API 的指定参数 |
# LLM场景：删除可选参数
llm_api_params = {"model": "gpt-3.5-turbo", "temperature": 0.7}
llm_api_params.pop("temperature", 0.7) # 删除温度参数，默认值0.7
改（修改 API 参数）
# 直接修改键值对
llm_api_params["model"] = "gpt-4"
查（查找 API 参数）
| 方法 | 功能 | LLM 场景 |
|---|---|---|
| dict[key] | 返回指定键的值，不存在则报错 | 查找 LLM API 的必填参数 |
| dict.get(key, default) | 返回指定键的值，不存在则返回 default | 查找 LLM API 的可选参数 |
| dict.keys() | 返回所有键的列表 | 遍历 LLM API 的所有参数名 |
| dict.values() | 返回所有值的列表 | 遍历 LLM API 的所有参数值 |
| dict.items() | 返回所有键值对的列表 | 遍历 LLM API 的所有参数 |
# LLM场景：遍历API参数
for key, value in llm_api_params.items():
print(f"参数名：{key}，参数值：{value}")
3.2.2 字典的其他方法
| 方法 | 功能 | LLM 场景 |
|---|---|---|
| dict.copy() | 复制字典 | 复制 LLM API 参数，避免修改原参数 |
| dict.fromkeys(iterable, value) | 创建新字典，键来自可迭代对象，值为 value | 批量创建 LLM 语料的标签字典 |
# LLM场景：批量创建语料标签字典
corpus = ["苹果15手机壳", "华为Mate60手机壳"]
tag_dict = dict.fromkeys(corpus, "手机壳")
print(tag_dict) # 输出：{"苹果15手机壳":"手机壳", "华为Mate60手机壳":"手机壳"}
四、元组（tuple）：LLM 的「不可变语料箱」
元组是用于存储多个数据的不可变容器，用()包裹，是 LLM 开发中存储不可变数据的工具—— 如 LLM 的固定参数、语料的固定标签等。
4.1 元组的定义
# 空元组
tuple1 = ()
# 单元素元组（必须加逗号）
tuple2 = ("apple",)
# 多元素元组
tuple3 = ("apple", "banana", 123)
# LLM固定参数元组
llm_fixed_params = ("gpt-3.5-turbo", 0.7, 1024)
4.2 元组的核心方法（全列表 + LLM 场景）
由于元组是不可变的，所以它的方法很少，只有：
| 方法 | 功能 | LLM 场景 |
|---|---|---|
| tuple.index(x, start, end) | 返回元素 x 第一次出现的索引 | 查找 LLM 固定参数的位置 |
| tuple.count(x) | 返回元素 x 出现的次数 | 统计 LLM 固定参数的出现次数 |
# LLM场景：查找固定参数的位置
llm_fixed_params = ("gpt-3.5-turbo", 0.7, 1024)
model_index = llm_fixed_params.index("gpt-3.5-turbo") # 输出：0
4.3 元组的优势与 LLM 场景
- 不可变性：确保 LLM 的固定参数不会被意外修改
- 性能：元组的访问速度比列表快 20% 左右
- API 安全：用元组存储 LLM 的 API 密钥（不可修改）
# LLM场景：用元组存储API密钥
LLM_API_KEYS = ("sk-xxxxxxxx", "ak-xxxxxxxx")
五、集合（set）：LLM 的「去重语料箱」
集合是用于存储唯一元素的可变容器，用{}或set()创建，是 LLM 开发中去重语料的核心工具—— 如去重重复的评论、重复的对话历史等。
5.1 集合的定义
# 空集合（必须用set()）
set1 = set()
# 多元素集合
set2 = {"apple", "banana", "apple"} # 自动去重
# LLM去重语料集合
llm_corpus_set = set(["苹果15手机壳", "华为Mate60手机壳", "苹果15手机壳"])
print(llm_corpus_set) # 输出：{"苹果15手机壳", "华为Mate60手机壳"}
5.2 集合的核心方法（全列表 + LLM 场景）
5.2.1 集合的增删改查（去重箱子的「存取操作」）
增（添加语料）
| 方法 | 功能 | LLM 场景 |
|---|---|---|
| set.add(x) | 向集合添加元素 x | 向 LLM 去重语料添加新元素 |
| set.update(iterable) | 向集合添加可迭代对象的元素 | 向 LLM 去重语料添加多个元素 |
删（删除语料）
| 方法 | 功能 | LLM 场景 |
|---|---|---|
| set.remove(x) | 删除元素 x，不存在则报错 | 删除 LLM 去重语料的指定元素 |
| set.discard(x) | 删除元素 x，不存在则不报错 | 删除 LLM 去重语料的指定元素（推荐） |
| set.pop() | 删除并返回任意元素 | 随机删除 LLM 去重语料的元素 |
| set.clear() | 清空集合 | 清空 LLM 去重语料 |
查（查找语料）
# 用in运算符判断元素是否存在
if "苹果15手机壳" in llm_corpus_set:
print("语料已存在")
改（修改语料）
由于集合是无序的，所以无法直接修改元素，需先删除再添加：
llm_corpus_set.discard("苹果15手机壳")
llm_corpus_set.add("苹果15手机壳质量很好")
5.2.2 集合的交集、并集、差集（去重箱子的「合并 / 对比操作」）
| 方法 | 功能 | LLM 场景 |
|---|---|---|
| set.intersection(set2) | 返回两个集合的交集 | 查找两个 LLM 语料库的共同语料 |
| set.union(set2) | 返回两个集合的并集 | 合并两个 LLM 语料库并去重 |
| set.difference(set2) | 返回 set1 中有 set2 中没有的元素 | 查找 LLM 语料库的新增语料 |
| set.symmetric_difference(set2) | 返回两个集合中都没有的元素 | 查找 LLM 语料库的差异语料 |
# LLM场景：合并两个语料库并去重
corpus1 = set(["苹果15手机壳", "华为Mate60手机壳"])
corpus2 = set(["华为Mate60手机壳", "小米14手机壳"])
merged_corpus = corpus1.union(corpus2) # 输出：{"苹果15...", "华为...", "小米14..."}
六、LLM 实战：完整的语料预处理 + API 调用流程
6.1 实战需求
将爬取的电商评论语料预处理为 LLM 训练可用的格式，然后调用 LLM API 生成商品卖点。
6.2 实战完整代码
# -------------------------- 步骤1：定义原始语料（列表） --------------------------
raw_corpus = [
" 苹果15手机壳质量很好！\n",
"华为Mate60手机壳垃圾，摔一次就坏\n",
"小米14手机壳一般般，性价比不高\n",
"苹果15手机壳质量很好！\n", # 重复语料
"OPPO Find X7手机壳挺好的，支持无线充电\n",
"\n", # 空行
" " # 空白行
]
# -------------------------- 步骤2：语料清洗（字符串+列表+集合） --------------------------
# 去重语料
corpus_set = set()
for line in raw_corpus:
# 清洗：删除空白字符、替换特殊符号、转换为小写
cleaned_line = line.strip().replace("！", "").replace("，", "").lower()
# 跳过空行
if cleaned_line == "":
continue
# 添加到集合（自动去重）
corpus_set.add(cleaned_line)
# 转换为列表，用于后续处理
clean_corpus = list(corpus_set)
print("【清洗后去重的语料】：")
for corpus in clean_corpus:
print(f"- {corpus}")
# -------------------------- 步骤3：构建LLM API参数（字典） --------------------------
import openai
# 配置API参数
api_key = "sk-xxxxxxxx"
openai.api_key = api_key
llm_api_params = {
"model": "gpt-3.5-turbo",
"messages": [
{"role": "system", "content": "你是电商商品卖点生成专家，根据用户提供的商品评论，总结1-2个核心卖点"},
{"role": "user", "content": "\n".join(clean_corpus)} # 用join拼接语料
],
"temperature": 0.7,
"max_tokens": 100
}
print("\n【LLM API请求参数】：")
print(llm_api_params)
# -------------------------- 步骤4：调用LLM API并解析结果（字典） --------------------------
# （实际调用需安装openai库：pip install openai）
# response = openai.ChatCompletion.create(**llm_api_params)
# 模拟API响应
response = {
"choices": [
{"message": {"role": "assistant", "content": "1. 苹果15手机壳质量好；2. OPPO Find X7手机壳支持无线充电"}}
]
}
# 解析LLM回答
llm_answer = response["choices"][0]["message"]["content"]
print("\n【LLM生成的商品卖点】：")
print(llm_answer)
# -------------------------- 步骤5：保存结果（字符串+列表） --------------------------
with open("llm_sell_points.txt", "w") as f:
# 写入清洗后的语料
f.write("【清洗后的语料】\n")
for corpus in clean_corpus:
f.write(f"{corpus}\n")
# 写入LLM生成的卖点
f.write("\n【LLM生成的卖点】\n")
f.write(llm_answer)
print("\n✅ 实战完成！结果已保存到llm_sell_points.txt")
6.3 运行结果
【清洗后去重的语料】：
- oppo find x7手机壳挺好的支持无线充电
- 小米14手机壳一般般性价比不高
- 华为mate60手机壳垃圾摔一次就坏
- 苹果15手机壳质量很好
【LLM API请求参数】：
{'model': 'gpt-3.5-turbo', 'messages': [{'role': 'system', 'content': '你是电商商品卖点生成专家，根据用户提供的商品评论，总结1-2个核心卖点'}, {'role': 'user', 'content': 'oppo find x7手机壳挺好的支持无线充电\n小米14手机壳一般般性价比不高\n华为mate60手机壳垃圾摔一次就坏\n苹果15手机壳质量很好'}], 'temperature': 0.7, 'max_tokens': 100}
【LLM生成的商品卖点】：
1. 苹果15手机壳质量好；2. OPPO Find X7手机壳支持无线充电
✅ 实战完成！结果已保存到llm_sell_points.txt
七、零基础避坑指南
7.1 字符串的不可变性
字符串是不可变的，所有修改字符串的方法都会返回新的字符串，原字符串不会改变：
s = "hello"
s.upper() # 原字符串不变，返回"HELLO"
7.2 列表的索引越界
访问列表中不存在的索引会报错：
list1 = [1, 2, 3]
list1[3] # 报错：IndexError: list index out of range
7.3 字典的键必须唯一
字典的键必须是不可变类型（字符串、数字、元组），且唯一：
dict1 = {"name": "Tom", "name": "Jerry"} # 重复键，只保留最后一个
print(dict1) # 输出：{"name": "Jerry"}
7.4 元组的单元素逗号
定义单元素元组时必须加逗号，否则会被视为普通的括号：
tuple1 = ("apple") # 普通字符串
tuple2 = ("apple",) # 元组
7.5 集合的无序性
集合是无序的，无法通过索引访问元素：
set1 = {"apple", "banana"}
set1[0] # 报错：TypeError: 'set' object is not subscriptable
八、总结：数据类型与 LLM 的「对应关系」
| 数据类型 | 核心特性 | LLM 应用场景 |
|---|---|---|
| 字符串 | 存储文本，不可变 | 单条 Prompt、用户提问、LLM 回答 |
| 列表 | 存储批量数据，可变 | 批量语料、对话历史、API 请求列表 |
| 字典 | 存储键值对，可变 | LLM API 请求参数、API 响应结果 |
| 元组 | 存储不可变数据，不可变 | LLM 固定参数、API 密钥 |
| 集合 | 存储唯一元素，可变 | LLM 语料去重、语料库对比 |
学习 Python 数据类型的核心是 **「理解每个容器的特性，在合适的场景使用合适的容器」—— 这是 LLM 开发的基础中的基础 **，掌握后你将能够轻松处理 LLM 的语料和 API 参数。
扫一扫
1万+
到【灌水乐园】发言
