【Python-Day 11】列表入门：Python 中最灵活的数据容器 (创建、索引、切片)

Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南
02-玩转 LangChain Memory 模块：四种记忆类型详解及应用场景全覆盖
03-全面掌握 LangChain：从核心链条构建到动态任务分配的实战指南
04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 掌握 LangChain Agents：自定义工具 + LLM 打造智能工作流！
07-【深度解析】从GPT-1到GPT-4：ChatGPT背后的核心原理全揭秘
08-【万字长文】MCP深度解析：打通AI与世界的“USB-C”，模型上下文协议原理、实践与未来

Python系列文章目录

PyTorch系列文章目录

机器学习系列文章目录

深度学习系列文章目录

Java系列文章目录

JavaScript系列文章目录

Python系列文章目录

01-【Python-Day 1】告别编程恐惧：轻松掌握 Python 安装与第一个程序的 6 个步骤
02-【Python-Day 2】掌握Python基石：变量、内存、标识符及int/float/bool数据类型
03-【Python-Day 3】玩转文本：字符串(String)基础操作详解 (上)
04-【Python-Day 4】玩转文本：Python 字符串常用方法深度解析 (下篇)
05-【Python-Day 5】Python 格式化输出实战：%、format()、f-string 对比与最佳实践
06- 【Python-Day 6】从零精通 Python 运算符（上）：算术、赋值与比较运算全解析
07-【Python-Day 7】从零精通 Python 运算符（下）：逻辑、成员、身份运算与优先级规则全解析
08-【Python-Day 8】从入门到精通：Python 条件判断 if-elif-else 语句全解析
09-【Python-Day 9】掌握循环利器：for 循环遍历序列与可迭代对象详解
10-【Python-Day 10】Python 循环控制流：while 循环详解与 for 循环对比
11-【Python-Day 11】列表入门：Python 中最灵活的数据容器 (创建、索引、切片)

---

---

前言

欢迎来到 Python 学习之旅的第 11 天！在之前的学习中，我们已经掌握了 Python 的基本语法、变量、数据类型、运算符以及控制流语句（if、for、while）。今天，我们将踏入一个全新的领域——数据容器。而在 Python 中，列表（List）无疑是使用最频繁、功能最强大的数据容器之一，堪称“数据容器之王”。本篇作为列表学习的上半部分，将带你深入了解列表的创建与基础操作，为后续更复杂的数据处理打下坚实的基础。无论你是编程新手还是希望巩固基础的进阶者，本文都将为你提供清晰、易懂的讲解和实用的代码示例。

一、初识列表 (List)：Python 中的瑞士军刀

在正式学习列表的操作之前，我们首先需要理解列表究竟是什么，以及它为什么如此重要。

1.1 什么是列表 (List)？

想象一下，你需要记录一周内每天的最高气温，或者一个班级所有学生的姓名，亦或是一个购物清单上的所有商品。如果使用我们之前学过的变量，你可能需要为每个数据都创建一个单独的变量，例如 temp_monday, temp_tuesday… 这样做不仅繁琐，而且难以管理和进行批量操作。

列表（List）就是为了解决这类问题而生的。列表是 Python 中一种内置的数据结构，它是一个有序的、可变的元素序列。

这里有几个关键点需要理解：

• 有序 (Ordered)：列表中的元素是按照它们被添加的顺序排列的，每个元素都有一个固定的位置（索引）。除非你主动修改顺序，否则元素的相对位置不会改变。
• 可变 (Mutable)：这意味着你可以在列表创建之后，随意添加、删除或修改其中的元素。这是列表与我们后续会学到的元组（Tuple）的一个重要区别。
• 序列 (Sequence)：列表可以包含任意数量的元素，这些元素可以是不同数据类型的，例如数字、字符串、布尔值，甚至可以是另一个列表（构成嵌套列表）。

简单来说，列表就像一个可以动态调整大小、可以存放各种物品的货架，你可以随时往上面放东西、取东西、或者调换东西的位置。

1.2 为什么列表如此重要？

列表之所以被称为“数据容器之王”，主要归功于其以下特性：

