1. 前言
Python 是一種非常受歡迎的程式語言，具有簡潔易懂的語法與豐富的函式庫。其中的「串列（List）」是處理與管理資料時最常用的資料型別之一。串列可以一次處理多個資料，是進行 Python 開發時不可或缺的工具。
尤其是將多個串列合併成一個「串列合併」操作，是提升資料處理效率的基本技巧之一。若能正確理解這個操作，將大幅提升資料處理速度與程式碼的簡潔性。
本文將詳細介紹在 Python 中進行串列合併的各種方法。從最基礎的操作到進階技巧，再到效能比較與常見注意事項，皆以初學者也能理解的方式說明，並搭配具體的程式範例，讓您可以依照需求選擇最合適的合併方法。歡迎閱讀到最後！
接下來的章節，我們將深入探討 Python 中串列合併的五種主要方法。
2. 串列合併的 5 種主要方法
在 Python 中，有多種方式可以合併串列。每種方法都有其特點，適用情境也有所不同。本章節將透過具體的程式碼範例，介紹五種常見的串列合併方式。
2.1 append() 方法
特點
append() 方法用於將單一元素加入到串列的尾端。此方法會直接修改原本的串列，因此串列本身會更新。
使用範例
以下的程式碼示範了如何使用 append() 將新元素加入串列：
list1 = [1, 2, 3]
list1.append(4)
print(list1) ## 輸出: [1, 2, 3, 4]但需要注意的是，如果加入的是整個串列，會產生巢狀串列：
list1 = [1, 2, 3]
list1.append([4, 5])
print(list1) ## 輸出: [1, 2, 3, [4, 5]]注意事項
append() 適合加入單一元素，但若要合併整個串列，建議使用其他方法會更有效率。
2.2 extend() 方法
特點
extend() 方法可以將另一個串列或可迭代物件（如元組、集合等）展開後加入至原本串列的尾端。不會產生巢狀結構，適合用來合併串列。
使用範例
以下的程式碼示範了如何使用 extend() 合併兩個串列：
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1) ## 輸出: [1, 2, 3, 4, 5, 6]注意事項
extend()會直接修改原始串列。- 若需要合併巢狀串列，則需採用其他方法。
2.3 insert() 方法
特點
insert() 方法用於在串列中的特定位置插入元素。當您想在特定位置插入而不是合併時，這是一個很實用的方法。
使用範例
以下的程式碼示範了如何使用 insert() 將元素插入指定位置：
list1 = [1, 2, 4]
list1.insert(2, 3)
print(list1) ## 輸出: [1, 2, 3, 4]注意事項
如果經常使用 insert()，且串列資料量很大時，可能會導致處理速度變慢。
2.4 + 運算子
特點
+ 運算子可將兩個串列結合成一個新的串列。原本的串列不會被更動，會回傳一個新的結果。
使用範例
以下的程式碼示範如何使用 + 運算子合併串列：
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2
print(combined) ## 輸出: [1, 2, 3, 4, 5, 6]注意事項
- 由於會產生新的串列，可能會增加記憶體的使用量。
- 原始的串列不會被修改。
2.5 使用切片
特點
透過切片（Slice）語法，可以在串列中的任意位置插入或合併元素，是一種靈活度極高的方法。
使用範例
以下的程式碼示範了如何使用切片語法合併串列：
list1 = [1, 2, 5]
list1[2:2] = [3, 4]
print(list1) ## 輸出: [1, 2, 3, 4, 5]注意事項
使用切片時，必須準確指定索引位置，否則可能會導致非預期的結果。
3. 根據用途選擇合適的合併方法
雖然合併串列有多種方式可選，但根據實際的用途與情境，選擇最適合的方法非常重要。本章節將根據常見的使用情境，說明推薦使用的合併方式。
3.1 合併小型串列的情況
推薦方法: + 運算子
在處理小型串列時，使用 + 運算子是最簡潔且有效率的方法。由於會產生新的串列，因此在不希望修改原始資料時也很合適。
範例
list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = list1 + list2
print(result) ## 輸出: [1, 2, 3, 4, 5, 6]優點
- 語法簡潔易讀。
- 處理小量資料時效能表現良好。
注意事項
- 由於會建立新的串列，對於大量資料來說可能不夠效率。
3.2 合併大量資料的情況
推薦方法: extend() 方法
當要合併大量資料時，使用 extend() 方法更為高效。這個方法會直接更新原本的串列，可降低記憶體消耗。
範例
list1 = [i for i in range(100000)]
list2 = [j for j in range(100000)]
list1.extend(list2)
print(len(list1)) ## 輸出: 200000優點
- 非常適合處理大量資料。
- 記憶體使用效率高。
注意事項
- 由於會改動原始串列，不適合需要保留原資料的情況。
3.3 想在特定位置插入元素的情況
推薦方法: insert() 方法 或 切片
當您希望將元素插入到串列中的特定位置時，insert() 方法或使用切片都是非常方便的選擇。適合插入位置明確的情境。
範例（insert）
list1 = [1, 2, 4]
list1.insert(2, 3)
print(list1) ## 輸出: [1, 2, 3, 4]範例（切片）
list1 = [1, 2, 5]
list1[2:2] = [3, 4]
print(list1) ## 輸出: [1, 2, 3, 4, 5]優點
- 可以將元素插入任意位置。
- 使用切片可一次插入多個元素。
注意事項
- 若串列元素數量龐大，頻繁操作可能會導致效能下降。
3.4 重複新增元素的情況
推薦方法: append() 方法
當您在迴圈中需要一個一個地新增元素時，使用 append() 是最佳選擇。可以有效率地將單一元素加入串列。
範例
list1 = []
for i in range(5):
list1.append(i)
print(list1) ## 輸出: [0, 1, 2, 3, 4]優點
- 語法簡單易懂。
- 適用於逐一處理資料的情況。
注意事項
- 若目的是合併整個串列，
append()並非最合適的方法。
3.5 想組合多種合併方式的情況
有時可將多種方法組合使用，以實現更彈性的資料操作。例如，您可以結合切片與 extend()，有效地在特定位置插入多個元素。
範例
list1 = [1, 5]
list2 = [2, 3, 4]
list1[1:1] = list2
print(list1) ## 輸出: [1, 2, 3, 4, 5]總結
- 小型資料: 推薦使用
+運算子，簡單易懂。 - 大型資料: 考慮記憶體效率，推薦
extend()。 - 逐一新增元素:
append()最適合。 - 插入特定位置: 可用
insert()或切片。 - 插入多個元素: 切片方法靈活且實用。
4. 性能比較
在 Python 中，不同的串列合併方式在效能上可能會有差異。資料量較少時差異不大，但隨著資料增多，執行時間的差異可能會變得明顯。本章節將針對幾種常見的方法進行效能比較。
4.1 測試方法與前提條件
為了比較效能，我們使用以下條件進行測試：
- 串列大小: 每個串列包含 100,000 個元素。
- 比較項目: 執行速度（處理時間）。
- 測試環境: 使用 Python 標準函式庫中的
time模組。
我們將根據以下程式碼，比較 + 運算子、extend() 方法、append() 方法（透過迴圈）、以及切片的執行時間。
範例程式碼
import time
## 測試用串列
list1 = [i for i in range(100000)]
list2 = [j for j in range(100000)]
## 使用 + 運算子
start = time.time()
combined = list1 + list2
print("Plus:", time.time() - start)
## 使用 extend() 方法
start = time.time()
list1.extend(list2)
print("Extend:", time.time() - start)
## 使用 append() 方法（透過迴圈加入）
list1 = [i for i in range(100000)]
start = time.time()
for item in list2:
list1.append(item)
print("Append in Loop:", time.time() - start)
## 使用切片
list1 = [i for i in range(100000)]
start = time.time()
list1[len(list1):] = list2
print("Slice:", time.time() - start)4.2 性能測試結果
以下是測試結果的範例（實際結果會依據執行環境略有不同）：
| 方法 | 執行時間 (秒) |
|–||
| + 運算子 | 0.08 |
| extend() | 0.03 |
| append()（迴圈）| 0.25 |
| 切片 | 0.04 |
4.3 結果解析
+ 運算子
- 速度: 中等。
- 特點: 建立新的串列，可能增加記憶體的使用。
- 適用情境: 合併小型串列時效果良好。
extend() 方法
- 速度: 非常快。
- 特點: 直接修改原始串列，記憶體使用效率高。
- 適用情境: 大量資料的合併。
append() 方法（迴圈）
- 速度: 非常慢。
- 特點: 一次只加入一個元素，處理速度慢。
- 適用情境: 元素是動態生成時適用，不建議用於大量資料。
切片
- 速度: 快速。
- 特點: 彈性高，適合在指定位置插入或合併多個元素。
- 適用情境: 需要插入多個元素到特定位置時。
4.4 應該選擇哪一種方式？
小型串列：
- 推薦方法:
+運算子 或extend()。 - 原因: 語法簡潔，記憶體使用不成問題。
大型串列：
- 推薦方法:
extend()。 - 原因: 效能佳且節省記憶體。
插入指定位置：
- 推薦方法: 使用切片。
- 原因: 可彈性地操作多個元素，效率高。
5. 串列合併時的注意事項與常見錯誤
串列合併雖然非常實用，但若使用不當，可能會導致非預期的結果。本章節將介紹合併串列時常見的錯誤與對應的處理方式。
5.1 混淆 append() 與 extend()
問題點
由於 append() 和 extend() 名稱相似，常常會被搞混。特別是在想要合併整個串列時，容易使用錯誤的方法。
範例
list1 = [1, 2, 3]
list2 = [4, 5]
list1.append(list2)
print(list1) ## 輸出: [1, 2, 3, [4, 5]]上述範例中，list2 被當成單一元素加入，造成巢狀串列。
解決方式
若想要展開整個串列並合併，請使用 extend()：
list1 = [1, 2, 3]
list2 = [4, 5]
list1.extend(list2)
print(list1) ## 輸出: [1, 2, 3, 4, 5]5.2 使用 + 運算子導致記憶體佔用增加
問題點
使用 + 運算子合併串列時，會產生新的串列，這會增加記憶體的使用量，尤其是在處理大型資料時。
範例
list1 = [i for i in range(1000000)]
list2 = [j for j in range(1000000)]
combined = list1 + list2 ## 產生新的串列此操作會同時保留 list1、list2 和新的 combined，造成記憶體使用量大幅上升。
解決方式
若要處理大量資料，建議使用 extend() 來降低記憶體負擔：
5.3 insert() 或 切片時的索引錯誤
問題點
使用 insert() 或切片操作時，若指定了錯誤的索引，可能會導致非預期的結果。
範例
list1 = [1, 2, 3]
list1.insert(10, 4)
print(list1) ## 輸出: [1, 2, 3, 4]在這個例子中，即使指定了不存在的索引 10，也不會報錯，而是將元素加到尾端。
解決方式
使用前請先確認串列長度，或考慮使用切片來避免索引錯誤。
5.4 可變物件的副作用
問題點
append() 與 extend() 都會直接修改原始串列，因此如果多個變數參考了同一個串列，就可能出現預期外的變化。
範例
list1 = [1, 2, 3]
list2 = list1 ## list1 與 list2 指向相同的串列
list1.append(4)
print(list2) ## 輸出: [1, 2, 3, 4]解決方式
若不想影響原串列，可使用切片語法來建立複本：
list1 = [1, 2, 3]
list2 = list1[:]
list1.append(4)
print(list2) ## 輸出: [1, 2, 3]5.5 資料型別不一致
問題點
若加入的資料型別非可迭代對象（如整數），在使用 extend() 時會出錯。
範例
list1 = [1, 2, 3]
list1.extend(4) ## TypeError: 'int' object is not iterable解決方式
確認要加入的資料為可迭代（如：串列、元組等）：
list1 = [1, 2, 3]
list1.extend([4]) ## 正確寫法5.6 小結
- 理解 append() 和 extend() 的差異，並在正確的情境中使用。
- 處理大型資料時，優先考慮 extend()，以降低記憶體使用量。
- 使用 insert() 或 切片時，注意索引位置是否正確。
- 避免副作用，需要時請建立串列的複本。
- 確認資料型別是否為可迭代，避免型別錯誤。
6. 總結
在 Python 中，串列的合併是管理與操作資料不可或缺的重要技能。本文詳細介紹了五種主要的串列合併方法，包含它們的用途、效能表現，以及使用時應注意的細節。本章將回顧這些內容，幫助您根據不同情況選擇最合適的方式。
6.1 各合併方法的特點回顧
1. append() 方法
- 特點: 向串列尾端加入單一元素。
- 適用情境: 需要逐一加入元素時。
- 注意事項: 不適合用來合併整個串列。
2. extend() 方法
- 特點: 將另一個可迭代對象展開並加入串列尾端。
- 適用情境: 合併大量資料。
- 注意事項: 原始串列會被修改。
3. insert() 方法
- 特點: 在指定位置插入單一元素。
- 適用情境: 需要在特定位置插入元素。
- 注意事項: 資料量大時效率可能下降。
4. + 運算子
- 特點: 合併兩個串列，產生新的串列。
- 適用情境: 小型串列合併。
- 注意事項: 大量資料時記憶體使用效率較差。
5. 切片
- 特點: 在任意位置插入或合併多個元素。
- 適用情境: 需要更高彈性時。
- 注意事項: 必須正確指定索引。
6.2 根據用途推薦的合併方式
- 小型資料: 使用
+運算子簡潔且實用。 - 大型資料: 推薦使用
extend()，節省記憶體。 - 單一元素新增: 使用
append()適合迴圈中操作。 - 插入特定位置: 可使用
insert()或切片。 - 多個元素插入特定位置: 切片最具彈性與效率。
6.3 合併時的注意事項
- 理解 append() 與 extend() 差異，避免混淆。
- 處理大量資料時注意效能，建議使用
extend()。 - 使用 + 運算子建立新串列 時，需考慮記憶體消耗。
- 避免副作用，需要時使用切片建立複本。
- 確認資料型別一致性，避免發生錯誤。
6.4 下一步建議
建議您實際在 Python 中練習串列的操作，根據不同的目的選擇合適的合併方式，撰寫更高效與穩定的程式碼。
推薦練習內容：
- 嘗試各種合併方法：
- 比較小型與大型串列在不同方法下的執行速度。
- 故意觸發錯誤：
- 測試資料型別不符、索引錯誤等情況，了解錯誤訊息。
- 思考更彈性的應用方式：
- 嘗試結合
extend()與切片，打造自訂的合併邏輯。
透過深入理解串列合併操作，您將能撰寫更簡潔、高效且不易出錯的程式碼。
常見問題（FAQ）
Q1: append() 和 extend() 有何不同？
A1：
- append(): 加入一個元素到串列尾端。若加入的是串列，則會變成巢狀結構。
範例：
list1 = [1, 2, 3]
list1.append([4, 5])
print(list1) ## 輸出: [1, 2, 3, [4, 5]]- extend(): 將另一個串列或可迭代物件展開並加入尾端，不會巢狀。
範例：
list1 = [1, 2, 3]
list1.extend([4, 5])
print(list1) ## 輸出: [1, 2, 3, 4, 5]Q2: 要合併大量資料時，用哪種方法最好？
A2：
當要處理大量資料時，建議使用 extend() 方法。因為它會直接修改原串列，不會像 + 運算子那樣建立新串列，可以節省記憶體。
範例：
list1 = [i for i in range(1000000)]
list2 = [j for j in range(1000000)]
list1.extend(list2) ## 效率高，節省記憶體Q3: 如何使用切片來合併串列？
A3：
使用切片可在指定位置插入多個元素。例如：
list1 = [1, 5]
list1[1:1] = [2, 3, 4]
print(list1) ## 輸出: [1, 2, 3, 4, 5]切片非常彈性，適合插入多筆資料。但請務必注意索引指定的正確性。
Q4: + 運算子與 extend() 應該怎麼選擇？
A4：
- 小型串列: 使用 + 運算子 簡潔又直觀。
範例：
list1 = [1, 2]
list2 = [3, 4]
result = list1 + list2
print(result) ## 輸出: [1, 2, 3, 4]- 大型串列: 使用 extend() 效能更好，記憶體利用率高。
Q5: 串列合併時常見的錯誤有哪些？
A5：
常見的錯誤如下：
- TypeError: ‘int’ object is not iterable
- 當您將非可迭代對象（如整數）傳給
extend()時會發生這個錯誤。
解決方法： 使用串列或其他可迭代對象。
範例：
list1 = [1, 2, 3]
list1.extend([4]) ## 正確- 意外建立巢狀串列
- 使用
append()加入串列時會整體加入，造成巢狀。
解決方法： 使用extend()。
Q6: 哪一種方法最快？
A6：
若追求速度與效率，extend() 是最佳選擇。尤其在合併大量資料時，它比 + 運算子更快、更省記憶體。
範例： 以下是效能比較結果（可能依執行環境而異）：
| 方法 | 執行時間（秒） |
|---|---|
+ 運算子 | 0.08 |
extend() | 0.03 |