NumPy多維陣列合併與堆積疊操作

– 11 分鐘閱讀

NumPy 是 Python 資料科學領域的核心函式庫，其強大的陣列操作能力是許多資料分析任務的基本。在實際應用中，我們經常需要合併或堆積疊多個陣列以進行更進一步的分析。本文將深入探討 NumPy 提供的 concatenate 和 stack 等函式，以及它們的變體 vstack 和 hstack，並輔以實際案例說明如何在不同維度的陣列上進行操作。這些函式允許我們根據不同的軸向合併陣列，例如垂直合併、水平合併，或是增加新的維度。理解這些函式的運作機制對於提升資料處理效率至關重要，特別是在處理大型資料集時，能有效簡化程式碼並提升效能。透過本文的說明和範例，讀者將能更深入地瞭解 NumPy 陣列操作的精髓，並應用於實際的資料處理任務中。

多維陣列操作與合併

在進行資料分析和操作時，常常需要對多維陣列進行操作和合併。NumPy 提供了多種方法來實作這些操作，包括陣列的合併、交換軸等。

交換軸

當需要交換陣列的兩個軸時，可以使用 swapaxes 函式。這個函式可以讓你交換陣列的任意兩個軸。

合併多個陣列

NumPy 提供了 concatenate 函式來合併多個陣列。這個函式可以根據指定的軸來合併陣列。

concatenate 函式

concatenate 函式的語法如下：

numpy.concatenate((a1, a2,...), axis=0, dtype=None, casting='same_kind')

其中，a1, a2 等是要合併的陣列，axis 引數指定了合併的軸，dtype 引數指定了合併後的資料型別，casting 引數指定了合併時的資料型別轉換方式。

當 axis=0 時，進行垂直合併；當 axis=1 時，進行水平合併；當 axis=None 時，先將陣列轉換為 1D 陣列，然後進行合併。

例子

以下是使用 concatenate 函式合併多個陣列的例子：

import numpy as np

# 1D 陣列合併
arr1 = np.arange(4)
arr2 = np.arange(5)
print(np.concatenate((arr1, arr2)))

# 2D 陣列合併
arr3 = np.arange(1, 7).reshape(2, 3)
arr4 = np.array([[10, 11, 12], [13, 14, 15]])
print(np.concatenate((arr3, arr4), axis=0))
print(np.concatenate((arr3, arr4), axis=1))

這些例子展示瞭如何使用 concatenate 函式來合併多個陣列，並根據不同的軸進行合併。

圖表解釋

以下是使用 Mermaid 圖表來解釋 concatenate 函式的工作原理：

  flowchart TD
    A[陣列 1] -->|合併|> B[陣列 2]
    B -->|合併|> C[陣列 3]
    C -->|結果|> D[合併後的陣列]
    style A fill:#f9f,stroke:#333,stroke-width:4px
    style B fill:#f9f,stroke:#333,stroke-width:4px
    style C fill:#f9f,stroke:#333,stroke-width:4px
    style D fill:#f9f,stroke:#333,stroke-width:4px

這個圖表展示瞭如何使用 concatenate 函式來合併多個陣列，並根據不同的軸進行合併。

圖表翻譯

這個圖表展示了 concatenate 函式的工作原理。首先，陣列 1 和陣列 2 進行合併，然後結果與陣列 3 進行合併，最終得到合併後的陣列。這個過程可以根據不同的軸進行合併，例如垂直合併或水平合併。

垂直和水平串聯

垂直串聯是指沿著列（axis=0）進行的串聯，而水平串聯是指沿著行（axis=1）進行的串聯。這兩種串聯方式在 NumPy 中都可以使用 np.concatenate() 函式來實作。

垂直串聯

垂直串聯是指將兩個或多個陣列按照列方向（axis=0）進行串聯。這意味著原始陣列的行會被合併成一個新的陣列。

import numpy as np

# 建立兩個 1-D 陣列
arr1 = np.arange(5)
arr2 = np.arange(3)

# 垂直串聯
result_vertical = np.concatenate((arr1, arr2))

print("垂直串聯結果:")
print(result_vertical)

水平串聯

水平串聯是指將兩個或多個陣列按照行方向（axis=1）進行串聯。這意味著原始陣列的列會被合併成一個新的陣列。

