相关教程

  1. Python 基础教程
  2. 在 SublimeEditor 中配置 Python 环境
  3. Python 代码中添加注释
  4. Python 中的变量的使用
  5. Python 中的数据类型
  6. Python 中的关键字
  7. Python 字符串操作
  8. Python 中的 list 操作
  9. Python 中的 Tuple 操作
  10. Python max（）和 min（）–在列表或数组中查找最大值和最小值
  11. Python 找到最大的 N 个（前 N 个）或最小的 N 个项目
  12. Python 读写 CSV 文件
  13. Python 中使用 httplib2–HTTP GET 和 POST 示例
  14. Python 将 tuple 解包为变量或参数
  15. Python 解包 Tuple–太多值无法解压
  16. Python multidict 示例–将单个键映射到字典中的多个值
  17. Python OrderedDict–有序字典
  18. Python 字典交集–比较两个字典
  19. Python 优先级队列示例

Python 中的元组（Tuple）操作

在 Python 中，元组（Tuple） 类似于列表（List），但它是不可变（Immutable） 的，通常使用圆括号表示。

元组的主要特征包括：

  • 不可变：创建后无法修改其元素。
  • 有序：元素保持插入顺序。
  • 异构：可以包含不同类型的元素。
  • 可索引：支持从零开始的索引访问。
  • 语法：使用圆括号（可选，但建议使用）。
  • 性能：由于不可变性，在迭代过程中通常比列表更快。

元组非常适合用于创建包含相关信息的对象（例如员工信息记录）。换句话说，元组允许我们将相关信息“打包”在一起，并作为一个整体进行处理。

1. 创建元组

元组中的元素用圆括号括起来，并用逗号分隔。元组可以包含任意数量、不同类型的项。

语法：

tuple_var = (item1, item2, item3)

元组示例：

tuple1 = ()             # 空元组
tuple2 = (1, "2", 3.0)  # 包含不同类型元素
tuple3 = 1, "2", 3.0    # 圆括号可选，但仍被视为元组

1.1 单元素元组

如果圆括号内仅包含一个元素且没有逗号，Python 不会将其视为元组。必须添加尾随逗号以明确指定其为元组。

示例：

tuple_with_one_element = ("hello", )  # 注意尾随逗号

1.2 嵌套元组

包含另一个元组作为元素的元组，称为嵌套元组。

示例：

nested_tuple = ("hello", ("python", "world"))

2. 访问元组元素

我们可以使用方括号内的索引来访问元组项。

  • 正索引：从元组开头开始计数（从 0 开始）。
  • 负索引：从元组末尾开始计数（从 -1 开始）。
  • 切片（Slicing）：使用索引范围创建一个新的元组。
  • 范围规则：[m:n] 表示从位置 m（包含）到位置 n（不包含）。
  • 嵌套访问：使用多重索引访问嵌套元组的元素。

访问示例：

tuple_var = ("a", "b", "c", "d", "e", "f")

print(tuple_var[0])    # a
print(tuple_var[1])    # b
print(tuple_var[-1])   # f
print(tuple_var[-2])   # e
print(tuple_var[0:3])  # ('a', 'b', 'c')
print(tuple_var[-3:-1])# ('d', 'e')

# 嵌套元组访问
tuple_nested = ("a", "b", "c", ("d", "e", "f"))

print(tuple_nested[3])     # ('d', 'e', 'f')
print(tuple_nested[3][0])  # d
print(tuple_nested[3][0:2])# ('d', 'e')

3. 遍历元组

使用 for 循环遍历元组中的项。

示例：

tuple_var = ("a", "b", "c")

for x in tuple_var:
    print(x)

4. 检查元素是否存在

要检查元组是否包含给定元素，可以使用 in 和 not in 关键字。

示例：

tuple_var = ("a", "b", "c", "d", "e", "f")

if "a" in tuple_var:
    print("Yes, 'a' is present")  # Yes, 'a' is present

