【AI大模型应用开发工程师特训笔记】第04讲（第6章）：复合数据类型

目录

[6.1 列表（list）：有序、可变的序列](#6.1 列表（list）：有序、可变的序列)

[6.1.1 理论讲解](#6.1.1 理论讲解)

[6.1.2 案例展示](#6.1.2 案例展示)

[6.2 元组（tuple）：有序、不可变的序列](#6.2 元组（tuple）：有序、不可变的序列)

[6.2.1 理论讲解](#6.2.1 理论讲解)

[6.2.2 案例展示](#6.2.2 案例展示)

[6.3 字典（dict）：键值对，像"电话本"](#6.3 字典（dict）：键值对，像“电话本”)

[6.3.1 理论讲解](#6.3.1 理论讲解)

[6.3.2 案例展示](#6.3.2 案例展示)

[6.4 集合（set）：无序、不重复的元素集](#6.4 集合（set）：无序、不重复的元素集)

[6.4.1 理论讲解](#6.4.1 理论讲解)

[6.4.2 案例展示](#6.4.2 案例展示)

[6.5 映射（Mapping）与字典的深入理解](#6.5 映射（Mapping）与字典的深入理解)

[6.6 结构体（Struct）与命名元组](#6.6 结构体（Struct）与命名元组)

[6.6.1 理论讲解](#6.6.1 理论讲解)

[6.6.2 案例展示](#6.6.2 案例展示)

[6.7 复合数据结构的嵌套与实战](#6.7 复合数据结构的嵌套与实战)

[6.7.1 理论讲解](#6.7.1 理论讲解)

[6.7.2 案例展示（沿用原文档示例）](#6.7.2 案例展示（沿用原文档示例）)

[6.8 综合实战：增强版 AI 对话系统](#6.8 综合实战：增强版 AI 对话系统)

[6.9 常用操作总结表](#6.9 常用操作总结表)

---

前面我们学习了数字、字符串等基础数据类型，它们就像一个个小盒子，每个盒子只能放一样东西。但在 AI 开发中，你经常需要处理成组的数据：比如一个模型支持的所有参数配置、多轮对话的历史消息、一批待处理的提示词、一个请求的响应头信息......

复合 数据类型 就是用来存放多个数据的容器。本章将学习 Python 最常用的四种容器：列表（list） 、元组 （ tuple ） 、字典（dict） 和 集合（set） ，所有示例都紧扣大模型应用场景。最后还会补充 命名元组 和 数据类 等更高级的结构。

6.1 列表（list）：有序、可变的序列

6.1.1 理论讲解

定义 ：列表是一个有序 的容器，你可以往里面放任意类型 的元素（整数、字符串、布尔值，甚至其他列表），并且可以随时增删改 其中的元素。列表用方括号 [] 表示，元素之间用逗号分隔。

特性：

• 有序 ：每个元素都有一个确定的位置（索引），从 0 开始计数。

• 可变：可以添加、删除、修改元素。

• 可重复：允许存在多个相同的值。

类比 ：列表就像一条待办事项清单，你可以在上面按顺序写下任务，随时增加新任务、划掉已完成的任务，或者修改某个任务的内容。

常见操作：

• 创建：[] 或 list()

• 访问：通过索引 lst[0]，支持负索引（-1 表示最后一个）

• 切片：lst[开始:结束:步长]，返回子列表（结束位置不包含）

• 修改：直接赋值 lst[0] = 新值

• 添加：append() 在末尾加一个；insert() 在指定位置插入；extend() 合并另一个列表

• 删除：remove(值) 删除第一个匹配项；pop(索引) 删除并返回该元素；clear() 清空

• 遍历：for 元素 in 列表: 或 for 索引, 元素 in enumerate(列表):

• 列表推导式： [表达式 for 变量 in 可迭代对象 if 条件] 一行代码生成新列表

6.1.2 案例展示

# 1. 创建列表
models = ["gpt-4", "gpt-3.5-turbo", "claude-3", "llama-2"]
temperatures = [0.2, 0.7, 1.2, 1.8]
mixed = ["text", 42, True]          # 混合类型（不推荐）
empty_list = []

# 2. 访问元素（索引与切片）
print(models[0])        # 输出 "gpt-4"
print(models[2])        # 输出 "claude-3"
print(models[-1])       # 输出 "llama-2"（倒数第一个）
print(models[1:3])      # 输出 ['gpt-3.5-turbo', 'claude-3']（结束索引3不包含）
print(models[::2])      # 步长为2：['gpt-4', 'claude-3']

# 3. 修改列表（增、删、改）
models[0] = "gpt-4-turbo"            # 修改
models.append("gemini-pro")          # 末尾追加
models.insert(1, "claude-2")         # 在索引1处插入
models.remove("llama-2")             # 删除值为 "llama-2" 的第一个元素
deleted = models.pop(2)              # 删除索引2的元素并返回
print(f"删除了 {deleted}")
models.clear()                       # 清空列表

# 4. 遍历列表
prompts = ["解释Transformer", "写一首诗", "总结这篇文章"]
for p in prompts:
    print(f"正在处理: {p}")

# 需要索引时使用 enumerate()
for idx, model in enumerate(models):
    print(f"第{idx+1}个模型: {model}")

# 5. 列表推导式
# 传统方式
temps = []
for i in range(5):
    temps.append(0.1 * i)            # [0.0, 0.1, 0.2, 0.3, 0.4]
# 列表推导式
temps = [0.1 * i for i in range(5)]
temps_high = [t for t in temps if t > 0.2]   # 条件筛选
print(temps_high)                    # [0.3, 0.4]

运行上述代码，输出如下内容：

tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$ poetry run  python src/my_ai_service/loop.py 
gpt-4
claude-3
llama-2
['gpt-3.5-turbo', 'claude-3']
['gpt-4', 'claude-3']
删除了 gpt-3.5-turbo
正在处理: 解释Transformer
正在处理: 写一首诗
正在处理: 总结这篇文章
[0.30000000000000004, 0.4]

6.2 元组（tuple）：有序、不可变的序列

6.2.1 理论讲解

定义 ：元组与列表非常相似，但一旦创建就不能修改 （不可变）。元组用圆括号 () 表示，元素之间用逗号分隔。元组中可以存储不同类型的数据。

为什么需要 元组 ？

• 保护数据：当你不希望数据被意外修改时，使用元组（如 API 响应的固定字段）。

• 作为字典的键：列表是可变的，不能作为字典的键；元组不可变，可以作为键。

• 函数返回多个值：Python 函数可以返回多个值，实际上返回的是一个元组。

特性：

• 有序：索引从 0 开始。

• 不可变：不能添加、删除、修改元素。

• 可重复：允许重复值。

创建注意 ：单元素元组必须加逗号，例如 (5,)，否则 (5) 被解释为整数。

打包与解包：

• 打包： 将多个值赋给一个元组，例如 info = "gpt-4", 8192, 0.8。

• 解包： 将元组的元素分别赋给多个变量，例如 name, limit, temp = info。

6.2.2 案例展示

# 1. 创建元组
config = ("gpt-4", 4096, 0.7)        # 模型配置（模型名，最大token，温度）
print(config[0])                     # 'gpt-4'
print(config[1])                     # 4096

# 尝试修改会报错
# config[0] = "claude"               # TypeError

# 2. 单元素元组的陷阱
t1 = (5)                             # 这是整数 5
t2 = (5,)                            # 这才是包含一个元素的元组
print(type(t1), type(t2))            # <class 'int'> <class 'tuple'>

# 3. 打包与解包
model_info = "gpt-4", 8192, 0.8      # 打包成元组
name, context_len, temp = model_info # 解包
print(f"模型: {name}, 上下文: {context_len}, 温度: {temp}")

# 4. AI场景：存储固定的模型参数组合（不可变，防止意外覆盖）
GPT4_CONFIG = ("gpt-4-turbo", 128000, 0.8)
CLAUDE3_CONFIG = ("claude-3-opus", 200000, 0.7)

configs = [GPT4_CONFIG, CLAUDE3_CONFIG]
for name, limit, temp in configs:
    print(f"{name}: max_tokens={limit}, temperature={temp}")

运行上述代码，输出如下内容：

tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$ poetry run  python src/my_ai_service/loop.py 
gpt-4
4096
<class 'int'> <class 'tuple'>
模型: gpt-4, 上下文: 8192, 温度: 0.8
gpt-4-turbo: max_tokens=128000, temperature=0.8
claude-3-opus: max_tokens=200000, temperature=0.7
tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$

6.3 字典（dict）：键值对，像"电话本"

6.3.1 理论讲解

定义 ：字典是一种通过键（key） 来查找值（value） 的数据结构。每个键值对用冒号 : 分隔，整体用花括号 {} 包裹。键必须是不可变类型（如字符串、数字、元组），值可以是任意类型。

类比：字典就像电话本------通过姓名（键）快速找到电话号码（值）。也像现实中的字典------通过单词（键）找到释义（值）。

特性：

• 无序 ：在 Python 3.7+ 中，字典保持插入顺序，但逻辑上仍是通过键访问，不依赖位置。

• 可变：可以添加、删除、修改键值对。

• 键唯一：同一个键只能出现一次，后面的会覆盖前面的。

常用操作：

• 创建：{} 或 dict()

• 访问：dict[key]（键不存在会报错）；dict.get(key, 默认值)（安全，不存在返回默认值）

• 修改/添加：dict[key] = 新值

• 删除：del dict[key]；pop(key) 删除并返回值

• 检查键是否存在：if key in dict:

• 遍历：.keys() 遍历键；.values() 遍历值；.items() 遍历键值对

• 字典推导式：{键表达式: 值表达式 for 变量 in 可迭代对象}

6.3.2 案例展示

# 1. 创建字典
model_config = {
    "model": "gpt-4",
    "temperature": 0.7,
    "max_tokens": 2048,
    "top_p": 0.9,
    "stream": False
}

empty_dict = {}

# 2. 访问与修改
print(model_config["model"])           # 'gpt-4'
print(model_config.get("top_p"))       # 0.9（安全访问）
model_config["temperature"] = 0.85     # 修改
model_config["frequency_penalty"] = 0.5  # 添加新键值对
del model_config["stream"]             # 删除键值对

# 检查键是否存在
if "max_tokens" in model_config:
    print("max_tokens 存在")

# 3. 遍历字典
for key in model_config:
    print(f"{key}: {model_config[key]}")

# 推荐方式：遍历键值对
for key, value in model_config.items():
    print(f"{key} = {value}")

# 4. AI场景示例
# 场景1：构建API请求体
request_body = {
    "model": "gpt-3.5-turbo",
    "messages": [
        {"role": "system", "content": "你是一个助手"},
        {"role": "user", "content": "你好"}
    ],
    "temperature": 0.7,
    "max_tokens": 1500
}

# 场景2：存储多轮对话历史（列表嵌套字典）
conversation = [
    {"role": "user", "content": "什么是注意力机制？"},
    {"role": "assistant", "content": "注意力机制是Transformer的核心..."},
    {"role": "user", "content": "它有什么作用？"}
]
# 添加新消息
conversation.append({"role": "assistant", "content": "它能捕捉序列中的长距离依赖关系。"})
# 打印最后一条消息的内容
print(conversation[-1]["content"])

# 场景3：模型元信息字典（嵌套）
model_meta = {
    "gpt-4": {"context_length": 8192, "training_cutoff": "2023-09"},
    "claude-3": {"context_length": 200000, "training_cutoff": "2024-02"}
}
print(model_meta["gpt-4"]["context_length"])   # 8192

# 5. 字典推导式
models = ["gpt-4", "claude-3", "llama-2"]
default_temps = {model: 0.7 for model in models}
print(default_temps)   # {'gpt-4': 0.7, 'claude-3': 0.7, 'llama-2': 0.7}

运行上述代码，输出如下内容：

tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$ poetry run  python src/my_ai_service/loop.py 
gpt-4
0.9
max_tokens 存在
model: gpt-4
temperature: 0.85
max_tokens: 2048
top_p: 0.9
frequency_penalty: 0.5
model = gpt-4
temperature = 0.85
max_tokens = 2048
top_p = 0.9
frequency_penalty = 0.5
它能捕捉序列中的长距离依赖关系。
8192
{'gpt-4': 0.7, 'claude-3': 0.7, 'llama-2': 0.7}
tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$ 

6.4 集合（set）：无序、不重复的元素集

6.4.1 理论讲解

定义 ：集合用于存储唯一 且无序 的元素。它很像数学上的集合，支持交集、并集、差集等运算。集合用花括号 {} 表示，但空集合必须用 set() ，因为 {} 是空字典。

特性：

• 无序：元素没有顺序，不能通过索引访问。

• 元素唯一：自动去重。

• 可变：可以添加、删除元素（但元素本身必须是不可变类型，如数字、字符串、元组）。

常用操作：

• 创建：{元素1, 元素2} 或 set(可迭代对象)

• 添加：add(元素) 添加一个；update([元素1, 元素2]) 添加多个

• 删除：remove(元素)（不存在会报错）；discard(元素)（不存在不报错）；pop() 随机删除并返回

• 集合运算：

  • 交集：set1 & set2 或 set1.intersection(set2)

  • 并集：set1 | set2 或 set1.union(set2)

  • 差集：set1 - set2 或 set1.difference(set2)

  • 对称差集：set1 ^ set2 或 set1.symmetric_difference(set2)

• 成员测试：if 元素 in 集合:（比列表快得多）

6.4.2 案例展示

# 1. 创建集合
allowed_models = {"gpt-4", "gpt-3.5", "claude-3", "gpt-4"}  # 重复的 gpt-4 只保留一个
print(allowed_models)   # {'gpt-3.5', 'claude-3', 'gpt-4'}

# 从列表转换去重
model_list = ["gpt-4", "gpt-4", "claude-3"]
unique_models = set(model_list)
print(unique_models)    # {'claude-3', 'gpt-4'}

empty_set = set()        # 空集合，注意不是 {}

# 2. 添加和删除
models = {"gpt-4", "claude-3"}
models.add("llama-2")                # 添加一个
models.update(["gemini", "mistral"]) # 添加多个
models.remove("claude-3")            # 删除，不存在会报错
models.discard("xxx")                # 删除，不存在也不报错

# 3. 集合运算
available = {"gpt-4", "gpt-3.5", "claude-3", "llama-2"}
user_has = {"gpt-3.5", "claude-3"}

# 交集：用户已有的可用模型
can_use = available.intersection(user_has)   # 或 available & user_has
print(can_use)   # {'claude-3', 'gpt-3.5'}

# 并集：所有出现的模型
all_models = available.union(user_has)       # 或 available | user_has
print(all_models)

# 差集：可用但用户没有的
missing = available - user_has
print(missing)   # {'gpt-4', 'llama-2'}

# 4. AI场景示例
# 场景1：用户输入的模型名称去重
selected_models = ["gpt-4", "claude-3", "gpt-4", "llama-2"]
unique_selected = set(selected_models)
print(f"用户选择了 {len(unique_selected)} 个不同的模型")

# 场景2：检查用户请求的模型是否在支持列表中
supported = {"gpt-4", "gpt-3.5", "claude-3", "gemini-pro"}
user_model = "llama-2"
if user_model in supported:
    print("模型可用")
else:
    print(f"模型 {user_model} 不在支持列表中")

# 场景3：敏感词过滤（集合成员测试极快）
sensitive_words = {"暴力", "色情", "恐怖主义"}
user_input = "这个电影有点暴力"
words = set(user_input.split())       # 简单分词
if words & sensitive_words:           # 交集非空
    print("包含敏感词")
else:
    print("安全")

# 场景4：收集所有出现的错误码
error_codes = set()
import random
for _ in range(10):
    code = random.choice([200, 429, 500, 200])
    if code != 200:
        error_codes.add(code)
print(f"本次运行出现的错误码: {error_codes}")

运行上述代码，输出如下内容：

tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$ poetry run  python src/my_ai_service/loop.py 
{'gpt-4', 'gpt-3.5', 'claude-3'}
{'gpt-4', 'claude-3'}
{'gpt-3.5', 'claude-3'}
{'llama-2', 'gpt-4', 'gpt-3.5', 'claude-3'}
{'llama-2', 'gpt-4'}
用户选择了 3 个不同的模型
模型 llama-2 不在支持列表中
安全
本次运行出现的错误码: {500, 429}
tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$ 

6.5 映射（Mapping）与字典的深入理解

理论讲解 ：在计算机科学中，映射（Mapping） 是一种将键（key）关联到值（value）的数据结构。Python 中的字典就是最典型的映射类型 。你可以把映射想象成一个函数：输入键，输出值。

其他映射类型：

• collections.defaultdict：当键不存在时，自动返回一个默认值（如空列表、0 等），避免 KeyError。

• collections.OrderedDict：在 Python 3.7 之前用于保持插入顺序，现在普通字典也已有序，但仍有兼容用途。

• collections.Counter：专门用于计数的映射，键是元素，值是出现次数。

案例展示：

from collections import defaultdict, Counter

# 1. defaultdict：自动初始化不存在的键
# 传统做法：需要判断键是否存在
word_count = {}
words = ["apple", "banana", "apple"]
for w in words:
    if w not in word_count:
        word_count[w] = 0
    word_count[w] += 1

# 使用 defaultdict
word_count = defaultdict(int)   # 默认值为0
for w in words:
    word_count[w] += 1
print(word_count)   # defaultdict(<class 'int'>, {'apple': 2, 'banana': 1})

# 2. Counter：快速计数
cnt = Counter(words)
print(cnt)          # Counter({'apple': 2, 'banana': 1})
print(cnt.most_common(1))  # [('apple', 2)]

运行上述代码，输出如下内容：

tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$ poetry run  python src/my_ai_service/loop.py 
defaultdict(<class 'int'>, {'apple': 2, 'banana': 1})
Counter({'apple': 2, 'banana': 1})
[('apple', 2)]
tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$

6.6 结构体（Struct）与命名元组

6.6.1 理论讲解

什么是结构体？ 在一些编程语言（如 C、Go）中，结构体（struct）允许你将多个不同类型的数据组合成一个新的复合类型，每个字段有名字。Python 没有内置的结构体，但可以通过以下方式实现类似功能：

（1）命名 元组 （namedtuple） ：来自 collections 模块，是元组的子类，允许通过字段名访问元素，同时保持不可变性。

（2）数据类（dataclass） ：Python 3.7+ 引入，使用 @dataclass 装饰器，可以创建可变的、带类型注解的类，自动生成 __init__、__repr__ 等方法。

（3）普通类 ：手动定义 __init__，但代码较冗长。

为什么需要它们？ 当你要表示一个具有多个属性的对象（如模型配置、API 响应）时，使用字典虽然灵活，但字段名是字符串，容易拼写错误且 IDE 不能自动补全。命名元组和数据类提供了更清晰的接口 和更好的代码提示。

6.6.2 案例展示

from collections import namedtuple
from dataclasses import dataclass

# 1. 命名元组（不可变）
ModelConfig = namedtuple('ModelConfig', ['name', 'max_tokens', 'temperature'])
gpt4 = ModelConfig(name="gpt-4", max_tokens=8192, temperature=0.7)
print(gpt4.name)          # 通过字段名访问，而不是索引
print(gpt4.max_tokens)

# 不可变：尝试修改会报错
# gpt4.name = "claude"    # AttributeError

# 2. 数据类（可变，更灵活）
@dataclass
class ModelConfigDC:
    name: str
    max_tokens: int
    temperature: float = 0.7   # 可以有默认值

claude = ModelConfigDC(name="claude-3", max_tokens=200000)
print(claude)
claude.temperature = 0.9       # 可以修改
print(claude.temperature)

# 3. AI场景：使用数据类表示对话消息
@dataclass
class Message:
    role: str
    content: str

conversation = [
    Message(role="system", content="You are a helpful assistant."),
    Message(role="user", content="What is Python?")
]
for msg in conversation:
    print(f"{msg.role}: {msg.content[:50]}")

运行上述代码，输出如下内容：

tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$ poetry run  python src/my_ai_service/loop.py 
gpt-4
8192
ModelConfigDC(name='claude-3', max_tokens=200000, temperature=0.7)
0.9
system: You are a helpful assistant.
user: What is Python?
tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$

6.7 复合数据结构的嵌套与实战

6.7.1 理论讲解

在实际开发中，很少只用单一类型的容器，而经常使用嵌套 ：列表里套字典，字典里套列表，甚至更多层。理解嵌套的关键是逐层分解：先确定最外层是什么类型，然后逐步深入内层。

常见嵌套模式：

• 对话历史：列表（外层）→ 字典（每轮消息）→ 字符串（role 和 content）

• 模型配置库：字典（外层，键是模型名）→ 字典（内层配置）→ 各种值

• 批处理 请求：列表 → 字典（每个请求）→ 字典（parameters）

6.7.2 案例展示（沿用原文档示例）

# 1. 对话历史（列表内嵌字典）
conversation_history = [
    {"role": "system", "content": "You are a helpful AI assistant."},
    {"role": "user", "content": "Explain Python lists."},
    {"role": "assistant", "content": "A list is an ordered collection..."}
]
conversation_history.append({"role": "user", "content": "What about dictionaries?"})

# 2. 模型配置库（字典内嵌字典）
models_config = {
    "gpt-4": {
        "max_tokens": 8192,
        "cost_per_1k": 0.03,
        "supports_functions": True
    },
    "gpt-3.5": {
        "max_tokens": 4096,
        "cost_per_1k": 0.002,
        "supports_functions": True
    },
    "claude-3": {
        "max_tokens": 200000,
        "cost_per_1k": 0.025,
        "supports_functions": False
    }
}
print(models_config["gpt-4"]["max_tokens"])   # 8192

for model, info in models_config.items():
    print(f"{model}: 最大token={info['max_tokens']}, 支持函数={info['supports_functions']}")

# 3. 批处理请求（列表内嵌字典，再内嵌字典）
batch_requests = [
    {
        "id": 1,
        "prompt": "Write a poem",
        "parameters": {"temperature": 0.8, "max_tokens": 200}
    },
    {
        "id": 2,
        "prompt": "Explain quantum computing",
        "parameters": {"temperature": 0.2, "max_tokens": 500}
    }
]
for req in batch_requests:
    print(f"处理请求 {req['id']}: {req['prompt'][:20]}... 温度={req['parameters']['temperature']}")

运行上述代码，输出如下内容：

tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$ poetry run  python src/my_ai_service/loop.py 
8192
gpt-4: 最大token=8192, 支持函数=True
gpt-3.5: 最大token=4096, 支持函数=True
claude-3: 最大token=200000, 支持函数=False
处理请求 1: Write a poem... 温度=0.8
处理请求 2: Explain quantum comp... 温度=0.2
tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$ 

6.8 综合实战：增强版 AI 对话系统

将列表、字典、元组、集合全部用上，构建一个简单的多模型对话调度器。

# 1. 模型库（字典，内嵌元组和字典）
MODELS = {
    "gpt-4": {
        "context_limit": 8192,
        "cost_per_1k": 0.03,
        "aliases": ("GPT-4", "GPT4")
    },
    "gpt-3.5": {
        "context_limit": 4096,
        "cost_per_1k": 0.002,
        "aliases": ("GPT-3.5", "ChatGPT")
    },
    "claude-3": {
        "context_limit": 200000,
        "cost_per_1k": 0.025,
        "aliases": ("Claude", "Claude3")
    }
}
# 2. 可用模型集合（用于快速检查）
AVAILABLE_MODELS = set(MODELS.keys())

# 3. 会话记录（列表，内嵌字典）
conversation = []

# 4. 用户选择模型
user_model = input("请输入模型名称（gpt-4 / gpt-3.5 / claude-3）:").lower()
if user_model not in AVAILABLE_MODELS:
    print(f"模型 {user_model} 不可用，将使用 gpt-3.5 作为默认")
    user_model = "gpt-3.5"

# 5. 获取模型配置（通过键访问字典）
config = MODELS[user_model]
limit = config["context_limit"]
cost = config["cost_per_1k"]
print(f"已选择 {user_model}，上下文长度 {limit}，每1k token 费用 ${cost}")

# 6. 模拟对话循环（输入 'exit' 退出）
total_cost = 0.0
while True:
    user_input = input("\n你：")
    if user_input.lower() == "exit":
        break

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

    # 模拟模型回复
    assistant_reply = f"模型 {user_model} 已收到：{user_input}"

    # 模拟 token 计数（假设每个字 1 token）
    input_tokens = len(user_input)
    output_tokens = len(assistant_reply)
    total_tokens = input_tokens + output_tokens
    step_cost = total_tokens / 1000 * cost
    total_cost += step_cost

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

    print(f"助手：{assistant_reply}")
    print(f"[本次消耗 token: {total_tokens}，费用：${step_cost:.4f}]")

# 7. 输出统计
print(f"\n会话结束。共 {len(conversation)} 条消息，总费用 ${total_cost:.4f}")

# 8. 展示最后 3 条消息（列表切片）
print("\n最后3条记录：")
for msg in conversation[-3:]:
    print(f"{msg['role']}: {msg['content'][:50]}...")

运行上述的代码，输出如下内容：

tianpeng@DESKTOP-4L1UF5S:~/my-ai-service$ poetry run  python src/my_ai_service/loop.py 
请输入模型名称（gpt-4 / gpt-3.5 / claude-3）:gpt-3.5
已选择 gpt-3.5，上下文长度 4096，每1k token 费用 $0.002

你：2
助手：模型 gpt-3.5 已收到：2
[本次消耗 token: 17，费用：$0.0000]

你：zhangs 
助手：模型 gpt-3.5 已收到：zhangs
[本次消耗 token: 27，费用：$0.0001]

你：15654
助手：模型 gpt-3.5 已收到：15654
[本次消耗 token: 25，费用：$0.0001]

你：

6.9 常用操作总结表

数据类型	是否有序	是否可变	是否允许重复	典型应用
列表 list	是	是	是	批处理提示词、对话消息序列
元组 tuple	是	否	是	固定配置、函数多返回值
字典 dict	是（3.7+）	是	键唯一，值可重复	模型参数、API 请求体
集合 set	否	是	否	去重、快速成员测试、权限检查

本章完整覆盖了 Python 的四种复合数据类型（列表、元组、字典、集合），并扩展了映射（defaultdict 、Counter ）和结构体（namedtuple 、dataclass）等高级内容，所有示例均与 AI 大模型应用场景紧密结合。掌握这些内容后，你就能灵活处理 AI 开发中常见的结构化数据了。