# 建立兩個 2-D 陣列
arr3 = np.array([[1, 2], [3, 4]])
arr4 = np.array([[5, 6], [7, 8]])

# 水平串聯
result_horizontal = np.concatenate((arr3, arr4), axis=1)

print("\n水平串聯結果:")
print(result_horizontal)

平面化和串聯

在某些情況下，可能需要先平面化（flatten）陣列然後再進行串聯。這可以使用 np.flatten() 函式來實作。

# 建立一個 2-D 陣列
arr5 = np.array([[1, 2], [3, 4]])

# 平面化陣列
arr5_flat = arr5.flatten()

# 建立另一個 1-D 陣列
arr6 = np.arange(3)

# 串聯平面化的陣列和另一個陣列
result_flat_concat = np.concatenate((arr5_flat, arr6))

print("\n平面化和串聯結果:")
print(result_flat_concat)

使用 ‘out’ 引數和 dtype

當使用 np.concatenate() 函式時，可以指定 out 引數來儲存結果陣列。此外，還可以指定 dtype 引數來控制結果陣列的資料型別。

# 建立兩個 1-D 陣列
arr7 = np.arange(5)
arr8 = np.arange(3)

# 指定 'out' 引數和 dtype
result_out_dtype = np.empty(8, dtype=np.int64)
np.concatenate((arr7, arr8), out=result_out_dtype)

print("\n使用 'out' 引數和 dtype 的結果:")
print(result_out_dtype)

需要注意的是，當使用 out 引數時，結果陣列和 out 陣列必須具有相同的形狀和資料型別。否則，可能會出現錯誤。

陣列串接和堆積疊

在 NumPy 中，陣列串接和堆積疊是兩種常見的操作，用於合併多個陣列。以下將介紹這兩種操作的使用方法和範例。

陣列串接

陣列串接是指將多個陣列合併成一個新的陣列。NumPy 提供了 concatenate 函式來實作這一功能。以下是範例：

import numpy as np

# 1-D 陣列串接
arr1 = np.array([0, 1, 2, 3])
arr2 = np.array([0, 1, 2, 3, 4])
result = np.concatenate((arr1, arr2))
print(result)  # [0 1 2 3 0 1 2 3 4]

# 2-D 陣列串接
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[10, 11, 12], [13, 14, 15]])
result_vertical = np.concatenate((arr1, arr2), axis=0)
result_horizontal = np.concatenate((arr1, arr2), axis=1)
print(result_vertical)
# [[ 1  2  3]
#  [ 4  5  6]
#  [10 11 12]
#  [13 14 15]]
print(result_horizontal)
# [[ 1  2  3 10 11 12]
#  [ 4  5  6 13 14 15]]

# 陣列扁平化後串接
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
result = np.concatenate((arr1, arr2)).flatten()
print(result)  # [1 2 3 4 5 6]

堆積疊

堆積疊是指將多個陣列合併成一個新的陣列，並增加一個新的維度。NumPy 提供了 stack 函式來實作這一功能。以下是範例：

import numpy as np

# 堆積疊範例
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
result = np.stack((arr1, arr2), axis=0)
print(result)
# [[1 2 3]
#  [4 5 6]]

# 堆積疊後增加新的維度
arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])
result = np.stack((arr1, arr2), axis=0)
print(result)
# [[[1 2]
#   [3 4]]
#  [[5 6]
#   [7 8]]]

注意，stack 函式需要輸入陣列的形狀相同，否則會出現錯誤。

瞭解 NumPy 中的堆積疊操作

NumPy 的 stack 函式提供了一種方便的方法來將多個陣列堆積疊在一起，形成一個新的陣列。這個過程可以根據指定的軸（axis）進行堆積疊。

堆積疊操作的基本概念

堆積疊操作是指將兩個或多個陣列沿著某一維度進行合併。NumPy 中的 stack 函式支援沿著不同軸進行堆積疊，包括軸 0（預設）、軸 1 和軸 2 等。

示例 1：預設軸（軸 0）堆積疊

import numpy as np

# 建立兩個 1-D 陣列
myarr1 = np.array([1, 2, 3])
myarr2 = np.array([10, 12, 13])

# 沿著軸 0 堆積疊
mystack_array = np.stack((myarr1, myarr2))

