9.1 元组的定义（掌握）

元组是一种有序的、不可变的数据结构，可以存储多个元素。与列表类似，元组可以包含任意数据类型，但元组一旦创建，不能修改。元组使用小括号 () 表示，元素之间用逗号分隔。

• 定义元组：

  empty_tuple = ()                    # 空元组
  single_element_tuple = (42,)        # 单个元素的元组，需在元素后加逗号
  numbers = (1, 2, 3, 4, 5)           # 包含多个元素的元组
  mixed_tuple = (1, "hello", 3.14)    # 包含不同数据类型的元组

9.2 元组的基本操作（掌握）

虽然元组是不可变的，但我们可以通过索引和切片访问其中的元素。

9.2.1 访问元组元素

• 使用索引访问元组中的单个元素，索引从 0 开始，支持负索引。

  numbers = (1, 2, 3, 4, 5)
  print(numbers[0])       # 输出 1
  print(numbers[-1])      # 输出 5（最后一个元素）

9.2.2 元组切片

• 使用切片获取元组中的一部分，格式为 元组[起始:结束:步长]。

  numbers = (1, 2, 3, 4, 5)
  print(numbers[1:4])     # 输出 (2, 3, 4)
  print(numbers[:3])      # 输出 (1, 2, 3)
  print(numbers[::2])     # 输出 (1, 3, 5)
  print(numbers[::-1])    # 输出 (5, 4, 3, 2, 1)（元组反转）

9.2.3 元组长度

• 使用 len() 函数获取元组的长度。

  numbers = (1, 2, 3, 4, 5)
  print(len(numbers))      # 输出 5

9.3 元组的常用方法（掌握）

元组提供的内置方法不多，主要用于基本操作，如统计元素出现次数和查找元素索引。

9.3.1 count()：统计元素出现次数

• 使用 count(element) 方法统计指定元素在元组中出现的次数。

  numbers = (1, 2, 2, 3, 4)
  print(numbers.count(2))  # 输出 2

9.3.2 index()：查找元素的索引

• 使用 index(element) 方法返回指定元素在元组中的第一个匹配索引。如果元素不存在，会引发 ValueError。

  numbers = (1, 2, 3, 4)
  print(numbers.index(3))  # 输出 2

9.4 元组的不可变性（掌握）

元组的不可变性是其最重要的特性。元组一旦创建，元素就不能被修改、添加或删除。这一特性使元组在需要不可变数据时特别有用，例如作为函数返回多个值或将元组作为字典的键。

• 示例：

  numbers = (1, 2, 3)
  # numbers[0] = 10  # 会引发 TypeError，因为元组不可变

9.5 元组解包（掌握）

元组解包是一种将元组中的元素直接赋值给多个变量的方式，非常方便。

• 示例：

  coordinates = (10, 20)
  x, y = coordinates
  print(x)  # 输出 10
  print(y)  # 输出 20

• 应用场景：当一个函数返回多个值时，可以直接解包到多个变量中。

  def get_point():
      return (5, 10)
  
  x, y = get_point()
  print(x, y)  # 输出 5 10

9.6 元组的嵌套（掌握）

元组可以包含其他元组，形成嵌套结构，适合表示多维数据或层级结构的数据。

• 示例：

  nested_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
  print(nested_tuple[1][2])   # 输出 6，访问第2行第3列

9.7 元组与列表的转换（掌握）

在 Python 中可以使用 tuple() 和 list() 进行元组与列表的相互转换，方便在需要可变或不可变数据时灵活切换。

• 列表转换为元组：

  numbers_list = [1, 2, 3]
  numbers_tuple = tuple(numbers_list)
  print(numbers_tuple)        # 输出 (1, 2, 3)

• 元组转换为列表：

  numbers_tuple = (1, 2, 3)
  numbers_list = list(numbers_tuple)
  print(numbers_list)         # 输出 [1, 2, 3]

9.8 元组的使用场景（掌握）

由于元组不可变，且比列表更高效，因此在以下场景中更适合使用元组：

1. 多值返回：函数返回多个值时，可以将它们放在一个元组中。
2. 字典键：元组可以作为字典的键（因为元组是不可变类型），而列表不行。
3. 不需要修改的数据：当数据不需要修改时，用元组可以避免数据被意外改变，提高代码的安全性和可读性。

• 示例：函数返回多个值：

  def get_person_info():
      name = "aini"
      age = 23
      return name, age  # 返回一个包含多个值的元组
  
  info = get_person_info()
  print(info)            # 输出 ('aini', 23)

9.9 元组的拷贝（了解）

元组的拷贝通常不需要特别处理，因为元组是不可变的，直接赋值就是拷贝。拷贝只是创建了新的引用，指向相同的内存地址。

• 示例：

  original_tuple = (1, 2, 3)
  copy_tuple = original_tuple
  print(copy_tuple is original_tuple)   # 输出 True，两个变量指向相同对象

9.10 元组的优点和局限性（了解）

9.10.1 优点

• 不可变性：确保数据的安全性，不会被意外修改。
• 高效：因为不可变，元组的性能比列表略高，尤其是在迭代和存储方面。
• 适合作为键：可以作为字典的键，而列表不能。

9.10.2 局限性

• 不可变：无法修改、添加或删除元素。
• 方法少：元组只提供了 count() 和 index() 两个方法，功能相对有限。