当前位置：首页 > news >正文

05 Python 元组：不可变序列的解析和应用

news 来源：原创 2025/6/17 13:31:31

文章目录

- 前言
- 元组定义
- 元组的运算
- - 索引操作
  - 切片操作
  - 连接和重复运算
  - 循环遍历元组中的元素
  - 成员运算
  - 内置函数运算
- 打包和解包操作
- 交换变量的值

前言

在 Python 编程领域，元组（Tuple）是一类极为重要的数据结构。它属于不可变的序列类型，通过圆括号 () 进行定义，其中元素可涵盖多种不同数据类型，元素间以逗号分隔。元组凭借其独特性质，在诸多编程场景中发挥着关键作用。

元组定义

元组中的元素依照特定顺序构建起序列，具备有序性这一显著特征，我们能够借助索引便捷地访问其中元素。与列表存在本质区别的是，元组属于不可变类型。这表明一旦定义元组类型的变量，其中元素便无法再进行修改，元素的值也固定不可变动。这种不可变性在保障数据稳定性与安全性方面具有重要意义。

元组的运算

索引操作

元组支持通过索引精准访问元素

t = (10, 20, 30, 40, 50)
print("元组t的第一个元素：", t[0]) # 输出：10,
print("元组t的最后一个元素：", t[-1]) # 输出： 50

正向索引从0开始，负向索引从-1开始，通过索引可以定位元组中的元素

切片操作

切片操作能够帮助我们获取元组的特定片段

t = (10, 20, 30, 40, 50)
print("获取索引1到3的元素：", t[1:3]) # 输出：(20,30)
print("从索引2开始到末尾的元素：", t[2:]) # 输出：(30,40,50)
print("获取整个元组：", t[:]) # 输出：(10,20,30,40,50)
print("步长为2获取元素：", t[::2]) # 输出：(10,30,50)

切片操作通过指定起始索引、结束索引（不包含该索引对应元素）以及步长，灵活截取元组片段。

连接和重复运算

元组之间可进行连接和重复运算

t1 = (1, 2, 3)
t2 = (4, 5, 6)

print("连接元组t1和t2：", t1 + t2) # 输出：(1,2,3,4,5,6)
print("元组t1重复3次：", t1 * 3) # 输出：(1,2,3,1,2,3,1,2,3)

连接运算将两个元组合并为一个新元组，重复运算则按照指定次数复制元组元素

循环遍历元组中的元素

我们可使用for循环遍历元组中的元素。

t1 = (35, 12, 98)
for elem in t1:
    print(elem)

输出：
35
12
98
通过循环，可依次访问元组中的每个元素，便于对元组数据进行处理。

成员运算

利用in和not in关键字可判断元素是否存在于元组中。

t1 = (1, 2, 3)
t2 = (4, 5, 6)
print("判断1是否在元组t1中：", 1 in t1) # 输出：True
print("判断7是否不在元组t2中：", 7 not in t2) # 输出：True

内置函数运算

t3 = (10, 20, 30, 40, 50)
print("元组t3的长度：", len(t3)) # 输出：5
print("元组t3中的最大值：", max(t3)) # 输出：50
print("元组t3中的最小值：", min(t3)) # 输出：10
print("元组t3中所有元素的和：", sum(t3)) # 输出：150

打包和解包操作

在Python中，存在打包和解包这两种特殊操作。当将多个逗号分割的值赋给一个变量是，这些值会自动打包成一个元组类型；而将一个元组赋值给多个变量时，元组会解包成多个值并分别赋给对应的变量

# 打包操作
a = 1, 10, 100
print(type(a))  # <class 'tuple'>
print(a)        # (1, 10, 100)
# 解包操作
i, j, k = a
print(i, j, k)  # 1 10 100

在解包过程中，若解包出来的元素个数与变量个数不匹配，会触发ValueError异常，错误信息分别为too many values to unpack（解包的值太多）或not enough values to unpack（解包的值不足）

a = 1, 10, 100, 1000
# i, j, k = a             # ValueError: too many values to unpack (expected 3)
# i, j, k, l, m, n = a    # ValueError: not enough values to unpack (expected 6, got 4)

针对变量个数少于元素个数的情况，可采用星号表达式解决。借助星号表达式，可使一个变量接收多个值。需注意两点：其一，经星号表达式修饰的变量会转变为一个列表，该列表可能包含 0 个或多个元素；其二，在解包语法中，星号表达式仅能出现一次。

a = 1, 10, 100, 1000
i, j, *k = a
print(i, j, k)        # 1 10 [100, 1000]
i, *j, k = a
print(i, j, k)        # 1 [10, 100] 1000
*i, j, k = a
print(i, j, k)        # [1, 10] 100 1000
*i, j = a
print(i, j)           # [1, 10, 100] 1000
i, *j = a
print(i, j)           # 1 [10, 100, 1000]
i, j, k, *l = a
print(i, j, k, l)     # 1 10 100 [1000]
i, j, k, l, *m = a
print(i, j, k, l, m)  # 1 10 100 1000 []

补充一下，解包语法对所有的序列都成立，这就表示列表、range函数构造的范围序列甚至字符串都可以使用解包语法

a, b, *c = range(1, 10)
print(a, b, c) # 输出：1 2 [3,4,5,6,7,8,9]
a, b, c = [1, 10, 100]
print(a, b, c) # 输出:1 10 100
a, *b, c = 'hello'
print(a, b, c) # 输出：h ['e','l','l'] o