print("堆積疊結果：\n", mystack_array)
print("堆積疊陣列的形狀：", mystack_array.shape)

輸出結果：

堆積疊結果：
 [[ 1  2  3]
 [10 12 13]]
堆積疊陣列的形狀： (2, 3)

示例 2：沿著軸 1 堆積疊

# 建立兩個 2-D 陣列
myarr3 = np.arange(1, 7).reshape(2, 3)
myarr4 = np.array([[10, 12, 13], [14, 15, 17]])

# 沿著軸 1 堆積疊
mystack_array_3D = np.stack((myarr3, myarr4), axis=1)

print("堆積疊結果：\n", mystack_array_3D)
print("堆積疊陣列的形狀：", mystack_array_3D.shape)

輸出結果：

堆積疊結果：
 [[[ 1  2  3]
  [10 12 13]]

 [[ 4  5  6]
  [14 15 17]]]
堆積疊陣列的形狀： (2, 2, 3)

示例 3：沿著軸 2 堆積疊

# 建立兩個 2-D 陣列
myarr5 = np.arange(1, 7).reshape(2, 3)
myarr6 = np.array([[10, 12, 13], [14, 15, 17]])

# 沿著軸 2 堆積疊
mystack_array_3D_axis2 = np.stack((myarr5, myarr6), axis=2)

print("堆積疊結果：\n", mystack_array_3D_axis2)
print("堆積疊陣列的形狀：", mystack_array_3D_axis2.shape)

輸出結果：

堆積疊結果：
 [[[ 1 10]
  [ 2 12]
  [ 3 13]]

 [[ 4 14]
  [ 5 15]
  [ 6 17]]]
堆積疊陣列的形狀： (2, 3, 2)

透過這些示例，可以看到 NumPy 的 stack 函式如何根據不同的軸進行堆積疊操作，形成新的陣列結構。這些操作在資料分析和科學計算中非常有用。

使用 NumPy 的 stack 函式進行陣列堆積疊

在 NumPy 中，stack 函式可以用來堆積疊陣列。堆積疊的方向可以透過 axis 引數進行控制。

堆積疊陣列的方向

  • axis=0：根據第一維度（行）堆積疊。
  • axis=1：根據第二維度（列）堆積疊。
  • axis=2：根據第三維度（深度）堆積疊。

範例程式碼

import numpy as np

# 定義兩個 2D 陣列
myarr3 = np.array([[1, 2, 3], [10, 12, 13]])
myarr4 = np.array([[4, 5, 6], [14, 15, 17]])

# 根據 axis=0 堆積疊
mystack_array_0 = np.stack((myarr3, myarr4), axis=0)
print("根據 axis=0 堆積疊的結果：")
print(mystack_array_0)
print(f"堆積疊陣列的形狀：{mystack_array_0.shape}")

# 根據 axis=1 堆積疊
mystack_array_1 = np.stack((myarr3, myarr4), axis=1)
print("\n根據 axis=1 堆積疊的結果：")
print(mystack_array_1)
print(f"堆積疊陣列的形狀：{mystack_array_1.shape}")

# 根據 axis=2 堆積疊
mystack_array_2 = np.stack((myarr3, myarr4), axis=2)
print("\n根據 axis=2 堆積疊的結果：")
print(mystack_array_2)
print(f"堆積疊陣列的形狀：{mystack_array_2.shape}")

執行結果

根據 axis=0 堆積疊的結果：

[[ 1  2  3]
 [10 12 13]
 [ 4  5  6]
 [14 15 17]]

堆積疊陣列的形狀：(4, 3)

根據 axis=1 堆積疊的結果：

 [[[ 1  2  3]
  [ 4  5  6]]

 [[10 12 13]
  [14 15 17]]]

堆積疊陣列的形狀：(2, 2, 3)

根據 axis=2 堆積疊的結果：

 [[[ 1 10]
  [ 2 12]
  [ 3 13]]

 [[ 4 14]
  [ 5 15]
  [ 6 17]]]

堆積疊陣列的形狀：(2, 3, 2)

圖表翻譯：

圖表示意圖

  graph LR
    A[定義陣列] --> B[堆積疊陣列]
    B --> C[根據 axis=0 堆積疊]
    B --> D[根據 axis=1 堆積疊]
    B --> E[根據 axis=2 堆積疊]
    C --> F[輸出結果]
    D --> F
    E --> F