• 灵活性：可以存储任意类型的数据，并且长度可变。
• 功能强大：Python 提供了丰富的内置方法来操作列表，如添加、删除、排序、查找等。
• 应用广泛：在数据处理、算法实现、Web 开发、数据科学等几乎所有 Python 应用领域，列表都扮演着至关重要的角色。例如，存储用户输入、表示数据库查询结果、管理配置文件等等。

掌握列表是学习 Python 的一个重要里程碑，它将为你打开数据组织与操作的大门。

是

否

是

否

数据集合

是否有序?

是否可变?

其他数据结构, 如集合Set

列表 List

元组 Tuple

图1：Python 序列类型决策示意图

上图简单展示了列表在 Python 数据结构分类中的位置。

二、创建列表：多种方式任你选

理解了列表是什么之后，我们来看看如何在 Python 中创建列表。创建列表的方式非常灵活多样。

2.1 使用方括号 [] 创建

这是创建列表最常见也是最直接的方式，直接将所有元素用逗号 , 分隔，并用方括号 [] 括起来。

2.1.1 创建空列表

如果你需要一个列表，但暂时还没有确定要放入哪些元素，可以先创建一个空列表。

# 创建一个空列表
empty_list = []
print(empty_list)      # 输出: []
print(type(empty_list)) # 输出: 

代码解释：

• empty_list = []：通过一对空的方括号，我们就成功创建了一个不包含任何元素的列表，并将其赋值给变量 empty_list。
• print(type(empty_list))：使用 type() 函数可以验证 empty_list 的确是一个列表类型。

2.1.2 创建包含元素的列表

你可以在创建列表时就初始化它，包含各种数据类型的元素。

# 创建包含数字的列表
numbers = [1, 2, 3, 4, 5]
print(numbers) # 输出: [1, 2, 3, 4, 5]

# 创建包含字符串的列表
fruits = ["apple", "banana", "cherry"]
print(fruits)  # 输出: ['apple', 'banana', 'cherry']

# 创建包含混合数据类型的列表
mixed_list = [10, "hello", True, 3.14]
print(mixed_list) # 输出: [10, 'hello', True, 3.14]

场景驱动：

• 存储一周七天的名称：days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
• 记录学生的考试成绩：scores = [85, 92, 78, 95, 88]

2.2 使用 list() 构造函数创建

除了使用方括号，Python 还提供了 list() 构造函数来创建列表。这个函数可以将其他可迭代对象（如字符串、元组、集合、字典的键等）转换为列表。

2.2.1 将字符串转换为列表

如果将一个字符串传递给 list() 函数，它会将字符串中的每个字符作为独立的元素创建一个新列表。

# 将字符串转换为列表
greeting = "hello"
char_list = list(greeting)
print(char_list) # 输出: ['h', 'e', 'l', 'l', 'o']

代码解释：

• list(greeting)：将字符串 greeting 中的每个字符 ‘h’, ‘e’, ‘l’, ‘l’, ‘o’ 拆分出来，作为列表 char_list 的元素。

2.2.2 将元组转换为列表

元组（Tuple）是另一种有序的序列类型，但它是不可变的。我们可以使用 list() 将元组转换为可变的列表。

# 将元组转换为列表
my_tuple = (1, 2, 3, "a", "b")
tuple_to_list = list(my_tuple)
print(tuple_to_list) # 输出: [1, 2, 3, 'a', 'b']

2.2.3 将 range() 对象转换为列表

range() 函数生成一个数字序列，常用于 for 循环。通过 list() 可以将其直接转换为包含这些数字的列表。

# 将 range 对象转换为列表
num_sequence = range(5) # 生成 0 到 4 的序列
numbers_list = list(num_sequence)
print(numbers_list) # 输出: [0, 1, 2, 3, 4]

even_numbers = list(range(2, 11, 2)) # 生成 2 到 10 之间的偶数
print(even_numbers) # 输出: [2, 4, 6, 8, 10]

实用技巧：
当需要快速生成一个包含特定数字序列的列表时，list(range()) 非常方便。

2.3 列表推导式 (List Comprehension) - 初探

列表推导式是一种更简洁、更 Pythonic 的创建列表的方式，尤其适用于根据某个现有列表或可迭代对象来创建新列表的场景。我们会在后续章节详细讲解列表推导式，这里先简单了解一下它的威力。

# 使用列表推导式创建平方数列表
squares = [x**2 for x in range(1, 6)] # 计算 1 到 5 的平方
print(squares) # 输出: [1, 4, 9, 16, 25]

