NumPy陣列技術詳解與Python應用

– 20 分鐘閱讀

NumPy 提供了 ndarray 資料結構，專為數值運算設計，比原生 Python 列表更高效。它支援向量運算、廣播機制，並整合了大量數學函式，是機器學習、資料分析等領域的基礎工具。理解 ndarray 的建立、索引、切片、運算等操作，對於高效處理資料至關重要。不同維度的 ndarray（例如一維向量、二維矩陣、三維張量）各有應用場景，需要根據實際需求選擇。此外，NumPy 的資料型別和型別轉換機制，也有助於提升程式碼效能和穩定性。

探索NumPy函式庫：Python資料科學的基本

簡介

在Python資料科學領域中，開源函式庫扮演著重要角色。本章將深入探討NumPy函式庫，這是一個為資料科學和機器學習提供強大支援的函式庫。NumPy，全稱為Numerical Python，主要用於複雜的數學運算，如陣列建立、操作、微分、統計和積分計算等。這些功能是Python基本數學運算所不能提供的。

NumPy引入了多維陣列（ndarray）作為其基礎資料結構。由於NumPy同時使用Python和C語言編寫，因此能夠提供高效能的資料處理能力，使其成為機器學習演算法中高效資料結構的最佳選擇。NumPy中的資料以陣列格式儲存，並提供了一種名為ndarrays的陣列資料結構。透過pip安裝命令pip install numpy即可輕鬆安裝NumPy。

章節結構

本章將涵蓋以下主題：

  1. NumPy與Python列表的共同點和區別：瞭解NumPy陣列和Python列表之間的相似性和差異。
  2. 存取ndarray元素：學習如何存取和操作ndarray中的元素。
  3. 遍歷ndarray元素：掌握遍歷ndarray中元素的方法。
  4. NumPy中的算術運運算元：瞭解如何在NumPy中使用算術運運算元進行資料操作。
  5. 廣播概念在NumPy中：深入理解NumPy中的廣播機制及其應用。

目標

透過本章的學習，讀者將對比Python列表和NumPy陣列有更深入的理解，並掌握建立ndarrays的不同方法，包括使用列表和元組資料結構。同時，讀者還將學習到如何存取、遍歷和操作ndarray中的元素，以及如何使用NumPy中的算術運運算元和廣播概念進行高效的資料處理。

NumPy安裝

要開始使用NumPy，只需在終端或命令提示符中執行pip install numpy即可完成安裝。安裝完成後，您就可以在Python環境中匯入並使用NumPy函式庫了。

import numpy as np

建立ndarrays

可以透過多種方式建立ndarrays，包括從Python列表或元組建立。以下是從列表建立ndarray的示例：

# 建立一個Python列表
my_list = [1, 2, 3, 4, 5]

# 從列表建立一個ndarray
my_array = np.array(my_list)

print(my_array)  # 輸出：[1 2 3 4 5]

存取ndarray元素

可以透過索引來存取ndarray中的元素。索引從0開始，類別似於Python列表。

# 建立一個ndarray
my_array = np.array([1, 2, 3, 4, 5])

# 存取第一個元素
print(my_array[0])  # 輸出：1

# 存取最後一個元素
print(my_array[-1])  # 輸出：5

遍歷ndarray元素

可以使用迴圈來遍歷ndarray中的元素。

# 建立一個ndarray
my_array = np.array([1, 2, 3, 4, 5])

# 遍歷ndarray中的元素
for element in my_array:
    print(element)

NumPy中的算術運運算元

NumPy支援各種算術運運算元，可以對ndarrays進行元素級別的運算。

# 建立兩個ndarrays
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])

# 進行加法運算
result = array1 + array2

print(result)  # 輸出：[5 7 9]

廣播概念在NumPy中

廣播是NumPy的一個強大功能，允許對不同形狀的ndarrays進行運算。

# 建立兩個ndarrays
array1 = np.array([1, 2, 3])
array2 = np.array([4])

# 進行加法運算，利用廣播機制
result = array1 + array2

print(result)  # 輸出：[5 6 7]

