Tuple (元组)

下面是一份最完整、最系统、最实战的《Python 元组（tuple）知识体系总结》，覆盖基础 + 高级 + 实战技巧，非常适合收藏。

🎯 1. 什么是元组（tuple）

元组是不可变（immutable）的有序序列。

你可以把它理解为：

不可变版的 list
轻量级数据项容器
更安全、更快、更省内存

定义方式：

t = (1, 2, 3)

🧱 2. 元组的核心特点

特点	说明
有序	支持索引、切片
不可变	不能 append / remove / 修改元素
可哈希（前提：内部元素可哈希）	可以作为 dict 的 key、放入 set
轻量、更快	比 list 更节省内存，速度更快
可包含不同类型	如 (1, “abc”, True, [])

📌 3. 元组的创建方式

① 小括号

t = (1, 2, 3)

② 不加括号（自动打包）

t = 1, 2, 3

③ 单元素元组（最容易犯错！）

t = (1,)   # 正确
t = (1)    # 错误，类型为 int

④ 使用 tuple()

t = tuple([1, 2, 3])

🚀 4. 元组打包（packing）

Python 会自动将多个值打包为 tuple：

t = 10, 20, 30
print(t)  # (10, 20, 30)

🚀 5. 元组解包（unpacking）

① 基础解包

x, y = (10, 20)

② 多值解包

a, b, c = (1, 2, 3)

③ 星号解包（*）

a, *b = (1, 2, 3, 4)
# a = 1, b = [2,3,4]

*a, b = (1, 2, 3, 4)
# a = [1,2,3], b = 4

a, *b, c = (1, 2, 3, 4, 5)
# a = 1, b = [2,3,4], c = 5

④ 解包给函数参数

def add(a, b, c):
    return a + b + c

params = (1, 2, 3)
add(*params)

🔧 6. 元组操作（安全且常用）

索引与切片

t[0]
t[1:3]

连接

t1 + t2

重复

t * 3

成员检查

if 3 in t:
    ...

🔐 7. 为什么要用元组（tuple）？

① 不可变 -> 更安全

数据不会被误修改。

② 可哈希 -> 可做 dict 的 key

例如：

locations = {}
locations[(35.1, 108.9)] = "Xi'an"

③ 速度快 & 占用内存少

Python 内部优化过的只读结构。

④ 函数返回多个值（最常用）

def get_user():
    return 1, "Jack"

uid, name = get_user()

☘️ 8. 元组 vs 列表（tuple vs list）

属性	tuple	list
可变性	❌ 不可变	✅ 可变
内存	更省	较大
速度	更快	较慢
用途	返回值，常量数据，字典 key	动态数据、可变结构
哈希性	可哈希（内部元素都可哈希时）	不可哈希

🛠 9. 元组高级技巧

① 交换变量

a, b = b, a

② 解包 + 忽略

name, _, age = ("Tom", "Male", 23)

③ 嵌套解包

(a, b), (c, d) = [(1, 2), (3, 4)]

④ 使用 enumerate

for idx, value in enumerate(["a", "b", "c"]):
    print(idx, value)

这里 (idx, value) 就是 tuple。

🧰 10. 元组是 Python 结构化数据的基础

例如：

zip 产生元组

zip_list = list(zip([1,2,3], ["a","b","c"]))
# [(1,'a'), (2,'b'), (3,'c')]

dict.items() 也是元组

for key, value in mydict.items():
    ...

SQLAlchemy 查询行结果也是 tuple-like

✅ 11. 推荐使用元组的场景

不会改变的数据
函数返回多个值
作为 dict 的 key
配置常量
快速临时结构（比 list 更快）
给 map/filter/reduce 等函数传参数
展示一个数据记录（类似 struct）

⭐ 12. 一屏速查表（收藏）

tuple 基础：

不可变，有序
支持索引、切片、解包
内存小、速度快

关键概念：

自动打包：t = 1,2,3
解包：a,b = (1,2)
星号解包：a,*b,c = …

常用场景：

函数返回值
dict 的 key
不可变数据结构
zip / enumerate / dict.items

元组打包和解包示例

以下是最常用、最直观的 Python 元组 “打包 / 解包” 示例（含高级用法）。

🟦 1. 元组打包（Tuple Packing）

Python 自动把多个值打包成一个元组：

tpl = 1, 2, 3
print(tpl)

输出：

(1, 2, 3)

也可以显式写括号：

tpl = (1, 2, 3)

🟩 2. 元组解包（Tuple Unpacking）

把元组中的值拆开赋给多个变量：

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

输出：

1 2 3

🟨 3. 自动类型转换 + 解包

普通返回值，也可以直接解包：

def foo():
    return 10, 20, 30  # 实际返回的是一个 tuple

x, y, z = foo()
print(x, y, z)

🟧 4. 使用 *rest 捕获多余项目（可变解包）

⭐ 非常实用！

a, *middle, b = (1, 2, 3, 4, 5)

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

🟥 5. 交换变量（最经典的解包示例）

x, y = 10, 20
x, y = y, x
print(x, y)

输出：

20 10

🟦 6. 丢弃不需要的值（使用 `_`）

a, _, c = (1, 2, 3)
print(a, c)

🟩 7. 函数接收多个返回值（自动解包）

def get_user():
    return "jack", 18, "shenzhen"

name, age, city = get_user()

🟨 8. 字典 items() 解包（非常常用）

d = {"a": 1, "b": 2}

for key, value in d.items():
    print(key, value)

🟧 9. 循环中同时解包多个元组

coords = [(1, 2), (3, 4), (5, 6)]

for x, y in coords:
    print(x, y)

🟥 10. 解包嵌套结构

nested = ("user", (10, 20))

name, (x, y) = nested

print(name, x, y)

🔥 Bonus：星号解包直接传参

args = (1, 2, 3)

def add(a, b, c):
    return a + b + c

result = add(*args)
print(result)

📌 总结口诀

元组打包：

a = 1, 2, 3

元组解包：

x, y, z = a

带 * 的可变解包：

a, *b, c = some_tuple

非常灵活、Pythonic！