# 从一个列表筛选出偶数并乘以2
original_numbers = [1, 2, 3, 4, 5, 6]
processed_numbers = [num * 2 for num in original_numbers if num % 2 == 0]
print(processed_numbers) # 输出: [4, 8, 12]

代码解释：

• [x**2 for x in range(1, 6)]：对于 range(1, 6) 中的每一个 x (即 1, 2, 3, 4, 5)，计算 x**2 (平方)，并将结果作为新列表的元素。
• [num * 2 for num in original_numbers if num % 2 == 0]：遍历 original_numbers，如果 num 是偶数 (num % 2 == 0)，则计算 num * 2 并放入新列表。

虽然现在看起来可能有些复杂，但一旦熟悉，列表推导式将大大提高代码的可读性和效率。

三、访问列表元素：精准定位你的数据

创建了列表之后，下一步自然是如何获取或访问列表中的元素。Python 列表的元素是通过索引 (Index) 来访问的，索引代表了元素在列表中的位置。

3.1 正向索引 (Positive Indexing)

Python 中的索引是从 0 开始的，这意味着列表的第一个元素的索引是 0，第二个元素的索引是 1，以此类推。

my_list = ["Python", "Java", "C++", "JavaScript", "Go"]
# 索引:    0         1        2         3           4

# 访问第一个元素
first_element = my_list[0]
print(f"第一个元素是: {first_element}") # 输出: 第一个元素是: Python

# 访问第三个元素
third_element = my_list[2]
print(f"第三个元素是: {third_element}") # 输出: 第三个元素是: C++

# 访问最后一个元素 (假设知道列表长度)
last_element_by_length = my_list[len(my_list) - 1]
print(f"通过长度计算的最后一个元素是: {last_element_by_length}") # 输出: 通过长度计算的最后一个元素是: Go

代码解释：

• my_list[0]：通过方括号加上索引号 0，我们访问了列表 my_list 的第一个元素。
• len(my_list)：len() 函数返回列表的长度（元素个数）。由于索引从 0 开始，所以最后一个元素的索引是 长度 - 1。

常见问题：索引越界 (IndexError)
如果尝试访问一个不存在的索引，Python 会抛出 IndexError 异常。

# 错误示例：尝试访问不存在的索引
# print(my_list[5]) # 这行会报错: IndexError: list index out of range

因此，在访问列表元素时，要确保索引值在合法的范围内 (从 0 到 len(list) - 1)。

3.2 反向索引 (Negative Indexing)

除了从前往后数，Python 还支持从后往前数的反向索引。反向索引非常方便，尤其是当你需要访问列表末尾的元素时，而不知道列表确切长度。

• 最后一个元素的索引是 -1。
• 倒数第二个元素的索引是 -2，以此类推。

my_list = ["Python", "Java", "C++", "JavaScript", "Go"]
# 正向索引: 0         1        2         3           4
# 反向索引:-5        -4       -3        -2          -1

# 访问最后一个元素
last_element = my_list[-1]
print(f"最后一个元素是: {last_element}") # 输出: 最后一个元素是: Go

# 访问倒数第二个元素
second_last_element = my_list[-2]
print(f"倒数第二个元素是: {second_last_element}") # 输出: 倒数第二个元素是: JavaScript

实用性：
反向索引使得访问列表尾部元素变得非常简洁，无需计算 len(my_list) - n。

四、列表切片 (Slicing)：灵活截取子列表

如果我们想获取列表中的一部分元素，而不是单个元素，就需要用到切片 (Slicing) 操作。切片可以从列表中提取出一个新的子列表。

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

• start：切片开始的索引（包含该索引对应的元素）。如果省略，则默认为 0（列表的开头）。
• stop：切片结束的索引（不包含该索引对应的元素）。如果省略，则默认为列表的长度（切到列表末尾）。
• step：步长，表示每隔多少个元素取一个。如果省略，则默认为 1（连续取元素）。

切片操作返回的是一个新的列表，即使它只包含一个元素或为空。

4.1 基本切片操作

4.1.1 指定 start 和 stop

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 索引:    0, 1, 2, 3, 4, 5, 6, 7, 8, 9