圖表解釋

上述圖表表示使用 NumPy 的 stack 函式進行陣列堆積疊的流程。首先定義兩個陣列，然後根據不同的 axis 引數進行堆積疊，最後輸出結果。

垂直堆積疊（vstack）函式

垂直堆積疊（vstack）是一種用於將陣列垂直堆積疊的函式，適用於需要合併多個陣列的場景。這個函式可以接收一系列陣列作為輸入，並傳回一個單一的堆積疊後的陣列。

vstack 函式的語法

mynp.vstack(tup, *, dtype=None, casting='same_kind')

其中，tup 是一個包含多個陣列的序列，dtype 和 casting 是可選引數，分別用於指定傳回陣列的資料型別和數值轉換的方式。

vstack 函式的使用範例

以下是使用 vstack 函式的範例：

import numpy as mynp

# 範例 1：堆積疊 1-D 陣列
myarr1 = mynp.array([1, 2, 3])
myarr2 = mynp.array([11, 12, 13])
myarr3 = mynp.vstack((myarr1, myarr2))
print(f"Vstack array is {myarr3}")

# 範例 2：堆積疊 2-D 陣列
a = mynp.arange(1, 10).reshape(3, 3)
b = mynp.arange(20, 26).reshape(2, 3)
print(f"Vstack array is : {mynp.vstack((a, b))}")

輸出結果：

Eg1 vstack for 1-D array------------------------------
Vstack array is [[ 1  2  3]
 [11 12 13]]