透過本章的學習，讀者已經掌握了NumPy函式庫的基礎知識，包括建立和操作ndarrays、使用算術運運算元以及廣播概念。這些知識將為後續的資料科學和機器學習應用打下堅實的基礎。

NumPy 底層原理與應用

NumPy（Numerical Python）是一個強大的Python函式庫，提供了高效的數值計算能力。它的核心是ndarray（n維陣列），是一種多維度的陣列結構，可以儲存同型別的資料。

NumPy 與 Python 列表的比較

NumPy 與 Python 列表有一些相似之處，但也存在著明顯的差異。以下是兩者的共同點和不同點：

共同點

  • 都可以儲存資料
  • 都保留元素的順序，允許索引和切片操作
  • 都是可變的，意味著其內容可以被修改

差異點

  • NumPy 需要明確安裝，而 Python 列表是內建的
  • NumPy 陣列包含相同型別的元素，而 Python 列表可以包含不同型別的元素
  • NumPy 陣列支援向量運算，而 Python 列表不支援

向量運算

NumPy 陣列支援向量運算，這意味著您可以對整個陣列執行運算，而不需要使用迴圈。以下是一個示例：

import numpy as np

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

# 對陣列執行向量運算
result = arr + 2

print(result)  # 輸出：[3 4 5 6 7]

記憶體使用

NumPy 陣列比 Python 列表使用更少的記憶體。以下是一個示例：

import numpy as np
import sys

# 建立一個 Python 列表
lst = [1, 2, 3, 4, 5]

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

# 比較記憶體使用
print(sys.getsizeof(lst))  # 輸出：120
print(sys.getsizeof(arr))  # 輸出：96
圖表翻譯：
  graph LR
    A[NumPy] -->|支援向量運算|> B[高效數值計算]
    A -->|記憶體使用少|> C[高效記憶體使用]
    B -->|提高程式碼效率|> D[程式碼最佳化]
    C -->|提高程式碼效率|> D

內容解密：

上述程式碼示例展示瞭如何使用 NumPy 進行向量運算和比較記憶體使用。透過使用 NumPy，您可以提高您的程式碼的效率和可讀性。記憶體使用是程式碼最佳化的一個重要方面，透過使用 NumPy，您可以減少記憶體使用並提高程式碼的效率。

效能比較：陣列與列表

在進行資料處理時，選擇合適的資料結構是非常重要的。Python 中的列表（list）和 NumPy 陣列（ndarray）都是用於儲存多個元素的資料結構，但它們在效能和空間佔用方面有所不同。

空間佔用比較

首先，我們來比較一下列表和 NumPy 陣列的空間佔用。下面的程式碼建立了一個範圍從 11 到 30 的列表和 NumPy 陣列，並計算了它們的大小：

import numpy as np
import sys

my_list = [loop for loop in range(11, 31)]
my_ndarray = np.array(my_list)

print('The List size is --> ', sys.getsizeof(my_list))
print('The ndarray size is --> ', sys.getsizeof(my_ndarray))

輸出結果顯示，列表的大小約為 248 bytes，而 NumPy 陣列的大小約為 192 bytes。這表明 NumPy 陣列在空間佔用方面更為節省。

速度比較

除了空間佔用外，NumPy 陣列還具有更快的運算速度。下面的程式碼比較了使用傳統 Python 程式碼和 NumPy 陣列進行點積運算的速度：

import numpy as np
from datetime import datetime

my_arr_1 = np.array([14, 15, 16])
my_arr_2 = np.array([11, 12, 13])

def my_dot_product(my_arr_1, my_arr_2):
    my_result = 0
    for _x, _y in zip(my_arr_1, my_arr_2):
        my_result += _x * _y
    return my_result

my_before_time = datetime.now()
my_dot_product(my_arr_1, my_arr_2)
my_after_time = datetime.now()

print('傳統 Python 程式碼運算時間：', my_after_time - my_before_time)

my_before_time = datetime.now()
np.dot(my_arr_1, my_arr_2)
my_after_time = datetime.now()

print('NumPy 陣列運算時間：', my_after_time - my_before_time)

結果顯示，NumPy 陣列的運算速度遠超過傳統 Python 程式碼。

