python的列表和元组别再傻傻分不清啦
目录
什么是下标：
正数索引：正数索引从左到右，从 0 开始。
负数索引：负数索引从右到左，从 -1 开始。
切片（slice）：除了单个元素，Python还支持通过切片访问序列的子集。
索引越界：如果尝试访问一个不存在的索引，Python会抛出 IndexError 异常。
总结一下子吧：
什么是列表：
列表的定义语法：
列表有哪些特点呢？
列表的常见操作：
访问列表元素
修改列表元素
添加元素
删除元素
查找元素
什么是元组：
元组的特点：编辑
元组的常见操作：
访问元组元素：
2. 元组的切片
3. 元组的遍历
元组与列表有什么区别：
1. 可变性
2. 语法
3. 性能
什么是下标：
在学习之前，我们先了解一下什么是下标：
在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：结束索引（不包含）。 -
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总结一下子吧：
-
下标索引从
0开始。 -
负数索引从
-1开始，表示从末尾开始计数。 -
切片
[start:stop:step]可以获取子序列。 -
索引越界会抛出
IndexError。
索引是从0开始的，就先我们零基础的小白，从0到1的过程。
什么是列表：
在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()：在指定位置插入一个元素。 -
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()：删除并返回指定索引的元素（默认删除最后一个元素）。 -
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 开始
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. 性能
-
列表：由于列表是可变的，它的存储和操作（如添加、删除元素）会占用更多的内存和计算资源。
-
元组：由于元组是不可变的，它的存储和访问速度比列表更快，适合存储不需要修改的数据。
浅浅总结一下吧： 