usehook
创建时间: 2026-08-25最后更新: 2026-08-27

1. 元组

元组（tuple）也是一种有序集合，可以保存多个值。它和列表很像，都支持索引、切片和遍历，但元组创建后不能直接修改其中的元素。

使用圆括号创建元组：

create.py
1
point = (10, 20)

2
topics = ("变量", "列表", "元组")

3
empty = ()

4


5
print(point)

6
print(topics)

7
print(empty)

圆括号在很多场景中可以省略，逗号才是元组结构的重要标记：

comma.py
1
point = 10, 20

2


3
print(point)        # (10, 20)

4
print(type(point))  # <class 'tuple'>

创建只有一个元素的元组时，必须保留逗号。没有逗号的 ("Python") 只是普通字符串加上括号：

single.py
1
single_tuple = ("Python",)

2
not_tuple = ("Python")

3


4
print(type(single_tuple))  # <class 'tuple'>

5
print(type(not_tuple))     # <class 'str'>

也可以使用 tuple() 把其他可遍历对象转换成元组：

convert.py
1
letters = tuple("Python")

2
numbers = tuple(range(3))

3


4
print(letters)  # ('P', 'y', 't', 'h', 'o', 'n')

5
print(numbers)  # (0, 1, 2)

2. 访问

元组的索引和切片规则与列表、字符串一致，索引从 0 开始：

access.py
1
topics = ("变量", "列表", "元组", "字符串")

2


3
print(topics[0])   # 变量

4
print(topics[-1])  # 字符串

5
print(topics[1:3]) # ('列表', '元组')

可以使用 len() 获取元组长度，使用 in 判断元素是否存在：

inspect.py
1
permissions = ("read", "write")

2


3
print(len(permissions))       # 2

4
print("read" in permissions)  # True

5
print("admin" not in permissions)  # True

元组支持 count() 和 index()：

methods.py
1
values = ("Python", "AI", "Python")

2


3
print(values.count("Python"))  # 2

4
print(values.index("AI"))      # 1

如果 index() 找不到目标元素，会抛出 ValueError。不确定元素是否存在时，先使用 in 判断。

3. 不可变

元组最重要的特征是不可变。创建之后，不能给某个位置重新赋值，也不能使用 append()、remove() 等方法修改结构：

immutable.py
1
topics = ("变量", "列表", "元组")

2


3
# topics[0] = "模块"  # TypeError

4
# topics.append("字符串")  # AttributeError

如果确实需要得到一个加入新元素的结果，应该创建一个新的元组：

new-tuple.py
1
topics = ("变量", "列表")

2
new_topics = topics + ("元组",)

3


4
print(topics)      # ('变量', '列表')

5
print(new_topics)  # ('变量', '列表', '元组')

这里的 + 不会修改原元组，而是返回一个新的元组。单元素元组中的逗号不能省略。

元组不可变，但如果元组里面保存的是列表，列表本身仍然可以修改：

nested-mutable.py
1
data = ("topics", ["变量", "列表"])

2
data[1].append("元组")

3


4
print(data)  # ('topics', ['变量', '列表', '元组'])

不可变的是元组保存的元素引用，不能通过元组索引替换第二个元素；内部列表作为独立对象，仍然保留自己的可变性。

4. 解包

元组经常用于一次性保存一组固定值，也经常用于解包：把元组中的元素依次赋给多个变量：

unpack.py
1
point = (10, 20)

2
x, y = point

3


4
print(x)  # 10

5
print(y)  # 20

左侧变量的数量必须和右侧元素数量匹配，否则会抛出 ValueError：

unpack-error.py
1
values = (1, 2, 3)

2


3
# first, second = values  # ValueError

如果只关心一部分元素，可以使用 * 收集剩余内容：

starred.py
1
values = (1, 2, 3, 4, 5)

2
first, *middle, last = values

3


4
print(first)   # 1

5
print(middle)  # [2, 3, 4]

6
print(last)    # 5

带 * 的变量得到的是列表，而不是元组。一个解包表达式中通常只使用一个带 * 的变量。

函数可以返回多个值，Python 实际上会把它们组合成元组：

return-values.py
1
def get_user():

2
    return "小明", 18

3


4
name, age = get_user()

5
print(name)

6
print(age)

这种写法比手动创建一个临时对象更简洁，适合返回几个关系紧密的结果。

5. 对比

列表和元组都可以保存有序数据，但用途有所不同：

对比项列表元组
创建符号[]()
是否有序是是
是否可修改可以不可以
常用场景数据需要增删改数据结构固定
是否支持索引切片支持支持
是否可作为字典键通常不可以元素都可哈希时可以

需要不断添加任务、删除结果或重新排序时，使用列表更合适：

list-choice.py
1
tasks = ["读取文件", "保存结果"]

2
tasks.append("发送通知")

3


4
print(tasks)

表示坐标、配置项、日期或函数返回的固定组合时，元组更能表达「这些位置和数量不会随意变化」的意图：

tuple-choice.py
1
rgb = (255, 128, 0)

2
version = (3, 12, 1)

3


4
print(rgb)

5
print(version)

元组中的元素都可哈希时，可以作为字典的键。列表因为可变，不能直接作为字典键：

dict-key.py
1
locations = {

2
    (31.23, 121.47): "上海",

3
    (39.90, 116.40): "北京",

4
}

5


6
print(locations[(31.23, 121.47)])  # 上海

6. 使用

元组可以直接遍历，也可以和 enumerate() 一起使用：

loop.py
1
topics = ("变量", "列表", "元组")

2


3
for index, topic in enumerate(topics, start=1):

4
    print(f"第 {index} 个主题：{topic}")

在处理固定结构的数据时，可以把元组解包后再使用：

records.py
1
records = (

2
    ("小明", 82),

3
    ("小红", 95),

4
    ("小李", 58),

5
)

6


7
for name, score in records:

8
    if score >= 60:

9
        print(f"{name}：通过")

下面的例子使用元组保存固定的状态值，再用字典把状态值映射为展示文本：

status.py
01
statuses = ("pending", "running", "success", "failed")

02
labels = {

03
    "pending": "等待中",

04
    "running": "执行中",

05
    "success": "执行成功",

06
    "failed": "执行失败",

07
}

08


09
for status in statuses:

10
    print(labels[status])

FastAPI 接口和 LangChain 工具中也经常返回固定结构的多个结果。例如把状态和消息一起返回，再由调用方解包：

result.py
1
def run_task():

2
    return True, "任务执行成功"

3


4
success, message = run_task()

5
if success:

6
    print(message)

当返回值的数量和含义稳定时，元组可以让调用方一眼看出数据结构；如果字段很多、需要按名称访问，则更适合使用字典或数据模型。

正在验证登录状态
请稍候，验证完成后将继续显示文章内容
0
订阅