圖表翻譯：

  flowchart TD
    A[開始] --> B[建立列表和 NumPy 陣列]
    B --> C[計算大小]
    C --> D[比較空間佔用]
    D --> E[進行點積運算]
    E --> F[比較運算速度]
    F --> G[輸出結果]

內容解密：

上述程式碼首先匯入了必要的模組，包括 numpy 和 sys。然後，建立了一個範圍從 11 到 30 的列表和 NumPy 陣列。接著，計算了它們的大小，並將結果輸出。之後，定義了一個函式 my_dot_product，用於計算兩個陣列的點積。然後，比較了使用傳統 Python 程式碼和 NumPy 陣列進行點積運算的速度。

使用NumPy進行矩陣運算的效能比較

在進行矩陣運算時，使用NumPy函式庫可以大大提高效能。下面是一個簡單的例子，比較了使用傳統Python方法和使用NumPy函式庫進行矩陣運算的效能差異。

import numpy as np
import datetime

# 定義兩個矩陣
myarr_1 = np.array([1, 2, 3])
myarr_2 = np.array([4, 5, 6])

# 記錄開始時間
mybefore_time = datetime.datetime.now()

# 使用傳統Python方法進行矩陣運算
for myloop in range(2000000):
    my_dot_product = sum(a * b for a, b in zip(myarr_1, myarr_2))

# 記錄結束時間
myafter_time = datetime.datetime.now()

# 輸出執行時間
print('使用傳統Python方法的執行時間：', myafter_time - mybefore_time)

# 記錄開始時間
mybefore2_time = datetime.datetime.now()

# 使用NumPy函式庫進行矩陣運算
for my_loop in range(2000000):
    mynp_dot = np.dot(myarr_1, myarr_2)

# 記錄結束時間
myafter2_time = datetime.datetime.now()

# 輸出執行時間
print('使用NumPy函式庫的執行時間：', myafter2_time - mybefore2_time)

NumPy陣列的建立

NumPy陣列是NumPy函式庫的核心資料結構。建立NumPy陣列的過程涉及選擇適合的方法，以滿足所需的陣列結構和內容。下面是建立一維陣列的例子：

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

內容解密：

上述程式碼建立了一維NumPy陣列my_array，其中包含五個元素：1、2、3、4和5。np.array()函式用於建立NumPy陣列，括號內的列表定義了陣列的元素。

圖表翻譯：

  graph LR
    A[建立NumPy陣列] --> B[選擇適合的方法]
    B --> C[定義陣列結構和內容]
    C --> D[使用np.array()函式]
    D --> E[建立一維陣列]

圖表翻譯：

上述Mermaid圖表展示了建立NumPy陣列的過程。首先，選擇適合的方法以滿足所需的陣列結構和內容。然後，使用np.array()函式建立一維陣列。這個圖表簡單地展示了NumPy陣列建立的基本步驟。

使用NumPy建立一維陣列

NumPy是一個強大的Python函式庫，提供了多維陣列和矩陣的支援。以下是使用NumPy建立一維陣列的示例。

從列表建立一維陣列

首先，我們可以從一個列表建立一維陣列。以下是示例程式碼：

import numpy as np

my_list = [113, 213, 313, 413, 567]
my_array = np.array(my_list)

print("my_list type is: ", type(my_list))
print("my_array type is: ", type(my_array))
print("my_array: ", my_array)
print("Array dimensions: ", my_array.ndim)
print("Data type of array elements: ", my_array.dtype)
print("Array size: ", my_array.size)
print("Array shape: ", my_array.shape)

輸出結果：

my_list type is:  <class 'list'>
my_array type is:  <class 'numpy.ndarray'>
my_array:  [113 213 313 413 567]
Array dimensions:  1
Data type of array elements:  int32
Array size:  5
Array shape:  (5,)

從元組建立一維陣列

我們也可以從一個元組建立一維陣列。以下是示例程式碼：

import numpy as np

my_tuple = ('Ric', 'Pic', 'Tic', 'Mic')
my_array = np.array(my_tuple)

