一、元组（tuple）是什么

• • 元组是有序、不可变的容器
• • 写法：用小括号 () 表示
• • 可以存放任意类型数据：数字、字符串、列表、元组等
• • 一旦创建，不能增、删、改元素（这是核心特点）

二、元组的创建

1. 基本创建

# 空元组
t1 = ()

# 普通元组
t2 = (10, 20, 30, 40)

# 混合类型
t3 = (1, "hello", True, 3.14)

# 嵌套元组
t4 = (1, 2, (3, 4))

2. 只有一个元素的元组（重点易错）

必须加逗号，否则不是元组！

# 正确
t5 = (10,)
print(type(t5))  # tuple

# 错误（只是整数 10）
t6 = (10)
print(type(t6))  # int

3. 省略括号创建（元组特色）

Python 允许省略小括号，直接用逗号分隔：

t7 = 1, 2, 3, 4
print(type(t7))  # tuple

4. 使用 tuple() 创建

# 从列表转元组
t8 = tuple([1,2,3])

# 从字符串转元组
t9 = tuple("abc")   # ('a','b','c')

# 从 range 转元组
t10 = tuple(range(5))  # (0,1,2,3,4)

三、元组的不可变性（核心重点）

1. 不可变是什么意思？

• • 不能修改元素值
• • 不能添加元素
• • 不能删除元素
• • 任何修改原元组的操作都会报错

t = (1, 2, 3)
t[0] = 100# 报错！TypeError

2. 但“内部可变对象”可以变

如果元组里有列表、字典，它们内部可以修改，
因为元组存的是引用，不是值本身。

t = (1, 2, [3, 4])
t[2].append(5)
print(t)  # (1, 2, [3, 4, 5])

3. 元组为什么要不可变？

• • 更安全，数据不会被意外修改
• • 作为字典的 key（列表不行）
• • 函数多返回值本质就是元组
• • 性能略优于列表

四、元组索引与切片（和列表完全一样）

1. 索引访问

t = (10, 20, 30, 40)
print(t[0])    # 10
print(t[-1])   # 40

2. 切片

print(t[1:3])   # (20, 30)
print(t[::2])   # (10, 30)
print(t[::-1])  # (40,30,20,10)

切片只读取，不修改，所以元组支持切片。

五、元组拆包（Tuple Unpacking）超级好用

1. 基本拆包

把元组元素一次性赋值给多个变量：

t = ("小明", 18, "北京")
name, age, city = t

print(name)  # 小明
print(age)   # 18
print(city)  # 北京

2. 多变量交换（经典用法）

a = 10
b = 20
a, b = b, a   # 交换，不需要临时变量

3. 函数多返回值本质是元组拆包

defget_user():
return"小红", 20

name, age = get_user()

4. * 号接收剩余元素（Python3 特色）

t = (1, 2, 3, 4, 5)
first, *middle, last = t
print(first)   # 1
print(middle)  # [2,3,4]
print(last)    # 5

5. 下划线占位（只想要部分值）

t = (100, 200, 300)
a, _, b = t   # 忽略第二个

六、命名元组（namedtuple）

1. 什么是 namedtuple？

• • 带名字的元组
• • 既像元组一样轻量，又能像对象一样用 .属性 访问
• • 属于 collections 模块

2. 基本使用步骤

from collections import namedtuple

# 1. 定义模板
Person = namedtuple("Person", ["name", "age", "city"])

# 2. 创建实例
p = Person("小明", 18, "上海")

# 3. 访问（两种方式）
print(p.name)    # 小明
print(p.age)     # 18
print(p[0])      # 小明（依然支持索引）

3. 优点

• • 比字典更省内存、更快
• • 比普通类更轻量
• • 比元组可读性高很多，不会记混索引

4. 常用方法

# 转字典
print(p._asdict())

# 复制并修改某个字段（返回新对象）
p2 = p._replace(age=20)

# 从列表/元组创建实例
p3 = Person._make(["小刚", 22, "广州"])

七、元组常用方法（很少，因为不可变）

t = (1, 2, 2, 3)

# 统计次数
print(t.count(2))  # 2

# 查找索引
print(t.index(2))  # 1

元组没有 append / pop / remove / sort 等修改方法。

八、列表 vs 元组 对比表

📚 练习题（带详细讲解）

练习1：判断哪个是元组

a = (1)
b = (1,)
c = 1, 2
print(type(a), type(b), type(c))

答案：
int、tuple、tuple

练习2：元组拆包

t = ("Python", 3.10, "Windows")
lan, ver, sys = t
print(lan)

答案：Python

练习3：namedtuple 使用

from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])
p = Point(10, 20)
print(p.x + p.y)

答案：30

📝 本章总结

1. 1. 元组创建：()，单个元素必须加逗号 (1,)
2. 2. 不可变性：不能增删改，内部可变对象除外
3. 3. 索引/切片：和列表完全一样
4. 4. 元组拆包：a,b,c = t，支持 * 接收剩余
5. 5. namedtuple：轻量、可读、替代简单类
6. 6. 适合存放固定配置、坐标、函数返回值等