元组(tuple)也是一种有序集合,可以保存多个值。它和列表很像,都支持索引、切片和遍历,但元组创建后不能直接修改其中的元素。
使用圆括号创建元组:
1point = (10, 20) 2topics = ("变量", "列表", "元组") 3empty = () 4 5print(point) 6print(topics) 7print(empty)
圆括号在很多场景中可以省略,逗号才是元组结构的重要标记:
1point = 10, 20 2 3print(point) # (10, 20) 4print(type(point)) # <class 'tuple'>
创建只有一个元素的元组时,必须保留逗号。没有逗号的 ("Python") 只是普通字符串加上括号:
("Python")
1single_tuple = ("Python",) 2not_tuple = ("Python") 3 4print(type(single_tuple)) # <class 'tuple'> 5print(type(not_tuple)) # <class 'str'>
也可以使用 tuple() 把其他可遍历对象转换成元组:
tuple()
1letters = tuple("Python") 2numbers = tuple(range(3)) 3 4print(letters) # ('P', 'y', 't', 'h', 'o', 'n') 5print(numbers) # (0, 1, 2)
元组的索引和切片规则与列表、字符串一致,索引从 0 开始:
0
1topics = ("变量", "列表", "元组", "字符串") 2 3print(topics[0]) # 变量 4print(topics[-1]) # 字符串 5print(topics[1:3]) # ('列表', '元组')
可以使用 len() 获取元组长度,使用 in 判断元素是否存在:
len()
in
1permissions = ("read", "write") 2 3print(len(permissions)) # 2 4print("read" in permissions) # True 5print("admin" not in permissions) # True
元组支持 count() 和 index():
count()
index()
1values = ("Python", "AI", "Python") 2 3print(values.count("Python")) # 2 4print(values.index("AI")) # 1
如果 index() 找不到目标元素,会抛出 ValueError。不确定元素是否存在时,先使用 in 判断。
ValueError
元组最重要的特征是不可变。创建之后,不能给某个位置重新赋值,也不能使用 append()、remove() 等方法修改结构:
append()
remove()
1topics = ("变量", "列表", "元组") 2 3# topics[0] = "模块" # TypeError 4# topics.append("字符串") # AttributeError
如果确实需要得到一个加入新元素的结果,应该创建一个新的元组:
1topics = ("变量", "列表") 2new_topics = topics + ("元组",) 3 4print(topics) # ('变量', '列表') 5print(new_topics) # ('变量', '列表', '元组')
这里的 + 不会修改原元组,而是返回一个新的元组。单元素元组中的逗号不能省略。
+
元组不可变,但如果元组里面保存的是列表,列表本身仍然可以修改:
1data = ("topics", ["变量", "列表"]) 2data[1].append("元组") 3 4print(data) # ('topics', ['变量', '列表', '元组'])
不可变的是元组保存的元素引用,不能通过元组索引替换第二个元素;内部列表作为独立对象,仍然保留自己的可变性。
元组经常用于一次性保存一组固定值,也经常用于解包:把元组中的元素依次赋给多个变量:
1point = (10, 20) 2x, y = point 3 4print(x) # 10 5print(y) # 20
左侧变量的数量必须和右侧元素数量匹配,否则会抛出 ValueError:
1values = (1, 2, 3) 2 3# first, second = values # ValueError
如果只关心一部分元素,可以使用 * 收集剩余内容:
*
1values = (1, 2, 3, 4, 5) 2first, *middle, last = values 3 4print(first) # 1 5print(middle) # [2, 3, 4] 6print(last) # 5
带 * 的变量得到的是列表,而不是元组。一个解包表达式中通常只使用一个带 * 的变量。
函数可以返回多个值,Python 实际上会把它们组合成元组:
1def get_user(): 2 return "小明", 18 3 4name, age = get_user() 5print(name) 6print(age)
这种写法比手动创建一个临时对象更简洁,适合返回几个关系紧密的结果。
列表和元组都可以保存有序数据,但用途有所不同:
[]
()
需要不断添加任务、删除结果或重新排序时,使用列表更合适:
1tasks = ["读取文件", "保存结果"] 2tasks.append("发送通知") 3 4print(tasks)
表示坐标、配置项、日期或函数返回的固定组合时,元组更能表达「这些位置和数量不会随意变化」的意图:
1rgb = (255, 128, 0) 2version = (3, 12, 1) 3 4print(rgb) 5print(version)
元组中的元素都可哈希时,可以作为字典的键。列表因为可变,不能直接作为字典键:
1locations = { 2 (31.23, 121.47): "上海", 3 (39.90, 116.40): "北京", 4} 5 6print(locations[(31.23, 121.47)]) # 上海
元组可以直接遍历,也可以和 enumerate() 一起使用:
enumerate()
1topics = ("变量", "列表", "元组") 2 3for index, topic in enumerate(topics, start=1): 4 print(f"第 {index} 个主题:{topic}")
在处理固定结构的数据时,可以把元组解包后再使用:
1records = ( 2 ("小明", 82), 3 ("小红", 95), 4 ("小李", 58), 5) 6 7for name, score in records: 8 if score >= 60: 9 print(f"{name}:通过")
下面的例子使用元组保存固定的状态值,再用字典把状态值映射为展示文本:
01statuses = ("pending", "running", "success", "failed") 02labels = { 03 "pending": "等待中", 04 "running": "执行中", 05 "success": "执行成功", 06 "failed": "执行失败", 07} 08 09for status in statuses: 10 print(labels[status])
FastAPI 接口和 LangChain 工具中也经常返回固定结构的多个结果。例如把状态和消息一起返回,再由调用方解包:
1def run_task(): 2 return True, "任务执行成功" 3 4success, message = run_task() 5if success: 6 print(message)
当返回值的数量和含义稳定时,元组可以让调用方一眼看出数据结构;如果字段很多、需要按名称访问,则更适合使用字典或数据模型。
用坐标和任务状态观察元组的固定结构。接口会把 Python 的类型名与 repr() 一起返回,避免只看 JSON 数组而误以为 Python 中保存的也是列表。
main.py 提供接口,tuples_demo.py 执行实验。下面展示的代码与在线编辑器的初始文件来自同一份源码;修改编辑器中的文件后,保存并重新运行,接口就会使用修改后的内容。
01from typing import Literal 02 03from fastapi import FastAPI, Query 04 05from tuples_demo import build_report 06 07app = FastAPI() 08 09@app.get("/tuples") 10async def tuples( 11 x: int = Query(10, ge=-10000, le=10000), 12 y: int = Query(20, ge=-10000, le=10000), 13 status: Literal["pending", "running", "success", "failed"] = "running", 14) -> dict[str, object]: 15 report = build_report(x, y, status) 16 print(f"坐标元组:{report['point']['repr']}") 17 print(f"星号解包中间值类型:{report['starred']['middle_type']}") 18 print(f"索引赋值的捕获结果:{report['immutable_error']}") 19 return report 20
01def describe(value: tuple) -> dict[str, object]: 02 return {"type": type(value).__name__, "repr": repr(value), "items": list(value)} 03 04def task_result(status: str) -> tuple[bool, str]: 05 labels = {"pending": "等待中", "running": "执行中", 06 "success": "执行成功", "failed": "执行失败"} 07 return status == "success", labels[status] 08 09def build_report(x: int, y: int, status: str) -> dict[str, object]: 10 point = (x, y) 11 unpacked_x, unpacked_y = point 12 first, *middle, last = (1, 2, 3, 4, 5) 13 success, message = task_result(status) 14 15 try: 16 point[0] = 0 17 except TypeError as error: 18 immutable_error = type(error).__name__ 19 20 # 元组的元素引用不变,但其中的列表对象仍然可以修改。 21 nested = ("topics", ["变量", "列表"]) 22 before_nested = repr(nested) 23 nested[1].append("元组") 24 25 # 元组键留在 Python 内部;响应返回查找结果,不直接序列化这个字典。 26 locations = {point: "当前坐标"} 27 return { 28 "point": describe(point), 29 "unpacked": {"x": unpacked_x, "y": unpacked_y}, 30 "single": describe(("Python",)), 31 "without_comma": {"type": type(("Python")).__name__, "value": ("Python")}, 32 "slice": describe(point[:1]), 33 "extended": describe(point + (30,)), 34 "immutable_error": immutable_error, 35 "nested_mutable": {"before": before_nested, "after": repr(nested)}, 36 "starred": {"first": first, "middle": middle, "last": last, 37 "middle_type": type(middle).__name__}, 38 "tuple_key": {"key_repr": repr(point), "value": locations[point]}, 39 "returned_values": {"success": success, "message": message, 40 "python_type": type(task_result(status)).__name__}, 41 } 42 43if __name__ == "__main__": 44 import json 45 46 print(json.dumps(build_report(10, 20, "running"), ensure_ascii=False, indent=2)) 47
打开本篇在线案例,点击运行并等待环境就绪。案例预览默认选择 GET,地址为:
1/tuples?x=10&y=20&status=running
默认响应中,point.type 为 tuple,point.repr 为 "(10, 20)";single.type 是 tuple,without_comma.type 是 str。starred.middle 是 [2, 3, 4],middle_type 为 list。immutable_error 为 TypeError,它是已经捕获的教学结果,接口不会因此失败。
point.type
tuple
point.repr
"(10, 20)"
single.type
without_comma.type
str
starred.middle
[2, 3, 4]
middle_type
list
immutable_error
TypeError
日志会打印对应的关键操作结果。把 x 和 y 改为 31、121,观察坐标与元组键查询结果变化;把 status 改为 success,returned_values.success 会变成 true,message 为 "执行成功"。也可以修改 tuples_demo.py 中的元组内容,保存并重新运行后观察解包结果。
x
y
31
121
status
success
returned_values.success
true
message
"执行成功"
tuples_demo.py
status 只允许 pending、running、success、failed,其余值返回 HTTP 422。JSON 没有元组类型,所以 items 明确转成列表,type 与 repr 才说明 Python 里原本的类型。nested_mutable 演示修改内部列表,不是在替换元组元素。元组键字典只在 Python 中查询,不直接作为 JSON 对象返回。
本案例只使用标准库、FastAPI 与 Pydantic,不需要模型密钥。下载并解压 ZIP,进入项目目录后执行:
1uv run python tuples_demo.py 2uv run fastapi dev main.py
第一条直接在终端打印实验结果;第二条启动 FastAPI。打开 http://127.0.0.1:8000/docs,选择 GET /tuples,填写同样的参数即可发起请求。本机使用 Python 3.12,浏览器使用当前 Pyodide 版本,通过 HTTPX ASGITransport 执行接口,不启动电脑上的 8000 端口。
本篇的代码、日志、Git 配置与 PI Agent 对话使用独立工作区;同站 Python 依赖缓存可以复用。本机配置文件、忽略规则和 README 都包含在项目中,可以在文件目录里查看、编辑和下载。
此段落已有评论,按 Enter 查看评论及回复列表。
连接 GitHub 后查看和发表评论,也可在 GitHub 查看公开讨论。
1. 元组
元组(tuple)也是一种有序集合,可以保存多个值。它和列表很像,都支持索引、切片和遍历,但元组创建后不能直接修改其中的元素。
使用圆括号创建元组:
圆括号在很多场景中可以省略,逗号才是元组结构的重要标记:
创建只有一个元素的元组时,必须保留逗号。没有逗号的
("Python")只是普通字符串加上括号:也可以使用
tuple()把其他可遍历对象转换成元组:2. 访问
元组的索引和切片规则与列表、字符串一致,索引从
0开始:可以使用
len()获取元组长度,使用in判断元素是否存在:元组支持
count()和index():如果
index()找不到目标元素,会抛出ValueError。不确定元素是否存在时,先使用in判断。3. 不可变
元组最重要的特征是不可变。创建之后,不能给某个位置重新赋值,也不能使用
append()、remove()等方法修改结构:如果确实需要得到一个加入新元素的结果,应该创建一个新的元组:
这里的
+不会修改原元组,而是返回一个新的元组。单元素元组中的逗号不能省略。元组不可变,但如果元组里面保存的是列表,列表本身仍然可以修改:
不可变的是元组保存的元素引用,不能通过元组索引替换第二个元素;内部列表作为独立对象,仍然保留自己的可变性。
4. 解包
元组经常用于一次性保存一组固定值,也经常用于解包:把元组中的元素依次赋给多个变量:
左侧变量的数量必须和右侧元素数量匹配,否则会抛出
ValueError:如果只关心一部分元素,可以使用
*收集剩余内容:带
*的变量得到的是列表,而不是元组。一个解包表达式中通常只使用一个带*的变量。函数可以返回多个值,Python 实际上会把它们组合成元组:
这种写法比手动创建一个临时对象更简洁,适合返回几个关系紧密的结果。
5. 对比
列表和元组都可以保存有序数据,但用途有所不同:
[]()需要不断添加任务、删除结果或重新排序时,使用列表更合适:
表示坐标、配置项、日期或函数返回的固定组合时,元组更能表达「这些位置和数量不会随意变化」的意图:
元组中的元素都可哈希时,可以作为字典的键。列表因为可变,不能直接作为字典键:
6. 使用
元组可以直接遍历,也可以和
enumerate()一起使用:在处理固定结构的数据时,可以把元组解包后再使用:
下面的例子使用元组保存固定的状态值,再用字典把状态值映射为展示文本:
FastAPI 接口和 LangChain 工具中也经常返回固定结构的多个结果。例如把状态和消息一起返回,再由调用方解包:
当返回值的数量和含义稳定时,元组可以让调用方一眼看出数据结构;如果字段很多、需要按名称访问,则更适合使用字典或数据模型。
7. 在线元组实验
用坐标和任务状态观察元组的固定结构。接口会把 Python 的类型名与 repr() 一起返回,避免只看 JSON 数组而误以为 Python 中保存的也是列表。
7.1 完整案例代码
main.py 提供接口,tuples_demo.py 执行实验。下面展示的代码与在线编辑器的初始文件来自同一份源码;修改编辑器中的文件后,保存并重新运行,接口就会使用修改后的内容。
7.2 运行与观察
打开本篇在线案例,点击运行并等待环境就绪。案例预览默认选择 GET,地址为:
默认响应中,
point.type为tuple,point.repr为"(10, 20)";single.type是tuple,without_comma.type是str。starred.middle是[2, 3, 4],middle_type为list。immutable_error为TypeError,它是已经捕获的教学结果,接口不会因此失败。日志会打印对应的关键操作结果。把
x和y改为31、121,观察坐标与元组键查询结果变化;把status改为success,returned_values.success会变成true,message为"执行成功"。也可以修改tuples_demo.py中的元组内容,保存并重新运行后观察解包结果。status 只允许 pending、running、success、failed,其余值返回 HTTP 422。JSON 没有元组类型,所以 items 明确转成列表,type 与 repr 才说明 Python 里原本的类型。nested_mutable 演示修改内部列表,不是在替换元组元素。元组键字典只在 Python 中查询,不直接作为 JSON 对象返回。
7.3 在本机继续运行
本案例只使用标准库、FastAPI 与 Pydantic,不需要模型密钥。下载并解压 ZIP,进入项目目录后执行:
第一条直接在终端打印实验结果;第二条启动 FastAPI。打开 http://127.0.0.1:8000/docs,选择 GET /tuples,填写同样的参数即可发起请求。本机使用 Python 3.12,浏览器使用当前 Pyodide 版本,通过 HTTPX ASGITransport 执行接口,不启动电脑上的 8000 端口。
本篇的代码、日志、Git 配置与 PI Agent 对话使用独立工作区;同站 Python 依赖缓存可以复用。本机配置文件、忽略规则和 README 都包含在项目中,可以在文件目录里查看、编辑和下载。