print("my_tuple type is: ", type(my_tuple))
print("my_array type is: ", type(my_array))
print("my_array: ", my_array)
print("Array dimensions: ", my_array.ndim)
print("Data type of array elements: ", my_array.dtype)
print("Array size: ", my_array.size)
print("Array shape: ", my_array.shape)

輸出結果：

my_tuple type is:  <class 'tuple'>
my_array type is:  <class 'numpy.ndarray'>
my_array:  ['Ric' 'Pic' 'Tic' 'Mic']
Array dimensions:  1
Data type of array elements:  <U3
Array size:  4
Array shape:  (4,)

注意，在第二個示例中，元組中的元素是字串，因此建立的陣列的資料型別是 <U3，表示每個元素都是長度為3的Unicode字串。

內容解密：

  • np.array()函式用於建立NumPy陣列。
  • ndim屬性傳回陣列的維度數。
  • dtype屬性傳回陣列元素的資料型別。
  • size屬性傳回陣列中的元素數量。
  • shape屬性傳回陣列的形狀，作為一個元組。

圖表翻譯：

  flowchart TD
    A[建立列表或元組] --> B[使用np.array()函式建立NumPy陣列]
    B --> C[傳回陣列的維度數、資料型別、大小和形狀]
    C --> D[使用ndim、dtype、size和shape屬性存取陣列資訊]

這個流程圖展示了建立NumPy陣列的步驟，從建立列表或元組開始，然後使用 np.array() 函式建立NumPy陣列，最後傳回陣列的維度數、資料型別、大小和形狀。

使用NumPy建立陣列

NumPy是一個強大的Python函式庫，提供了高效的數值計算功能。以下是使用NumPy建立陣列的示例。

建立一維陣列

首先，我們可以使用numpy.array()函式建立一維陣列。這個函式可以接受多種型別的輸入，包括列表和元組。

import numpy as np

my_tuple = ('Ric', 'Pic', 'Tic', 'Mic')
my_nd_arr = np.array(my_tuple)

print('my_nd_arr type is: --> ' + str(type(my_nd_arr)))
print('my_nd_arr --> ' + str(my_nd_arr))

輸出：

my_nd_arr type is: --> <class 'numpy.ndarray'>
my_nd_arr --> ['Ric' 'Pic' 'Tic' 'Mic']

建立二維陣列

接下來，我們可以使用巢狀列表建立二維陣列。

my_nested_list = [[105, 205, 305], [405, 505, 605], [705, 805, 905], [1005, 1105, 1205]]
my_nd_arr = np.array(my_nested_list)

print('my_nd_arr type is: --> ' + str(type(my_nd_arr)))
print('my_nd_arr --> ' + str(my_nd_arr))
print('The array dimensions is: ' + str(my_nd_arr.ndim))
print('The data type of array elements is: ' + str(my_nd_arr.dtype))
print('The array size is: ' + str(my_nd_arr.size))
print('The array shape is: ' + str(my_nd_arr.shape))

輸出：

my_nd_arr type is: --> <class 'numpy.ndarray'>
my_nd_arr --> [[105 205 305]
 [405 505 605]
 [705 805 905]
 [1005 1105 1205]]
The array dimensions is: 2
The data type of array elements is: int64
The array size is: 12
The array shape is: (4, 3)

在這個例子中，我們建立了一個二維陣列my_nd_arr，它包含四行三列的元素。輸出顯示了陣列的型別、維度、資料型別、大小和形狀。

圖表翻譯

以下是使用Mermaid語法建立的流程圖，展示了建立NumPy陣列的步驟：

  flowchart TD
    A[建立列表或元組] --> B[使用numpy.array()函式]
    B --> C[建立NumPy陣列]
    C --> D[取得陣列屬性]
    D --> E[輸出陣列資訊]

這個流程圖展示了建立NumPy陣列的步驟，從建立列表或元組開始，然後使用numpy.array()函式建立NumPy陣列，最後取得陣列屬性並輸出陣列資訊。

瞭解 NumPy 陣列的基本屬性

NumPy 陣列（ndarrays）是一種多維度的同型別資料結構。下面是一個示例，展示瞭如何建立和操作 NumPy 陣列。

import numpy as np