# 获取索引 1 到索引 3 的元素 (即第 2、3、4 个元素)
sub_list1 = numbers[1:4]
print(f"numbers[1:4] -> {sub_list1}") # 输出: numbers[1:4] -> [1, 2, 3]
# 解释: 从索引 1 开始，到索引 4 之前结束

# 获取索引 0 到索引 4 的元素 (即前 5 个元素)
sub_list2 = numbers[0:5]
print(f"numbers[0:5] -> {sub_list2}") # 输出: numbers[0:5] -> [0, 1, 2, 3, 4]

4.1.2 省略 start

如果省略 start，切片将从列表的开头开始。

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取从开头到索引 4 的元素 (不包括索引 5)
first_five = numbers[:5]
print(f"numbers[:5] -> {first_five}") # 输出: numbers[:5] -> [0, 1, 2, 3, 4]

4.1.3 省略 stop

如果省略 stop，切片将一直到列表的末尾。

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取从索引 5 到末尾的元素
from_index_5 = numbers[5:]
print(f"numbers[5:] -> {from_index_5}") # 输出: numbers[5:] -> [5, 6, 7, 8, 9]

4.1.4 同时省略 start 和 stop

如果同时省略 start 和 stop (my_list[:])，会得到整个列表的一个浅拷贝 (shallow copy)。这是一种快速复制列表的方法。

numbers = [0, 1, 2, 3, 4]
copy_of_numbers = numbers[:]
print(f"numbers[:] -> {copy_of_numbers}") # 输出: numbers[:] -> [0, 1, 2, 3, 4]
print(f"numbers is copy_of_numbers: {numbers is copy_of_numbers}") # 输出: False (它们是不同的对象)
print(f"numbers == copy_of_numbers: {numbers == copy_of_numbers}") # 输出: True (它们的内容相同)

4.2 使用步长 step

步长 step 控制切片时元素的选取间隔。

4.2.1 正向步长

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 从索引 0 到索引 8，每隔 2 个元素取一个
every_other = numbers[0:9:2]
print(f"numbers[0:9:2] -> {every_other}") # 输出: numbers[0:9:2] -> [0, 2, 4, 6, 8]

# 获取所有偶数索引的元素
even_indexed_elements = numbers[::2] # start 和 stop 省略，步长为 2
print(f"numbers[::2] -> {even_indexed_elements}") # 输出: numbers[::2] -> [0, 2, 4, 6, 8]

4.2.2 反向步长 (实现列表反转)

当 step 为负数时，切片会从右向左进行。一个常见的用途是反转列表。

my_list = ["a", "b", "c", "d", "e"]

# 反转整个列表
reversed_list = my_list[::-1]
print(f"my_list[::-1] -> {reversed_list}") # 输出: my_list[::-1] -> ['e', 'd', 'c', 'b', 'a']

# 从索引 3 反向取到索引 1 (不包括索引 0)，步长为 -1
sub_reversed = my_list[3:0:-1]
print(f"my_list[3:0:-1] -> {sub_reversed}") # 输出: my_list[3:0:-1] -> ['d', 'c', 'b']
# 解释: 从 my_list[3] ('d') 开始，向左取，直到 my_list[0] 之前

场景驱动：

• 获取字符串 “Python” 的前三个字符：lang = "Python", lang_list = list(lang), prefix = lang_list[:3] 结果 ['P', 'y', 't']。
• 获取一个成绩列表的后五个成绩：scores = [70, 85, 90, 65, 95, 88, 76], last_five = scores[-5:] 结果 [90, 65, 95, 88, 76]。

4.3 切片中的越界处理

与索引不同，切片操作对于超出范围的 start 或 stop 值具有更强的容错性。它不会抛出 IndexError，而是会尽其所能返回一个合法的切片结果。

numbers = [0, 1, 2, 3, 4]

# start 超出左边界
print(numbers[-10:3]) # 输出: [0, 1, 2] (等同于 numbers[0:3])

# stop 超出右边界
print(numbers[2:10])  # 输出: [2, 3, 4] (等同于 numbers[2:len(numbers)])

# start 和 stop 都超出边界，但方向正确
print(numbers[-10:10]) # 输出: [0, 1, 2, 3, 4] (等同于 numbers[:])

# start 在 stop 右边 (对于正向步长)，返回空列表
print(numbers[3:1])   # 输出: []