if "p" not in tuple_var:
    print("No, 'p' is not present")  # No, 'p' is not present

5. 元组排序

使用内置的 sorted() 函数对元组内的元素进行排序。请注意，sorted() 返回的是一个列表（List），而不是元组。

示例：

tuple_var = ("a", "c", "b", "d", "f", "e")

sorted_tuple = sorted(tuple_var)

print(sorted_tuple)  # ['a', 'b', 'c', 'd', 'e', 'f']

6. 重复与连接

重复：将元组乘以因子 N 可重复其所有元素。

示例：

tuple_var = ("a", "b")

repeated_tuple = tuple_var * 3

print(repeated_tuple)  # ('a', 'b', 'a', 'b', 'a', 'b')

连接：使用 + 运算符连接两个或多个元组。

示例：

tuple1 = ("a", "b", "c")
tuple2 = ("d", "e", "f")

joined_tuple = tuple1 + tuple2

print(joined_tuple)  # ('a', 'b', 'c', 'd', 'e', 'f')

7. 打包与解包

打包（Packing） 是指将一组值分配给一个变量的操作。在打包时，元组中的所有项目被分配给一个元组对象。

示例：

tuple_var = ("a", "b", "c")  # 打包

解包（Unpacking） 是指将元组中的各个项目分配给各个变量的操作。

示例：

tuple_var = ("a", "b", "c")  # 打包

(x, y, z) = tuple_var        # 解包

print(x)  # a
print(y)  # b
print(z)  # c

在解包期间，等号左侧变量的数量必须与右侧元组中的元素数量一致，否则会抛出错误。

解包错误示例：

tuple_var = ("a", "b", "c")  # 打包

# 错误：值太多，无法解包（期望 2 个，得到 3 个）
(x, y) = tuple_var           # ValueError: too many values to unpack (expected 2)

# 错误：值不足，无法解包（期望 4 个，得到 3 个）
(x, y, z, i) = tuple_var     # ValueError: not enough values to unpack (expected 4, got 3)

8. 命名元组（Named Tuples）

Python 的 collections 模块提供了一种名为 namedtuple() 的特殊工厂函数。

命名元组类似于字典，但支持通过索引和属性名（键）进行访问，而普通字典仅支持按键访问。

示例：

import collections

Record = collections.namedtuple('Record', ['id', 'name', 'date'])

R1 = Record('1', 'My Record', '12/12/2020')

# 通过索引访问
print("Record id is:", R1[0])  # Record id is: 1

# 通过键名访问
print("Record name is:", R1.name)  # Record name is: My Record

9. 元组常用内置函数

以下内置函数适用于元组对象（注意：它们是内置函数，而非元组的方法）。

9.1 any()

如果元组中至少有一个元素为真，则返回 True；如果元组为空，则返回 False。

print(any(()))        # 空元组 - False
print(any((1,)))      # 单元素元组 - True
print(any((1, 2)))    # 常规元组 - True

9.2 min()

返回元组中的最小元素。

tuple_var = (4, 1, 2, 6, 9)

print(min(tuple_var))  # 1

9.3 max()

返回元组中的最大元素。

tuple_var = (4, 1, 2, 6, 9)

print(max(tuple_var))  # 9

9.4 len()

返回元组的长度（元素个数）。

tuple_var = (4, 1, 2, 6, 9)

print(len(tuple_var))  # 5

9.5 sum()

返回元组中所有元素（数值型）的总和。

tuple_var = (4, 1, 2, 6, 9)

print(sum(tuple_var))  # 22

10. 总结

综上所述，元组是不可变、有序且可索引的异构元素集合。它可以带圆括号编写，也可以不带（但建议带上）。

元组对于创建对象类型和实例非常有用。元组支持类似于 list 类型的操作，主要区别在于我们不能更改元组中的元素。

学习愉快！

说明：本文内容基于 Python 3 版本。部分内置函数（如 sorted）返回的是列表而非元组，使用时请注意数据类型转换。