NumPy陣列扁平化與轉置操作

NumPy 提供了多種方法來處理陣列維度轉換，其中 flatten、flat 和 ravel 方法，以及 T 屬性，常被用於陣列扁平化和轉置操作。理解這些方法的差異對於有效運用 NumPy 至關重要。flatten 方法會建立原始陣列的副本，修改副本不會影響原始陣列；而 flat 屬性則傳回一個迭代器，可以直接修改原始陣列元素。ravel 方法類別似 flat，但傳回的是陣列檢視，修改檢視會影響原始陣列。T 屬性則用於陣列轉置，例如二維陣列的行和列互換，或高維陣列的軸交換，同樣傳回的是檢視。這些方法也支援 order 引數，可以指定元素的儲存順序，例如 C 語言的行優先或 Fortran 的列優先。選擇正確的方法取決於具體的需求，例如是否需要修改原始陣列，以及效能考量。

使用NumPy的flatten和flat屬性

NumPy是一個強大的Python函式庫，提供了高效的資料結構和運算工具。當處理多維陣列時，瞭解如何使用flatten和flat屬性是非常重要的。

flatten屬性

flatten屬性傳回一個新的1維陣列，它是原始多維陣列的複製。這意味著修改原始陣列的值不會影響到flatten後的陣列。

import numpy as np

# 建立一個2維陣列
myarr1 = np.array([[1, 2, 3], [4, 5, 6]])

# 使用flatten屬性
myarr2 = myarr1.flatten()

print("原始陣列:")
print(myarr1)
print("flatten後的陣列:")
print(myarr2)

# 修改原始陣列的值
myarr1[0, 0] = 13

print("修改後的原始陣列:")
print(myarr1)
print("flatten後的陣列（未變）:")
print(myarr2)

輸出：

原始陣列:
[[1 2 3]
 [4 5 6]]
flatten後的陣列:
[1 2 3 4 5 6]
修改後的原始陣列:
[[13  2  3]
 [ 4  5  6]]
flatten後的陣列（未變）:
[1 2 3 4 5 6]

flat屬性

flat屬性傳回一個1維迭代器，允許存取多維陣列的元素。這個迭代器是原始陣列的檢視，這意味著修改原始陣列的值會影響到flat迭代器。

import numpy as np

# 建立一個2維陣列
myarr1 = np.array([[1, 2, 3], [4, 5, 6]])

# 使用flat屬性
flat_iter = myarr1.flat

print("原始陣列:")
print(myarr1)

# 修改原始陣列的值
myarr1[0, 0] = 13

print("修改後的原始陣列:")
print(myarr1)

# 使用flat迭代器存取元素
for elem in flat_iter:
    print(elem)

輸出：

原始陣列:
[[1 2 3]
 [4 5 6]]
修改後的原始陣列:
[[13  2  3]
 [ 4  5  6]]
13
2
3
4
5
6

order引數

flatten和flat屬性都支援order引數，該引數指定了陣列元素的儲存順序。預設情況下，order為 'C'，表示行優先儲存順序。如果設定為 'F'，則表示列優先儲存順序。

import numpy as np

# 建立一個2維陣列
myarr1 = np.array([[1, 2, 3], [4, 5, 6]])

# 使用flatten屬性，order='F'
myarr3 = myarr1.flatten(order='F')

print("flatten後的陣列（order='F'）:")
print(myarr3)

輸出：

flatten後的陣列（order='F'）:
[1 4 2 5 3 6]

總之，flatten和flat屬性是NumPy中非常有用的工具，允許您以不同的方式存取和操作多維陣列。瞭解它們的差異和用法可以幫助您更有效地使用NumPy進行資料分析和科學計算。

NumPy陣列的扁平化與拉直

NumPy提供了多種方法來扁平化和拉直陣列，包括flat、flatten和ravel。在本文中，我們將探討這些方法的差異和使用方式。

使用flat屬性

flat屬性傳回一個numpy.flatiter物件，它允許您迭代陣列的元素。以下是使用flat屬性的範例：

import numpy as np

my_array = np.arange(1, 7).reshape(2, 3)
print(my_array.flat)

for element in my_array.flat:
    print(element)

輸出：

<numpy.flatiter object at 0x000002C5D3984520>
1
2
3
4
5
6

如您所見，flat屬性傳回了一個迭代器物件，您可以使用它來迭代陣列的元素。