# 建立一個 NumPy 陣列
my_arr = np.array([[105, 205, 305], [405, 505, 605], [705, 805, 905], [1005, 1105, 1205]])

print("my_arr type is: ", type(my_arr))
print("my_arr -->\n", my_arr)

# 取得陣列的維度
print("The array dimensions is: ", my_arr.ndim)

# 取得陣列元素的資料型別
print("The data type of array elements is : ", my_arr.dtype)

# 取得陣列的大小
print("The array size is : ", my_arr.size)

# 取得陣列的形狀
print("The array shape is : ", my_arr.shape)

陣列元素的資料型別

NumPy 陣列中的所有元素必須是相同的資料型別。如果建立陣列時提供的列表包含不同資料型別的元素，NumPy 會進行上轉換（upcasting），以確保所有元素都是相同的資料型別。

# 建立一個包含不同資料型別元素的列表
my_list = [201, 301, 420.5]

# 建立 NumPy 陣列，並進行上轉換
my_arr = np.array(my_list)

print("my_arr --> ", my_arr)
print("Elements data type is --> ", my_arr.dtype)

指定資料型別建立陣列

可以使用 dtype 引數指定建立 NumPy 陣列的資料型別。

# 指定資料型別建立 NumPy 陣列
my_arr = np.array([1, 2, 3], dtype=np.float64)

print("my_arr --> ", my_arr)
print("Elements data type is --> ", my_arr.dtype)

內容解密：

  1. 建立 NumPy 陣列：使用 np.array() 函式建立 NumPy 陣列，可以從列表或其他可迭代物件建立。
  2. 陣列屬性：NumPy 陣列具有多個屬性，例如 ndim、dtype、size 和 shape，可以用於取得陣列的維度、元素資料型別、大小和形狀。
  3. 上轉換：當建立 NumPy 陣列時，如果提供的列表包含不同資料型別的元素，NumPy 會進行上轉換，以確保所有元素都是相同的資料型別。
  4. 指定資料型別：可以使用 dtype 引數指定建立 NumPy 陣列的資料型別。

圖表翻譯：

  flowchart TD
    A[建立 NumPy 陣列] --> B[取得陣列屬性]
    B --> C[上轉換]
    C --> D[指定資料型別]
    D --> E[建立指定資料型別的陣列]

圖表說明：

  • 建立 NumPy 陣列：從列表或其他可迭代物件建立 NumPy 陣列。
  • 取得陣列屬性：取得陣列的維度、元素資料型別、大小和形狀。
  • 上轉換：當建立 NumPy 陣列時，如果提供的列表包含不同資料型別的元素，NumPy 會進行上轉換。
  • 指定資料型別：使用 dtype 引數指定建立 NumPy 陣列的資料型別。

資料型別與NumPy陣列

在使用NumPy時，瞭解資料型別的重要性不言而喻。NumPy提供了多種資料型別，包括整數（int）、浮點數（float）、布林值（bool）、複數（complex）和字串（str）。每種資料型別都有其特定的用途和限制。

整數型別（int）

當建立一個NumPy陣列時，可以指定其資料型別為整數。例如：

import numpy as np

my_arr = np.array([101, 201, 410, 0], dtype=int)
print(my_arr)

輸出：

[101 201 410 0]

如上所示，當資料型別設為整數時，所有元素都將被轉換為整數。

浮點數型別（float）

同樣地，可以指定資料型別為浮點數。例如：

my_arr = np.array([101, 201, 410.8, 0], dtype=float)
print(my_arr)

輸出：

[101. 201. 410.8 0.]

這裡，所有元素都被轉換為浮點數。

布林值型別（bool）

布林值是一種特殊的資料型別，用於表示真或假。例如：

my_arr = np.array([101, 201, 410.8, 0, '', 'BoolType', 'False'], dtype=bool)
print(my_arr)

輸出：

[ True False False True True]

注意，非空字串和非零數值都被視為True，而空字串和零則被視為False。

複數型別（complex）

複數是一種資料型別，用於表示具有實部和虛部的數值。例如：

my_arr = np.array([101, 201, 410.8, 0], dtype=complex)
print(my_arr)

輸出：