Eg2 2-D array shape with (3,3) and (2,3)--------------
Vstack array is : [[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [20 21 22]
 [23 24 25]]

注意，在使用 vstack 函式時，所有輸入陣列必須具有相同的形狀，除了軸向 0 的維度外。

內容解密：

在上述範例中，我們使用 vstack 函式將兩個 1-D 陣列和兩個 2-D 陣列堆積疊在一起。vstack 函式會根據輸入陣列的形狀和資料型別自動調整傳回陣列的形狀和資料型別。在範例 1 中，兩個 1-D 陣列被堆積疊在一起，形成一個 2-D 陣列。在範例 2 中，兩個 2-D 陣列被堆積疊在一起，形成一個新的 2-D 陣列。

圖表翻譯：

以下是使用 Mermaid 圖表語言描述 vstack 函式的工作原理：

  flowchart TD
    A[輸入陣列] --> B[檢查形狀]
    B --> C[堆積疊陣列]
    C --> D[傳回堆積疊後的陣列]
    D --> E[輸出結果]

這個圖表描述了 vstack 函式的工作流程：輸入陣列 -> 檢查形狀 -> 堆積疊陣列 -> 傳回堆積疊後的陣列 -> 輸出結果。

橫向堆積疊（hstack）函式

橫向堆積疊（hstack）是一種用於堆積疊陣列的函式，能夠將多個陣列按照橫向（第二軸）進行堆積疊。這個函式需要輸入陣列序列，並傳回一個單一的陣列。需要注意的是，所有輸入陣列必須具有相同的維度。

hstack 函式的語法

mynp.hstack(tup, *, dtype=None, casting='same_kind')

其中，tup 是輸入陣列序列，dtype 是傳回陣列的資料型別，casting 是用於控制資料型別轉換的引數。

1-D 陣列的橫向堆積疊

對於 1-D 陣列，hstack 函式會按照第一軸進行堆積疊。以下是示例程式碼：

import numpy as mynp

myarr1 = mynp.array([1, 2, 3])
myarr2 = mynp.array([11, 12, 13, 14])

myarr3 = mynp.hstack((myarr1, myarr2))

print(f"Hstack array is {myarr3}")

輸出結果：

Hstack array is [ 1  2  3 11 12 13 14]

2-D 陣列的橫向堆積疊

對於 2-D 陣列，hstack 函式會按照第二軸進行堆積疊。以下是示例程式碼：

a = mynp.arange(1, 10).reshape(3, 3)
b = mynp.arange(10, 13).reshape(3, 1)

myarr4 = mynp.hstack((a, b))

print(f"Hstack array is {myarr4}")

輸出結果：

Hstack array is [[ 1  2  3 10]
 [ 4  5  6 11]
 [ 7  8  9 12]]

內容解密：

hstack 函式的作用是將多個陣列按照橫向進行堆積疊，傳回一個單一的陣列。這個函式需要輸入陣列序列，並傳回一個單一的陣列。需要注意的是，所有輸入陣列必須具有相同的維度。

圖表翻譯：

  graph LR
    A[輸入陣列序列] --> B[hstack 函式]
    B --> C[傳回單一陣列]
    C --> D[橫向堆積疊]
    D --> E[傳回結果]

這個圖表展示了 hstack 函式的工作流程，從輸入陣列序列到傳回單一陣列的過程。

瞭解 NumPy 中的陣列堆積疊：vstack、hstack 和 dstack

NumPy 提供了多種方法來堆積疊陣列，包括 vstack、hstack 和 dstack。這些函式可以根據不同的軸向堆積疊陣列，從而建立新的陣列結構。

vstack：垂直堆積疊

vstack 函式用於沿著第一軸（垂直方向）堆積疊陣列。這意味著當你使用 vstack 時，原始陣列的行數會增加，而列數保持不變。

import numpy as np

a = np.arange(1, 4).reshape(1, 3)
b = np.arange(4, 7).reshape(1, 3)

print("垂直堆積疊結果：\n", np.vstack((a, b)))

hstack：水平堆積疊

hstack 函式則用於沿著第二軸（水平方向）堆積疊陣列。這意味著當你使用 hstack 時，原始陣列的列數會增加，而行數保持不變。

import numpy as np

a = np.arange(1, 4).reshape(1, 3)
b = np.arange(4, 7).reshape(1, 3)

print("水平堆積疊結果：\n", np.hstack((a, b)))

dstack：深度堆積疊

dstack 函式用於沿著第三軸（深度方向）堆積疊陣列。這在處理三維陣列或需要增加陣列深度的情況下非常有用。

import numpy as np

a = np.arange(1, 5).reshape(2, 2)
b = np.arange(5, 9).reshape(2, 2)

print("深度堆積疊結果：\n", np.dstack((a, b)))

堆積疊陣列的注意事項

  • 使用 vstack 和 hstack 時，所有輸入陣列除堆積疊軸外的其他維度必須完全匹配。
  • 使用 dstack 時，所有輸入陣列必須具有相同的形狀（除第三軸外）。

實際應用

堆積疊陣列在資料分析和科學計算中非常常見，尤其是在需要合並不同資料集或增加資料維度的情況下。透過掌握 vstack、hstack 和 dstack 函式，你可以更靈活地操作 NumPy 陣列，從而更好地解決實際問題。

圖表翻譯：

  flowchart TD
    A[開始] --> B[選擇堆積疊方法]
    B --> C[vstack: 垂直堆積疊]
    B --> D[hstack: 水平堆積疊]
    B --> E[dstack: 深度堆積疊]
    C --> F[沿第一軸堆積疊]
    D --> G[沿第二軸堆積疊]
    E --> H[沿第三軸堆積疊]
    F --> I[結果陣列]
    G --> I
    H --> I

內容解密：

上述程式碼示範瞭如何使用 vstack、hstack 和 dstack 函式來堆積疊 NumPy 陣列。每個函式都有其特定的用途，根據你想要增加陣列的維度或合並資料的方式來選擇合適的函式。透過這些函式，你可以建立出更複雜的陣列結構，以滿足你的資料分析和科學計算需求。

從底層實作到高階應用的全面檢視顯示，NumPy 提供了豐富的多維陣列操作工具，concatenate、stack、vstack、hstack 和 dstack 等函式各有千秋，讓開發者能靈活地合併和重塑陣列結構。透過多維度效能指標的實測分析，concatenate 在處理大規模陣列合併時效率更高，而 stack 系列函式則更適用於需要增加維度的場景。然而，這些函式也存在一些限制，例如 concatenate 需要考慮軸向和資料型別匹配，stack 系列函式則要求輸入陣列形狀一致。技術團隊應著重於理解不同函式的適用場景和限制，才能釋放這些工具的完整潛力。對於追求極致效能的應用，建議深入研究 NumPy 的底層機制，探索更進階的陣列操作技巧。隨著資料科學和機器學習的蓬勃發展，我們預見更高效、更靈活的多維陣列操作工具將會不斷湧現，進一步提升資料處理效率。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。