使用ravel方法

ravel方法傳回一個檢視（view），它是一個新的陣列物件，指向原始陣列的記憶體位置。這意味著，如果您修改原始陣列，檢視也會受到影響。以下是使用ravel方法的範例：

import numpy as np

my_array = np.arange(1, 7).reshape(2, 3)
my_ravel = my_array.ravel()

print("原始陣列：", my_array)
print("拉直陣列：", my_ravel)

my_ravel[0] = 11
print("修改後的原始陣列：", my_array)

輸出：

原始陣列： [[1 2 3]
 [4 5 6]]
拉直陣列： [1 2 3 4 5 6]
修改後的原始陣列： [[11  2  3]
 [ 4  5  6]]

如您所見，ravel方法傳回了一個檢視，當您修改檢視時，原始陣列也會受到影響。

圖表翻譯：

  graph LR
    A[原始陣列] -->|ravel|> B[拉直陣列]
    B -->|修改|> A
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style B fill:#f9f,stroke:#333,stroke-width:2px

此圖表顯示了原始陣列和拉直陣列之間的關係，以及修改拉直陣列如何影響原始陣列。

NumPy 陣列的 Ravel 方法

NumPy 的 ravel() 方法可以用來將多維陣列轉換為一維陣列。這個方法傳回一個檢視（view），而不是複製原始陣列。

Eg1：使用 Ravel 方法

首先，我們建立了一個 2x3 的二維陣列 myarr1，然後使用 ravel() 方法將其轉換為一維陣列 myarr2。

import numpy as np

myarr1 = np.array([[1, 2, 3], [4, 5, 6]])
myarr2 = myarr1.ravel()

print(f"myarr1 is {myarr1}")
print(f"myarr2 is {myarr2}")

輸出：

myarr1 is [[1 2 3]
 [4 5 6]]
myarr2 is [1 2 3 4 5 6]

如您所見，myarr2 是 myarr1 的一維版本。

Eg2：修改 Ravel 陣列

現在，我們將修改 myarr2 的某些元素，看看是否會影響到 myarr1。

myarr2[0] = 11

print(f"myarr1 after making changes to ravel array is {myarr1}")
print(f"myarr2 after making changes to ravel array is {myarr2}")

輸出：

myarr1 after making changes to ravel array is [[11 2 3]
 [ 4 5 6]]
myarr2 after making changes to ravel array is [11 2 3 4 5 6]

由於 myarr2 是 myarr1 的檢視，修改 myarr2 的元素也會影響到 myarr1。

Eg3：使用 Ravel 函式

最後，我們使用 np.ravel() 函式將一個 2x3 的二維陣列 myarr3 轉換為一維陣列 myarr4，並指定 order='F' 以使用 Fortran 順序。

myarr3 = np.arange(1, 7).reshape(2, 3)
myarr4 = np.ravel(myarr3, order='F')

print(f"myarr3 is {myarr3}")
print(f"myarr4 is {myarr4}")

輸出：

myarr3 is [[1 2 3]
 [4 5 6]]
myarr4 is [1 4 2 5 3 6]

在這個例子中，myarr4 是 myarr3 的一維版本，以 Fortran 順序排列。

圖表翻譯：

  flowchart TD
    A[原始陣列] --> B[使用 Ravel 方法]
    B --> C[一維陣列]
    C --> D[修改陣列元素]
    D --> E[影響原始陣列]
    E --> F[使用 Ravel 函式]
    F --> G[一維陣列（Fortran 順序）]

這個流程圖展示了 NumPy 陣列的 Ravel 方法如何將多維陣列轉換為一維陣列，並且如何修改陣列元素會影響到原始陣列。

3.5陣列轉置（Transpose）功能

陣列轉置是一種可以交換陣列維度的操作，傳回的是原始陣列的檢視，而不是建立一個新的陣列。使用T屬性，可以方便地取得陣列的轉置。

轉置函式語法

mynp.transpose(a, axis=None)

或

a.transpose(axis=None)

如果不指定axis引數，陣列的維度將被反轉，如下表所示：

轉置函式範例

以下範例展示了轉置函式的使用：

import numpy as mynp

# 範例1：非指定軸引數的2D陣列轉置
print("範例1：非指定軸引數的2D陣列轉置")
a = mynp.arange(1, 7).reshape(2, 3)
myarr1 = a.transpose()
print(f"原始陣列：\n{a}")
print(f"轉置陣列：\n{myarr1}")

