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 的一個重要里程碑，它將為你打開數據組織與操作的大門。

<center>圖1：Python 序列類型決策示意圖</center>

上圖簡單展示了列表在 Python 數據結構分類中的位置。

二、創建列表：多種方式任你選

理解了列表是什么之后，我們來看看如何在 Python 中創建列表。創建列表的方式非常靈活多樣。

2.1 使用方括號 [] 創建

這是創建列表最常見也是最直接的方式，直接將所有元素用逗號 , 分隔，并用方括號 [] 括起來。

2.1.1 創建空列表

如果你需要一個列表，但暫時還沒有確定要放入哪些元素，可以先創建一個空列表。

# 創建一個空列表
empty_list = []
print(empty_list)      # 輸出: []
print(type(empty_list)) # 輸出: <class '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) 詳解 (下) 中，我們將繼續深入學習列表的常用方法，如添加元素、刪除元素、排序、查找等，以及更高級的列表推導式。敬請期待！

---