【Python入门第八讲】不可变的列表

元组

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。 Python将不能修改的值称为不可变的，而不可变的列表被称为元组。

请在此添加图片描述

定义元组

_元组（Tuple）_是 Python 中的一种不可改变的数据类型，类似于列表，但元组中的元素不能被修改一旦创建。元组使用圆括号 () 定义，而不是方括号。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

例如，如果有一个大小不应改变的矩形，可将其长度和宽度存储在一个元组中，从而确保它们是不能修改的：

下面是一个关于矩形大小的元组的示例：

python"># 定义矩形大小的元组
rectangle_size = (10, 5)# 访问元组的元素
length = rectangle_size[0]
width = rectangle_size[1]print(f"The rectangle has a length of {length} and a width of {width}.")
# 输出: The rectangle has a length of 10 and a width of 5.

在这个例子中，rectangle_size 是一个包含两个元素的元组，分别表示矩形的长度和宽度。通过索引访问元组的元素，可以获取矩形的长度和宽度。元组一旦创建，其元素就不可修改。

元组示例

python"># 创建一个元组
my_tuple = (1, 2, 3, 'hello', 3.14)# 访问元组元素
print(my_tuple[0])  # 输出: 1
print(my_tuple[3])  # 输出: 'hello'# 获取元组长度
length = len(my_tuple)
print(length)  # 输出: 5

元组的不可修改性使其适用于存储在整个程序生命周期内不应更改的数据集合。如果需要一个保持不变的有序集合，可以使用元组。

特性

不可变性（Immutable）： 元组一旦创建，其元素不可被修改、添加或删除。这意味着你不能通过索引或方法改变元组的内容。
有序性： 元组是有序的，即元素的顺序是有意义的，并且可以通过索引访问。
可以包含不同类型的元素： 一个元组中可以包含不同类型的元素，例如整数、字符串、浮点数等。
支持嵌套： 元组中的元素可以是其他元组，实现嵌套结构。
使用圆括号定义： 元组通过圆括号 () 定义，元素之间使用逗号 , 分隔。

元组常用于表示一组相关的值，例如坐标、日期、配置项等。其不可变性使其适用于那些不应该被修改的场景，同时也提供了一些性能上的优势。

基本操作符

连接： 使用 + 号可以连接两个元组，生成一个新的元组。

python">tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
result = tuple1 + tuple2
print(result)  # 输出: (1, 2, 3, 'a', 'b', 'c')

重复： 使用 * 号可以重复一个元组多次。

python">tuple1 = (1, 2, 3)
result = tuple1 * 3
print(result)  # 输出: (1, 2, 3, 1, 2, 3, 1, 2, 3)

成员关系： 使用 in 或 not in 判断元素是否在元组中。

python">tuple1 = (1, 2, 3)
print(2 in tuple1)   # 输出: True
print('a' not in tuple1)  # 输出: True

元组切片：[index:index]遵循左闭右开原则。

元组支持切片操作，这使得你可以获取元组中的一部分元素。切片的语法为 start:stop:step，其中：

start 表示切片的起始索引（包含该位置的元素）。
stop 表示切片的结束索引（不包含该位置的元素）。
step 表示切片的步长（每隔多少个元素取一个）。

例子：

python">my_tuple = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)# 获取索引 2 到 5 的切片
slice1 = my_tuple[2:6]
print(slice1)  # 输出: (2, 3, 4, 5)# 获取索引 0 到 9 的切片，步长为 2
slice2 = my_tuple[0:10:2]
print(slice2)  # 输出: (0, 2, 4, 6, 8)# 获取整个元组的切片，步长为 3
slice3 = my_tuple[::3]
print(slice3)  # 输出: (0, 3, 6, 9)# 逆序获取元组的切片
reverse_slice = my_tuple[::-1]
print(reverse_slice)  # 输出: (9, 8, 7, 6, 5, 4, 3, 2, 1, 0)

常用的方法

count方法：

返回指定值在元组中出现的次数。

python">my_tuple = (1, 2, 3, 1, 4, 1, 5)
count_ones = my_tuple.count(1)
print(count_ones)  # 输出: 3

index方法：

返回指定值在元组中第一次出现的索引。

python">my_tuple = (1, 2, 3, 1, 4, 1, 5)
index_4 = my_tuple.index(4)
print(index_4)  # 输出: 4

这两个方法允许你在元组中查找特定值的信息。由于元组的不可变性，其他修改元组内容的方法相对较少。

魔法方法

在Python中，魔法方法是一种特殊的方法，其名称以双下划线开头和结尾，如__method__。这些方法在特定的情况下由解释器自动调用，可以为类提供一些特殊行为。下面是tuple类中一些常用的魔法方法：

`add`方法：

实现元组的合并，使用 + 运算符。

python">tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
result = tuple1.__add__(tuple2)
print(result)  # 输出: (1, 2, 3, 4, 5, 6)

`mul`方法：

实现元组的重复，使用 * 运算符。

python">tuple1 = (1, 2, 3)
result = tuple1.__mul__(3)
print(result)  # 输出: (1, 2, 3, 1, 2, 3, 1, 2, 3)

`len`方法：

返回元组中元素的个数，使用 len() 函数。

python">tuple1 = (1, 2, 3, 4, 5)
length = tuple1.__len__()
print(length)  # 输出: 5

`getitem`方法：

获取指定索引位置的元素，使用 [] 运算符。

python">tuple1 = (1, 2, 3, 4, 5)
element = tuple1.__getitem__(2)
print(element)  # 输出: 3

这些魔法方法提供了元组类的一些基本操作的实现方式。在实际编程中，通常直接使用运算符和内置函数而不是调用这些魔法方法。

常用函数和操作

`len(tuple)`：

返回元组中元素的个数。

python">my_tuple = (1, 2, 3, 4, 5)
length = len(my_tuple)
print(length)  # 输出: 5

`max(tuple)`：

返回元组中的最大值。

python">my_tuple = (1, 2, 3, 4, 5)
maximum = max(my_tuple)
print(maximum)  # 输出: 5

`min(tuple)`：

返回元组中的最小值。

python">my_tuple = (1, 2, 3, 4, 5)
minimum = min(my_tuple)
print(minimum)  # 输出: 1

`type(tuple)`：

返回元组的类型。

python">emy_tuple = (1, 2, 3, 4, 5)
tuple_type = type(my_tuple)
print(tuple_type)  # 输出: <class 'tuple'>

`tuple(iterable)`：

将可迭代对象转换为元组。

python">my_list = [1, 2, 3, 4, 5]
converted_tuple = tuple(my_list)
print(converted_tuple)  # 输出: (1, 2, 3, 4, 5)

上面这些函数提供了对元组进行常见操作的便捷方式。