# 範例2：指定軸引數的轉置
print("範例2：指定軸引數的轉置")

內容解密：

在上述範例中，我們首先建立了一個2D陣列a，然後使用transpose()函式取得其轉置myarr1。由於未指定axis引數，陣列的維度被反轉。接著，我們列印預出原始陣列和轉置陣列，以展示轉置的效果。

圖表翻譯：

  flowchart TD
    A[原始陣列] --> B[轉置函式]
    B --> C[轉置陣列]
    C --> D[列印結果]

在這個流程圖中，我們展示了原始陣列經過轉置函式後變成轉置陣列的過程，並最終列印預出結果。

3D 陣列轉置

在 NumPy 中，轉置是一種重新排列陣列維度的操作。對於 3D 陣列，轉置可以根據指定的軸順序進行。

使用 transpose 函式

首先，我們建立一個 3D 陣列 a，然後使用 transpose 函式將其轉置。axes 引數用於指定轉置後的軸順序。

import numpy as np

# 建立 3D 陣列
a = np.arange(1, 25).reshape(2, 3, 4)

# 轉置 3D 陣列
myarr2 = np.transpose(a, axes=(1, 2, 0))

print("原始 3D 陣列：\n", a)
print("轉置後的 3D 陣列：\n", myarr2)
print("原始 3D 陣列的形狀：\n", a.shape)
print("轉置後的 3D 陣列的形狀：\n", myarr2.shape)

使用 T 屬性

另外，我們可以使用 T 屬性來簡單地轉置陣列。這種方法等同於使用 transpose 函式，但更為方便。

# 建立 3D 陣列
a = np.arange(1, 25).reshape(2, 3, 4)

# 轉置 3D 陣列
myarr3 = a.T

print("轉置後的 3D 陣列：\n", myarr3)

在這兩個例子中，轉置後的陣列的形狀都變成了 (4, 3, 2)，這是因為原陣列的維度被重新排列了。

圖表翻譯：

  flowchart TD
    A[原始陣列] --> B[轉置操作]
    B --> C[轉置後陣列]
    C --> D[形狀變化]
    D --> E[結果輸出]

內容解密：

• np.arange(1, 25).reshape(2, 3, 4) 建立了一個 3D 陣列，包含 2 個 3x4 的矩陣。
• np.transpose(a, axes=(1, 2, 0)) 將陣列轉置，重新排列維度為 (1, 2, 0)，即 (3, 4, 2)。
• a.T 使用 T 屬性進行轉置，效果與上述相同。
• 轉置後的陣列形狀變為 (4, 3, 2)，表示維度被重新排列了。

高維陣列轉置：解析與實踐

在資料科學和機器學習中，高維陣列的操作是非常常見的。其中，轉置操作是一種基本但強大的工具，能夠幫助我們重新排列陣列中的元素，以便更好地理解和處理資料。在這篇文章中，我們將深入探討高維陣列轉置的概念，特別是當指定軸引數時的轉置操作。

什麼是轉置？

轉置是一種陣列操作，透過交換陣列的維度來重新排列其元素。對於二維陣列，轉置操作相當於將行和列互換。然而，當處理高維陣列（三維或更高維度）時，轉置操作就變得更加複雜，因為我們需要指定沿哪個軸進行轉置。

指定軸引數的轉置

當我們處理三維陣列時，轉置操作需要指定一個軸引數，以確定哪個維度應該被交換。例如，對於一個形狀為 (a, b, c) 的三維陣列，如果我們想要沿著軸 0 進行轉置，則結果將是一個形狀為 (b, c, a) 的陣列。如果我們想要沿著軸 1 進行轉置，則結果將是一個形狀為 (c, a, b) 的陣列。

實際案例：三維陣列轉置

讓我們考慮一個具體的例子。假設我們有一個三維陣列，其形狀為 (2, 3, 4)，如下所示：

import numpy as np

# 原始 3-D 陣列
original_array = np.array([
    [[1, 2, 3, 4],
     [5, 6, 7, 8],
     [9, 10, 11, 12]],
    [[13, 14, 15, 16],
     [17, 18, 19, 20],
     [21, 22, 23, 24]]
])

如果我們想要沿著軸 0 進行轉置，則結果將是一個形狀為 (3, 4, 2) 的陣列，如下所示：

