Python 列表与元组的区别及常用操作

索引越界

如果尝试访问一个不存在的索引，Python 会抛出 IndexError 异常。

my_list = [10, 20, 30]
# 尝试访问不存在的索引
print(my_list[3])  # 报错：IndexError: list index out of range

什么是列表

在 Python 中，**列表（List）**是一种有序的、可变的序列类型，用于存储一组元素。列表用方括号 [] 定义，元素之间用逗号分隔。列表中的元素可以是任意类型（如整数、字符串、布尔值、甚至其他列表等），并且同一个列表中的元素可以是不同类型的。

列表的定义语法

# 定义一个空列表
empty_list = []
# 定义一个包含整数的列表
numbers = [1, 2, 3, 4, 5]
# 定义一个包含不同类型元素的列表
mixed_list = [1, "Hello", 3.14, True]
# 定义一个嵌套列表（列表中的元素也是列表）
nested_list = [[1, 2], [3, 4], [5, 6]]

列表有哪些特点呢？

1. 有序性：列表中的元素是有序的，每个元素都有一个固定的位置（索引），索引从 0 开始。
2. 可变性：列表是可变的（mutable），可以动态地添加、删除或修改元素。
3. 元素类型多样性：列表中的元素可以是任意类型，甚至可以是不同类型的混合。
4. 支持重复元素：列表中可以包含重复的元素。

示例代码：

# 定义一个包含字符串的列表
fruits = ["apple", "banana", "cherry"]
# 定义一个包含不同类型元素的列表
mixed_list = [42, "Python", 3.14, True]
# 定义一个嵌套列表
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
# 访问列表中的元素
print(fruits[0])       # 输出：apple
print(matrix[1][2])    # 输出：6

列表的常见操作

1. 访问元素：通过索引访问列表中的元素。
2. 修改元素：通过索引直接修改列表中的元素。
3. 添加元素：使用 append()、insert() 或 extend() 方法。
4. 删除元素：使用 remove()、pop() 或 del 语句。
5. 遍历列表：使用 for 循环遍历列表中的元素。

访问列表元素

列表中的元素可以通过下标索引访问，索引从 0 开始。

修改列表元素

列表是可变的，可以通过索引直接修改元素。

添加元素

• append()：在列表末尾添加一个元素。
• insert()：在指定位置插入一个元素。
• extend()：将另一个列表的所有元素添加到当前列表末尾。

my_list = [1, 2, 3]
# 添加元素
my_list.append(4)      # [1, 2, 3, 4]
# 在索引 1 处插入元素
my_list.insert(1, 99)  # [1, 99, 2, 3, 4]
# 扩展列表
my_list.extend([5, 6]) # [1, 99, 2, 3, 4, 5, 6]

删除元素

• remove()：删除列表中第一个匹配的元素。
• pop()：删除并返回指定索引的元素（默认删除最后一个元素）。
• index()：返回指定元素的索引。
• in 关键字：检查元素是否存在于列表中。
• del：通过索引删除元素。

my_list = [10, 20, 30, 40, 50]
# 删除值为 20 的元素
my_list.remove(20)     # [10, 30, 40, 50]
# 删除并返回最后一个元素
last_element = my_list.pop()  # last_element = 50, my_list = [10, 30, 40]
# 删除索引 1 处的元素
del my_list[1]         # [10, 40]

查找元素

使用 index() 方法查找元素索引，或使用 in 判断存在性。

什么是元组

在 Python 中，**元组（Tuple）**是一种有序的、不可变的序列类型，用于存储一组元素。元组用圆括号 () 定义，元素之间用逗号分隔。元组与列表类似，但元组是不可变的（immutable），这意味着一旦创建，就不能修改元组中的元素。

元组的定义语法：

# 定义一个空元组
empty_tuple = ()
# 定义一个包含整数的元组
numbers = (1, 2, 3, 4, 5)
# 定义一个包含不同类型元素的元组
mixed_tuple = (1, "Hello", 3.14, True)
# 定义一个嵌套元组（元组中的元素也是元组）
nested_tuple = ((1, 2), (3, 4), (5, 6))

元组的特点

• 有序性
• 不可变性
• 元素类型多样性
• 支持重复元素

元组的常见操作

访问元组元素

元组中的元素可以通过下标索引访问，索引从 0 开始。

元组的切片

元组支持切片操作，可以获取子元组。

元组的遍历

可以使用 for 循环遍历元组中的每个元素。

元组与列表有什么区别

1. 可变性

• 列表（List）：是可变的（mutable），可以动态地添加、删除或修改元素。
• 元组（Tuple）：是不可变的（immutable），一旦创建，就不能修改元组中的元素。

示例：

# 列表是可变的
my_list = [1, 2, 3]
my_list[1] = 99        # 修改元素
my_list.append(4)      # 添加元素
print(my_list)         # 输出：[1, 99, 3, 4]

# 元组是不可变的
my_tuple = (1, 2, 3)
my_tuple[1] = 99       # 报错：TypeError: 'tuple' object does not support item assignment

2. 语法

• 列表：用方括号 [] 定义。
• 元组：用圆括号 () 定义。

# 列表
my_list = [1, 2, 3]
# 元组
my_tuple = (1, 2, 3)

3. 性能

• 列表：由于列表是可变的，它的存储和操作（如添加、删除元素）会占用更多的内存和计算资源。
• 元组：由于元组是不可变的，它的存储和访问速度比列表更快，适合存储不需要修改的数据。