[101.+0.j 201.+0.j 410.8+0.j 0.+0.j]

這裡，所有元素都被轉換為複數，實部和虛部均為0。

字串型別（str）

最後，可以指定資料型別為字串。例如：

my_arr = np.array([101, 201, 410.8, 0], dtype=str)
print(my_arr)

輸出：

['101' '201' '410.8' '0']

這裡，所有元素都被轉換為字串。

物件型別（object）

NumPy還提供了一種物件型別，可以用於儲存不同型別的資料。例如：

my_arr = np.array([410, 'Yathartha', 410.5, True, 3+7j, False], dtype=object)
print(my_arr)

這裡，陣列中包含了整數、字串、浮點數、布林值和複數等不同型別的資料。

總之，NumPy提供了多種資料型別，可以根據具體需求選擇合適的型別。同時，理解每種資料型別的特點和限制對於有效地使用NumPy至關重要。

使用NumPy建立多維陣列

NumPy是一個強大的Python函式庫，提供了多維陣列的支援。以下是使用NumPy建立多維陣列的範例。

建立一維陣列

首先，我們可以使用numpy.array()函式建立一維陣列。以下是範例：

import numpy as np

my_arr = np.array([410, 'Yathartha', 410.5, True, (3+7j), False], dtype=object)

print(my_arr)
print('The elements data type of my_arr is:' + str(my_arr.dtype))

輸出：

[410 'Yathartha' 410.5 True (3+7j) False]
The elements data type of my_arr is: object

如您所見，numpy.array()函式可以建立一維陣列，並且可以包含不同型別的元素。

建立一維陣列使用arange()函式

另外，我們可以使用numpy.arange()函式建立一維陣列。以下是範例：

import numpy as np

my_arr = np.arange(7)

print('my_arr is:' + str(my_arr))
print('The array dimensions is: ' + str(my_arr.ndim))
print('The data type of elements of array is : ' + str(my_arr.dtype))
print('The array size is : ' + str(my_arr.size))
print('The array shape is : ' + str(my_arr.shape))

輸出：

my_arr is:[0 1 2 3 4 5 6]
The array dimensions is: 1
The data type of elements of array is : int64
The array size is : 7
The array shape is : (7,)

如您所見，numpy.arange()函式可以建立一維陣列，並且可以指定陣列的大小。

建立多維陣列

最後，我們可以使用numpy.array()函式建立多維陣列。以下是範例：

import numpy as np

my_arr = np.array([[1, 2, 3], [4, 5, 6]])

print(my_arr)
print('The array dimensions is: ' + str(my_arr.ndim))
print('The data type of elements of array is : ' + str(my_arr.dtype))
print('The array size is : ' + str(my_arr.size))
print('The array shape is : ' + str(my_arr.shape))

輸出：

[[1 2 3]
 [4 5 6]]
The array dimensions is: 2
The data type of elements of array is : int64
The array size is : 6
The array shape is : (2, 3)

如您所見，numpy.array()函式可以建立多維陣列，並且可以指定陣列的大小和形狀。

圖表翻譯：

以下是使用Mermaid語法繪製的圖表，展示了NumPy陣列的結構：

  graph LR
    A[NumPy Array] --> B[一維陣列]
    A --> C[多維陣列]
    B --> D[arange()函式]
    C --> E[ndim、dtype、size、shape屬性]

如您所見，圖表展示了NumPy陣列的結構，並且指出了相關的屬性和函式。

NumPy陣列屬性與建立

NumPy（Numerical Python）是一個強大的Python函式庫，主要用於數值運算。它提供了多維陣列和矩陣資料結構，以及一系列高效的數值運算工具。理解NumPy陣列的屬性和建立方法是使用NumPy進行數值運算的基礎。

建立NumPy陣列

NumPy提供了多種建立陣列的方法，包括使用numpy.arange()、numpy.array()等函式。以下是使用numpy.arange()建立陣列的示例：

import numpy as np

# 建立一個從1到6（不含6），步長為2的陣列
mynd_arr1 = np.arange(1, 7, 2)
print('mynd_arr1 is:' + str(mynd_arr1))

