python的列表和元组别再傻傻分不清啦

在Python中，下标索引（也称为索引）用于访问序列类型（如字符串、列表、元组等）中的单个元素。Python的索引从 0 开始，即第一个元素的索引是 0，第二个元素的索引是 1，依此类推。此外，Python还支持负数索引，从序列的末尾开始计数，-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。

正数索引：正数索引从左到右，从 `0` 开始。

my_list = [10, 20, 30, 40, 50] # 访问第一个元素 print(my_list[0]) # 输出: 10 # 访问第三个元素 print(my_list[2]) # 输出: 30

负数索引：负数索引从右到左，从 `-1` 开始。

my_list = [10, 20, 30, 40, 50] # 访问最后一个元素 print(my_list[-1]) # 输出: 50 # 访问倒数第二个元素 print(my_list[-2]) # 输出: 40

切片（slice）：除了单个元素，Python还支持通过切片访问序列的子集。

切片的语法是 [start:stop:step]：

start：起始索引（包含）。
stop：结束索引（不包含）。
下标索引从 0 开始。
负数索引从 -1 开始，表示从末尾开始计数。
切片 [start:stop:step] 可以获取子序列。

索引越界会抛出 IndexError。

~~索引是从0开始的，就先我们零基础的小白，从0到1的过程。~~

什么是列表：

step：步长（可选，默认为1）。

my_list = [10, 20, 30, 40, 50] # 获取索引1到3的元素（不包含索引3） print(my_list[1:3]) # 输出: [20, 30] # 获取从开始到索引3的元素 print(my_list[:3]) # 输出: [10, 20, 30] # 获取从索引2到末尾的元素 print(my_list[2:]) # 输出: [30, 40, 50] # 使用步长2 print(my_list[::2]) # 输出: [10, 30, 50] # 反转列表 print(my_list[::-1]) # 输出: [50, 40, 30, 20, 10]

索引越界：如果尝试访问一个不存在的索引，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]]

列表有哪些特点呢？

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

示例代码：

# 定义一个包含字符串的列表 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

列表的常见操作：

访问元素：通过索引访问列表中的元素。
修改元素：通过索引直接修改列表中的元素。
添加元素：使用 append()、insert() 或 extend() 方法。
删除元素：使用 remove()、pop() 或 del 语句。

遍历列表：使用 for 循环遍历列表中的元素。

接下来我们将详细介绍这些操作：

访问列表元素

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

修改列表元素

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

添加元素

append()：在列表末尾添加一个元素。
insert()：在指定位置插入一个元素。
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]

查找元素

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]

删除元素

什么是元组：

在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 开始

2. 元组的切片

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

3. 元组的遍历

可以使用 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. 性能

列表：由于列表是可变的，它的存储和操作（如添加、删除元素）会占用更多的内存和计算资源。

元组：由于元组是不可变的，它的存储和访问速度比列表更快，适合存储不需要修改的数据。

浅浅总结一下吧：