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：结束索引（不包含）。
• 下标索引从 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]]

 列表有哪些特点呢？

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 语句。

遍历列表：使用 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. 性能

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

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

浅浅总结一下吧：