这种容错性使得切片在某些情况下更易于使用，不必过分担心边界条件。

五、修改列表元素：动态更新数据

列表的一个核心特性就是它的可变性 (mutability)。这意味着我们可以在列表创建后，通过索引来修改其中特定位置的元素。

5.1 修改单个元素

可以直接通过索引赋值的方式修改列表中的某个元素。

colors = ["red", "green", "blue"]
print(f"修改前: {colors}") # 输出: 修改前: ['red', 'green', 'blue']

# 修改第二个元素 (索引为 1)
colors[1] = "yellow"
print(f"修改后: {colors}") # 输出: 修改后: ['red', 'yellow', 'blue']

# 使用反向索引修改最后一个元素
colors[-1] = "purple"
print(f"再次修改后: {colors}") # 输出: 再次修改后: ['red', 'yellow', 'purple']

代码解释：

• colors[1] = "yellow"：将列表 colors 中索引为 1 的元素（原来的 “green”）替换为 “yellow”。

注意：如果尝试为不存在的索引赋值（即索引越界），同样会引发 IndexError。

# 错误示例：尝试修改不存在的索引
# colors[3] = "orange" # 这行会报错: IndexError: list assignment index out of range

要添加新元素，应该使用列表的 append() 或 insert() 方法 (我们将在下一篇文章中详细介绍)。

5.2 通过切片修改多个元素

更强大的是，我们还可以使用切片来一次性修改列表中的多个元素。赋值的右侧可以是一个新的列表，其元素数量可以与被替换的切片部分不同。

5.2.1 替换等长切片

如果赋值的列表元素数量与切片指定的元素数量相同，则相当于逐个替换。

letters = ['a', 'b', 'c', 'd', 'e', 'f']
print(f"原始列表: {letters}") # 输出: 原始列表: ['a', 'b', 'c', 'd', 'e', 'f']

# 将索引 1 到 3 的元素 (即 'b', 'c', 'd') 替换为 ['B', 'C', 'D']
letters[1:4] = ['B', 'C', 'D']
print(f"替换后: {letters}") # 输出: 替换后: ['a', 'B', 'C', 'D', 'e', 'f']

5.2.2 替换不等长切片 (实现插入或删除效果)

如果赋值的列表元素数量与切片指定的元素数量不同，列表的长度会发生改变。

numbers = [10, 20, 30, 40, 50]
print(f"原始列表: {numbers}") # 输出: 原始列表: [10, 20, 30, 40, 50]

# 用一个新列表替换索引 1 和 2 的元素 (即 20, 30)
# 切片 [20, 30] 被替换为 [21, 22, 23]
numbers[1:3] = [21, 22, 23]
print(f"用更长的列表替换后: {numbers}") # 输出: 用更长的列表替换后: [10, 21, 22, 23, 40, 50]
# 列表长度从 5 变为 6

# 用一个更短的列表替换索引 2 到 4 的元素 (即 22, 23, 40)
# 切片 [22, 23, 40] 被替换为 [99]
numbers[2:5] = [99]
print(f"用更短的列表替换后: {numbers}") # 输出: 用更短的列表替换后: [10, 21, 99, 50]
# 列表长度从 6 变为 4

5.2.3 通过切片删除元素

可以将一个空列表 [] 赋值给一个切片，从而删除该切片对应的所有元素。

items = ['item1', 'item2', 'item3', 'item4', 'item5']
print(f"原始列表: {items}") # 输出: 原始列表: ['item1', 'item2', 'item3', 'item4', 'item5']

# 删除索引 1 和 2 的元素 (即 'item2', 'item3')
items[1:3] = []
print(f"删除部分元素后: {items}") # 输出: 删除部分元素后: ['item1', 'item4', 'item5']

这与使用 del 关键字删除切片的效果类似 (我们会在下篇讨论 del)。

六、列表嵌套：列表中的列表

列表的强大之处还在于它的元素可以是任何数据类型，包括另一个列表。当一个列表的元素本身也是列表时，就形成了嵌套列表 (Nested List)，也常被称为二维列表或多维列表（如果嵌套更深）。

6.1 创建嵌套列表

创建嵌套列表与创建普通列表的方式相同，只是将列表作为元素放入外部列表中。