# 建立一個從1到7（不含7），步長為2的陣列
mynd_arr2 = np.arange(1, 7, 2)
print('mynd_arr2 is:' + str(mynd_arr2))

# 建立一個從1到7（不含7），步長為3，資料型別為float的陣列
mynd_arr3 = np.arange(1, 7, 3, dtype=float)
print('mynd_arr3 is:' + str(mynd_arr3))

陣列屬性

NumPy陣列有一些重要的屬性，包括：

  • ndim: 陣列的維度數。
  • dtype: 陣列中元素的資料型別。
  • size: 陣列中元素的總數。
  • shape: 陣列的形狀，描述了陣列每個維度的大小。

以下是如何存取這些屬性的示例：

print('The array dimensions is: ' + str(mynd_arr1.ndim))
print('The data type of elements of array is : ' + str(mynd_arr1.dtype))
print('The array size is : ' + str(mynd_arr1.size))
print('The array shape is : ' + str(mynd_arr1.shape))

圖表翻譯：

  flowchart TD
    A[建立陣列] --> B[設定陣列屬性]
    B --> C[存取陣列屬性]
    C --> D[進行數值運算]

內容解密：

上述程式碼示例展示瞭如何使用numpy.arange()建立NumPy陣列，並存取陣列的屬性。這些屬性對於理解和操作NumPy陣列至關重要。在進行數值運算時，瞭解陣列的維度、資料型別、大小和形狀可以幫助您更好地控制和最佳化您的程式碼。

使用 NumPy 的 linspace 函式建立陣列

NumPy 的 linspace 函式可以用來建立一個等距分佈的陣列。這個函式的語法如下：

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

以下是 linspace 函式的一些引數解釋：

  • start: 可選引數，預設值為 0，表示間隔範圍的開始。
  • stop: 表示間隔範圍的結束。
  • num: 可選引數，表示要生成的樣本數。
  • endpoint: 如果設為 False，則結束值不包含在間隔中，並且間隔是透過 (stop-start) / num 計算得出的。當設為 True 時，間隔是透過 (stop-start) / (num - 1) 計算得出的。
  • retstep: 如果設為 True，則傳回間隔之間的步長，預設值為 False。
  • dtype: 指定輸出陣列的型別。

以下是一個示例程式，展示瞭如何使用 linspace 函式：

import numpy as np

# 建立一個等距分佈的陣列，範圍從 0 到 10，樣本數為 5
arr = np.linspace(0, 10, 5)
print(arr)

# 輸出：[ 0.  2.5 5.  7.5 10. ]

在這個示例中，我們建立了一個等距分佈的陣列，範圍從 0 到 10，樣本數為 5。輸出結果是一個包含 5 個元素的陣列，每個元素之間的間隔都是 2.5。

示例程式：Chap2_Example2.12.py

以下是示例程式 Chap2_Example2.12.py 的內容：

import numpy as np

# 建立一個等距分佈的陣列，範圍從 0 到 10，樣本數為 50
arr = np.linspace(0, 10, 50)
print(arr)

# 輸出：[ 0.  0.20408163 0.40816327... 9.59183673 10.        ]

在這個示例中，我們建立了一個等距分佈的陣列，範圍從 0 到 10，樣本數為 50。輸出結果是一個包含 50 個元素的陣列，每個元素之間的間隔都是 0.20408163。

使用NumPy的linspace功能生成等間距數值

NumPy的linspace功能是一種用於生成等間距數值的方法，能夠根據指定的起始值、結束值、數值個數以及是否包含結束值等引數，生成一系列等間距的數值。

基本使用方法

首先，我們來看一下基本的使用方法。假設我們想要生成0到2之間的數值，包含0和2，則可以使用以下程式碼：

import numpy as np

print(np.linspace(0, 2))

這將輸出從0到2之間的50個等間距數值，包括0和2。

指定數值個數

如果我們想要指定生成的數值個數，可以使用以下程式碼：

print(np.linspace(0, 2, 3))

這將輸出從0到2之間的3個等間距數值，包括0和2。

排除結束值

如果我們想要生成從0到2之間的數值，但不包括2，可以使用以下程式碼：