# 轉置後的 3-D 陣列（沿軸 0）
transposed_array_axis_0 = np.transpose(original_array, (1, 2, 0))
print(transposed_array_axis_0.shape)  # (3, 4, 2)

同樣，如果我們想要沿著軸 1 進行轉置，則結果將是一個形狀為 (4, 2, 3) 的陣列，如下所示：

# 轉置後的 3-D 陣列（沿軸 1）
transposed_array_axis_1 = np.transpose(original_array, (2, 0, 1))
print(transposed_array_axis_1.shape)  # (4, 2, 3)

內容解密：

在上述例子中，我們使用了 NumPy 的 transpose 函式來進行陣列轉置。該函式接受兩個引數：原始陣列和軸引數。軸引數是一個元組，指定了轉置後的維度順序。例如，(1, 2, 0) 表示原始陣列的第二個維度（索引 1）應該變成第一個維度，第三個維度（索引 2）應該變成第二個維度，而第一個維度（索引 0）應該變成第三個維度。

圖表翻譯：

下面的 Mermaid 圖表展示了三維陣列轉置的過程：

  flowchart TD
    A[原始 3-D 陣列] --> B[轉置操作]
    B --> C[轉置後的 3-D 陣列]
    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

圖表翻譯：

這個圖表顯示了原始三維陣列經過轉置操作後變成新的三維陣列的過程。轉置操作根據指定的軸引數重新排列了原始陣列中的元素，以產生新的陣列結構。

瞭解陣列轉置的概念

在進行資料分析或科學計算時，陣列轉置是一種常見的操作。轉置是指將陣列的維度進行交換，例如將一個3維陣列的第一維和第二維進行交換。

原始3維陣列

原始3維陣列的形狀為(2, 3, 4)，表示它有2個子陣列，每個子陣列又包含3個子子陣列，而每個子子陣列包含4個元素。

import numpy as np

# 定義原始3維陣列
original_array = np.array([
    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
    [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]
])

轉置3維陣列

轉置後的3維陣列形狀變為(3, 4, 2)，這意味著第一維和第二維進行了交換。現在，每個子陣列包含4個子子陣列，而每個子子陣列包含2個元素。

# 進行轉置操作
transposed_array = original_array.transpose((1, 2, 0))

Eg3 使用 T 變數

使用 T 變數進行轉置操作，可以得到相同的結果。

# 使用 T 變數進行轉置
T = original_array.transpose((1, 2, 0))

結果比較

原始陣列和轉置後的陣列之間的差異在於維度的排列順序。轉置操作使得原始陣列的第一維和第二維進行了交換，從而得到了一個新的陣列結構。

print("原始陣列形狀：", original_array.shape)
print("轉置後陣列形狀：", transposed_array.shape)

內容解密

在上述程式碼中，我們使用了 NumPy 的 transpose 函式來進行陣列轉置操作。這個函式可以根據指定的軸順序來進行轉置。透過這種方式，我們可以輕鬆地實作陣列的轉置，並得到所需的結果。

圖表翻譯

下面是使用 Mermaid 語法繪製的轉置過程圖表：

  graph LR
    A[原始陣列] -->|轉置|> B[轉置後陣列]
    B -->|維度交換|> C[新的陣列結構]
    C -->|結果|> D[轉置後陣列形狀]

這個圖表展示了原始陣列到轉置後陣列的轉換過程，包括維度的交換和新的陣列結構的形成。

從底層實作到高階應用的全面檢視顯示，NumPy 的 flatten、flat 和 ravel 方法，以及陣列轉置功能，為多維陣列操作提供了強大的工具。flatten 建立陣列的副本，而 flat 提供迭代器，ravel 則傳回陣列的檢視，修改檢視會影響原始陣列。透過 order 引數，可以控制扁平化時的元素順序。陣列轉置，透過 .T 屬性或 transpose() 函式，可以靈活地交換陣列維度，尤其在處理高維陣列時，axes 引數允許精確控制維度排列。然而，需要注意的是，轉置操作傳回的是檢視，直接修改會影響原始陣列。對於需要頻繁操作大型陣列的應用，理解這些方法的差異和特性，對於有效管理記憶體和提升效能至關重要。玄貓認為，熟練掌握這些技巧，能大幅提升開發者處理複雜資料結構的效率，並在資料科學、機器學習等領域發揮關鍵作用。