# 一个简单的嵌套列表
nested_list = [1, 2, ["a", "b", "c"], 4]
print(nested_list) # 输出: [1, 2, ['a', 'b', 'c'], 4]

# 表示一个简单的 2x3 矩阵
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(matrix)
# 输出:
# [[1, 2, 3],
#  [4, 5, 6],
#  [7, 8, 9]]

场景驱动：

• 表示井字棋棋盘状态：board = [['X', 'O', ''], ['O', 'X', ''], ['', '', 'X']]
• 存储学生的多个科目成绩：student_grades = [["Math", 90], ["Science", 85], ["English", 92]]

6.2 访问嵌套列表中的元素

要访问嵌套列表中的元素，你需要使用多个索引。第一个索引定位到外部列表中的内部列表，第二个索引定位到该内部列表中的具体元素。

matrix = [
    [1, 2, 3],  # 外部列表的索引 0
    [4, 5, 6],  # 外部列表的索引 1
    [7, 8, 9]   # 外部列表的索引 2
]

# 访问第一行 (索引 0)
first_row = matrix[0]
print(f"第一行: {first_row}") # 输出: 第一行: [1, 2, 3]

# 访问第一行的第一个元素 (matrix[0][0])
element_00 = matrix[0][0]
print(f"matrix[0][0]: {element_00}") # 输出: matrix[0][0]: 1

# 访问第二行的第三个元素 (matrix[1][2])
element_12 = matrix[1][2]
print(f"matrix[1][2]: {element_12}") # 输出: matrix[1][2]: 6

# 访问 nested_list 中的 'b'
nested_list = [1, 2, ["a", "b", "c"], 4]
# 内部列表 ["a", "b", "c"] 在 nested_list 中的索引是 2
# 'b' 在内部列表中的索引是 1
char_b = nested_list[2][1]
print(f"nested_list[2][1]: {char_b}") # 输出: nested_list[2][1]: b

代码解释：

• matrix[0]：获取 matrix 列表的第一个元素，即内部列表 [1, 2, 3]。
• matrix[0][0]：先通过 matrix[0] 得到内部列表 [1, 2, 3]，然后再对这个内部列表使用索引 [0]，得到元素 1。

嵌套列表在处理表格数据、矩阵运算、游戏棋盘等场景中非常有用。随着嵌套层数的增加，访问元素所需的索引也会相应增加。

七、总结

在本篇文章中，我们对 Python 中的列表 (List) 进行了初步的探索，重点学习了其基础特性和操作：

1. 列表的定义：列表是一种有序、可变的序列，可以包含不同类型的元素。它是 Python 中最常用的数据结构之一。
2. 创建列表：
   • 使用方括号 []：如 my_list = [1, "hello", True] 或空列表 []。
   • 使用 list() 构造函数：可以将字符串、元组等可迭代对象转换为列表，如 list("abc") 结果为 ['a', 'b', 'c']。
   • 初步了解了列表推导式（后续会详细学习）。
3. 访问列表元素：
   • 正向索引：从 0 开始，如 my_list[0] 访问第一个元素。
   • 反向索引：从 -1 开始，如 my_list[-1] 访问最后一个元素。
   • 需要注意 IndexError，避免访问不存在的索引。
4. 列表切片 (Slicing)：
   • 语法 my_list[start:stop:step]，用于获取列表的子集。
   • start 默认为 0，stop 默认为列表末尾，step 默认为 1。
   • 切片返回的是一个新列表。
   • 负数步长可以实现反向切片，如 my_list[::-1] 反转列表。
   • 切片操作对越界索引具有容错性。
5. 修改列表元素：
   • 通过索引赋值来修改单个元素：my_list[index] = new_value。
   • 通过切片赋值来修改多个元素：my_list[start:stop] = new_iterable，可以改变列表长度。
6. 列表嵌套：
   • 列表的元素可以是另一个列表，形成嵌套结构。
   • 访问嵌套列表元素需要使用多级索引，如 nested_list[outer_index][inner_index]。

通过今天的学习，你已经掌握了列表的基本骨架。列表的强大之处远不止于此，在下一篇文章【Python-Day 12】数据容器之王 - 列表 (List) 详解 (下) 中，我们将继续深入学习列表的常用方法，如添加元素、删除元素、排序、查找等，以及更高级的列表推导式。敬请期待！

---