print(np.linspace(0, 2, 3, endpoint=False))

這將輸出從0到2之間的3個等間距數值，包括0但不包括2。

傳回間距

如果我們想要傳回間距，可以使用以下程式碼：

print(np.linspace(0, 2, 3, endpoint=False, retstep=True))

這將輸出從0到2之間的3個等間距數值，包括0但不包括2，並傳回間距。

指定資料型別和間距

如果我們想要生成從2到50之間的5個等間距整數，並傳回間距，可以使用以下程式碼：

print(np.linspace(2, 50, 5, dtype=int, retstep=True))

這將輸出從2到50之間的5個等間距整數，包括2和50，並傳回間距。

內容解密：

上述程式碼中，我們使用了NumPy的linspace功能來生成等間距數值。這個功能可以根據指定的引數生成一系列等間距的數值。其中，endpoint引數用於指定是否包含結束值，retstep引數用於指定是否傳回間距，dtype引數用於指定生成數值的資料型別。

圖表翻譯：

  flowchart TD
    A[開始] --> B[生成等間距數值]
    B --> C[指定引數]
    C --> D[傳回結果]
    D --> E[結束]

上述圖表展示了使用NumPy的linspace功能生成等間距數值的流程。首先，我們開始使用linspace功能，然後指定所需的引數，接著傳回生成的等間距數值，最後結束程式。

NumPy陣列與維度

NumPy是一個強大的Python函式庫，提供了高效的數值計算功能。其中，陣列（array）是NumPy的核心資料結構。陣列可以是多維的，維度（dimension）代表了陣列的結構層次。

陣列維度

  • 0-D陣列：是一個單一的數值，常被稱為標量（scalar）。
  • 1-D陣列：是一個向量（vector），由多個0-D陣列組成。
  • 2-D陣列：是一個矩陣（matrix），由多個1-D陣列組成。
  • 3-D陣列：由多個2-D陣列組成，形成一個三維結構。

陣列大小與形狀

  • (20,) 代表一個1-D陣列，包含20個元素。
  • (10, 2) 代表一個2-D陣列，有10行和2列。
  • (1, 2, 3) 代表一個3-D陣列，包含1個2-D陣列，每個2-D陣列有2行和3列。其大小計算為 1 * 2 * 3 = 6。

使用NumPy的zeros()函式

zeros()函式可以建立指定形狀和大小的陣列，並用零填充。以下是使用zeros()函式的範例：

import numpy as np

# 建立1-D陣列，包含4個零
print(np.zeros(4))
print('-'*50)

# 建立2-D陣列，4x4大小，填充零
print(np.zeros((4, 4)))
print('-'*50)

# 建立3-D陣列，2x3x2大小，填充零
print(np.zeros((2, 3, 2)))
print('-'*50)

# 建立4-D陣列
print(np.zeros((1, 2, 3, 4)))

NumPy 多維陣列初始化

在進行數值計算時，經常需要初始化多維陣列。NumPy 提供了 zeros 函式來建立多維陣列，並將所有元素初始化為 0。

從底層實作到高階應用的全面檢視顯示，NumPy 作為 Python 資料科學的基本，其效能優勢和豐富功能不容忽視。透過多維度效能指標的實測分析，NumPy 陣列在空間佔用和運算速度上均優於 Python 列表，尤其在矩陣運算等場景中，效能提升顯著。技術堆疊的各層級協同運作中體現，NumPy 提供了linspace、arange、zeros等多樣化的陣列建立方法，方便開發者根據不同需求初始化和操作陣列，從而提升程式碼效率。雖然 NumPy 的學習曲線較 Python 列表陡峭，但對於需要處理大量數值資料的應用而言，其帶來的效能提升和便捷性遠超學習成本。技術團隊應著重於掌握 NumPy 陣列的屬性、資料型別以及多維陣列的操作技巧，才能釋放此技術的完整潛力。接下來的 2-3 年，隨著資料科學和機器學習的持續發展，我們預見 NumPy 的應用場景將進一步擴充套件，並與其他資料科學工具深度整合，成為資料處理領域不可或缺的核心元件。

玄貓

玄貓

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