【深度學習①】 | Numpy數組篇

0 序言

本文為NumPy數組庫的系統學習筆記，將自己先前的筆記做一個總結歸納。內容涵蓋數組基礎、創建、索引、變形、運算、函數、布爾型數組及與張量的銜接等內容。通過具體示例解析核心概念與操作，幫助讀者掌握NumPy的使用邏輯與方法，為后續深度學習中數據處理打下基礎，讀完可獨立完成數組的創建、操作及與張量的轉換。

使用的Python版本為3.12
NumPy版本為2.2.4
代碼編輯器為VsCode

1 數組基礎

數組作為NumPy的核心數據結構，其基礎特性直接決定了后續復雜操作的實現邏輯。要熟練運用NumPy數組，首先需要掌握其最根本的屬性——數據類型與維度。

數據類型決定了數組中元素的存儲形式和運算規則，整數型與浮點型數組的區分、元素插入時的同化特性，以及類型間的轉換方法，是保證數據處理準確性的基礎；

而數組的維度（如一維向量與二維矩陣）則影響著數據的組織形式和操作方式，理解維度的表示、形狀參數及不同維度間的轉換，是進行數組索引、變形等操作的前提。

接下來，我們將從數據類型和數組維度兩方面，詳細解析NumPy數組的基礎特性。

1.1 數據類型

1.1.1 整數型與浮點型數組

整數型數組：元素均為整數，如arr1 = np.array([1, 2, 3])，輸出[1 2 3]。
浮點型數組：含浮點數，如arr2 = np.array([1.0, 2, 3])，輸出[1. 2. 3.]。
區別：print輸出時，浮點型元素帶小數點，整數型不帶。

1.1.2 同化特性

往整數型數組插入浮點數，浮點數自動截斷為整數，數組仍為整數型。
```
import numpy as np
arr1 = np.array([1, 2, 3])
arr1[0] = 100.9
print(arr1)  
```

在這里插入圖片描述

往浮點型數組插入整數，整數自動升級為浮點數，數組仍為浮點型。
```
arr2 = np.array([1.0, 2, 3])
arr2[1] = 10
print(arr2)  # 輸出 [ 1. 10. 3.]
```

在這里插入圖片描述

1.1.3 相互改變特性

整數型與浮點型數組相互轉換的規范方法：使用.astype()方法。

arr1 = np.array([1, 2, 3])
arr2 = arr1.astype(float)  # 整數型轉浮點型，輸出 [1. 2. 3.]
arr3 = arr2.astype(int)    # 浮點型轉整數型，輸出 [1 2 3]

整數型數組可通過運算升級為浮點型數組（浮點型數組運算一般不降級）。

arr = np.array([1, 2, 3])
print(arr + 0.0)  # 輸出 [1. 2. 3.]
print(arr / 1)    # 輸出 [1. 2. 3.]

1.2 數組維度

1.2.1 一維與二維數組

顯示區別：一維數組用1層中括號表示；二維數組用2層中括號表示。

形狀參數：一維數組形如(x,)；二維數組形如(x,y)。

arr1 = np.ones(3)       # 一維數組，形狀 (3,)，輸出 [1. 1. 1.]
arr2 = np.ones((1,3))   # 二維數組，形狀 (1,3)，輸出 [[1. 1. 1.]]

維度查看：通過.shape屬性，如print(arr1.shape)輸出(3,)，print(arr2.shape)輸出(1, 3)。

1.2.2 不同維度數組的轉換

轉換方法：使用.reshape()方法，可通過-1讓系統自動計算維度。

一維轉二維：

arr1 = np.arange(10)    # 一維數組 [0 1 ... 9]
arr2 = arr1.reshape((1,-1))  # 轉為二維數組 [[0 1 ... 9]]，-1自動計算列數為10

在這里插入圖片描述

二維轉一維：

arr2 = np.arange(10).reshape(2,5)  # 二維數組 [[0...4],[5...9]]
arr1 = arr2.reshape(-1)  # 轉為一維數組 [0 1 ... 9]，-1自動計算長度為10

注意：一維數組稱為向量，二維數組稱為矩陣。

在這里插入圖片描述

2 數組的創建

2.1 創建指定數組

方法：使用np.array()函數，將Python列表轉換為NumPy數組。

程序示例：

# 一維數組（向量）
arr1 = np.array([1,2,3])
print(arr1)  # 輸出 [1 2 3]# 二維數組（行矩陣）
arr2 = np.array([[1,2,3]])
print(arr2)  # 輸出 [[1 2 3]]# 二維數組（列矩陣）
arr3 = np.array([[1],[2],[3]])
print(arr3)  # 輸出 [[1] [2] [3]]# 二維數組（矩陣）
arr4 = np.array([[1,2,3],[4,5,6]])
print(arr4)  # 輸出 [[1 2 3] [4 5 6]]

在這里插入圖片描述

2.2 創建遞增數組

方法：使用np.arange()函數（全稱array_range）。

程序示例：

# 從0開始，到10之前結束
arr1 = np.arange(10)
print(arr1)  # 輸出 [0 1 ... 9]# 從10開始，到20之前結束
arr2 = np.arange(10,20)
print(arr2)  # 輸出 [10 11 ... 19]# 從1開始，到21之前結束，步長為2
arr3 = np.arange(1,21,2)
print(arr3)  # 輸出 [1 3 ... 19]

這里跟python基礎里的arange函數是一樣的。

步長就相當于跳著選數據，比如說步長為3，然后有個數據是：

1 2 3 4 5 6 7 8 9 10，從1開始，那輸出就是：1 4 7 10

2.3 創建同值數組

全0數組：np.zeros(shape)，輸出浮點型數組。
全1數組：np.ones(shape)，輸出浮點型數組。
全值數組：通過與標量相乘實現。

程序示例：

# 全0數組（向量）
arr1 = np.zeros(3)
print(arr1)  # 輸出 [0. 0. 0.]# 全1數組（矩陣）
arr2 = np.ones((1,3))
print(arr2)  # 輸出 [[1. 1. 1.]]# 全3.14數組（矩陣）
arr3 = 3.14 * np.ones((2,3))
print(arr3)  # 輸出 [[3.14 3.14 3.14] [3.14 3.14 3.14]]

在這里插入圖片描述

2.4 創建隨機數組

0-1均勻分布浮點型數組：np.random.random(shape)。

arr1 = np.random.random(5)  # 形狀為5的向量
print(arr1)

在這里插入圖片描述

范圍均勻分布整數數組：np.random.randint(low, high, shape)。

arr2 = np.random.randint(10,100,(1,15))  # 10-100的整數，形狀(1,15)
print(arr2)

在這里插入圖片描述

正態分布數組：np.random.normal(mean, std, shape)，標準正態分布可用np.random.randn(shape)。
```
arr3 = np.random.normal(0,1,(2,3))  # 均值0，標準差1，形狀(2,3)
print(arr3)  
```
范圍轉換：如創建60-100均勻分布3x3數組：(100-60)*np.random.random((3,3)) + 60。

這里就是說，np.random.random((3,3))生成的是形狀為3*3，但是矩陣內的數值仍然是0-1之間的矩陣。

在這里插入圖片描述
然后接著(100-60)*np.random.random((3,3))是因為要創建60-100，它們之間的差距為40.

此時生成的就是0-40之間的矩陣。

在這里插入圖片描述
但我們是要求60-100，那0-40范圍+60不就是60-100范圍的了嘛。

3 數組的索引

在掌握了數組的創建方法后，接下來的核心問題便是如何精準地訪問和修改數組中的元素，這就需要借助索引操作。

索引是數組操作中最基礎也最常用的技能，無論是提取單個元素、修改特定值，還是后續更復雜的切片、篩選，都依賴于對索引規則的理解。

由于前面我們已將一維數組定義為向量、二維數組定義為矩陣，二者在結構上存在差異，因此它們的索引方式既有共通之處，也有各自的特點。

接下來，我們就具體看看如何通過索引訪問向量和矩陣中的元素，以及如何通過索引修改元素的值。

3.1 訪問數組元素

向量訪問：與Python列表類似，索引從0開始，支持負索引。

arr1 = np.arange(1,10)  # [1 2 ... 9]
print(arr1[3])   # 訪問索引3，輸出4
print(arr1[-1])  # 訪問最后一個元素，輸出9
arr1[3] = 100    # 修改元素，數組變為 [1 2 3 100 5 ... 9]

矩陣訪問：使用arr[x,y]，x為行索引，y為列索引。

arr2 = np.array([[1,2,3],[4,5,6]])
print(arr2[1,-2])  # 第1行倒數第2列，輸出5
print(arr2[0,2])   # 第0行第2列，輸出3
arr2[1,1] = 100.9  # 浮點數插入整數數組被截斷，數組變為 [[1 2 3] [4 100 6]]

在這里插入圖片描述

3.2 花式索引

定義：通過索引列表訪問多個元素，向量用arr[[x1,x2...]]，矩陣用arr[[x1,x2...],[y1,y2...]]。

向量示例：

arr1 = np.arange(0,90,10)  # [0 10 20 ... 80]
print(arr1[[0,2]])  # 訪問索引0和2，輸出 [0 20]

矩陣示例：

arr2 = np.arange(1,17).reshape(4,4)  # [[1..4],[5..8],[9..12],[13..16]]
print(arr2[[0,1],[0,1]])  # 訪問(0,0)和(1,1)，輸出 [1 6]
arr2[[0,1,2,3],[3,2,1,0]] = 100  # 修改指定位置為100
print(arr2)  # 輸出 [[1 2 3 100], [5 6 100 8], [9 100 11 12], [100 14 15 16]]

在這里插入圖片描述

3.3 訪問數組切片

3.3.1 向量的切片

方法：與Python列表切片一致，arr[start:end:step]，默認step=1，start缺省為0，end缺省為數組長度。

程序示例：

arr1 = np.arange(10)  # [0 1 ... 9]
print(arr1[1:4])   # 從索引1到4之前，輸出 [1 2 3]
print(arr1[1:])    # 從索引1到結尾，輸出 [1 ... 9]
print(arr1[:4])    # 從開頭到索引4之前，輸出 [0 1 2 3]
print(arr1[2:-2])  # 切除開頭2個和結尾2個，輸出 [2 3 4 5 6 7]
print(arr1[::2])   # 每2個元素采樣，輸出 [0 2 4 6 8]

3.3.2 矩陣的切片

方法：arr[行切片, 列切片]，行/列切片規則同向量。

程序示例：

arr2 = np.arange(1,21).reshape(4,5)  # [[1..5],[6..10],[11..15],[16..20]]
print(arr2[1:3,1:-1])  # 行1-2（不含3），列1到結尾前1，輸出 [[7 8 9] [12 13 14]]
print(arr2[::3,::2])   # 行每3個取1，列每2個取1，輸出 [[1 3 5] [16 18 20]]

在這里插入圖片描述

3.3.3 提取矩陣的行

方法：arr[行索引, :]，可簡寫為arr[行索引]。

程序示例：

arr3 = np.arange(1,21).reshape(4,5)
print(arr3[2,:])    # 第2行，輸出 [11 12 13 14 15]
print(arr3[1:3,:])  # 行1-2，輸出 [[6 7 8 9 10] [11 12 13 14 15]]
print(arr3[2])      # 簡寫，輸出 [11 12 13 14 15]

在這里插入圖片描述

3.3.4 提取矩陣的列

方法：arr[:, 列索引]，單獨提取一列輸出為向量，需轉為列矩陣可使用reshape(-1,1)。

程序示例：

arr4 = np.arange(1,21).reshape(4,5)
print(arr4[:,2])    # 第2列，輸出 [3 8 13 18]（向量）
print(arr4[:,1:3])  # 列1-2，輸出 [[2 3] [7 8] [12 13] [17 18]]# 提取列并轉為列矩陣
cut = arr4[:,2]
cut = cut.reshape(-1,1)  # 轉為列矩陣
print(cut)  # 輸出 [[3] [8] [13] [18]]

也是同樣的道理。

在這里插入圖片描述

3.4 數組切片僅是視圖

特點：NumPy數組的切片是原數組的視圖，修改切片會改變原數組，不創建新變量。

程序示例：

arr = np.arange(10)  # [0 1 ... 9]
cut = arr[:3]        # 切片 [0 1 2]
cut[0] = 100         # 修改切片
print(cut)  # 輸出 [100 1 2]
print(arr)  # 原數組變為 [100 1 2 3 ... 9]

創建新變量：使用.copy()方法，修改拷貝不影響原數組。

arr = np.arange(10)
copy = arr[:3].copy()  # 拷貝切片
copy[0] = 100
print(copy)  # [100 1 2]
print(arr)   # 原數組仍為 [0 1 2 3 ... 9]

3.5 數組賦值僅是綁定

特點：數組賦值是變量綁定，兩個變量指向同一數組，修改一個會影響另一個。

程序示例：

arr1 = np.arange(10)  # [0 1 ... 9]
arr2 = arr1           # 綁定
arr2[0] = 100         # 修改arr2
print(arr2)  # [100 1 ... 9]
print(arr1)  # 原數組變為 [100 1 ... 9]

復制為新變量：使用.copy()方法。

arr1 = np.arange(10)
arr2 = arr1.copy()  # 拷貝
arr2[0] = 100
print(arr2)  # [100 1 ... 9]
print(arr1)  # 原數組仍為 [0 1 ... 9]

4 數組的變形

4.1 數組的轉置

方法：使用.T，僅對矩陣有效，向量需先轉為矩陣。

向量轉置：

arr1 = np.arange(1,4)  # 向量 [1 2 3]
arr2 = arr1.reshape((1,-1))  # 轉為行矩陣 [[1 2 3]]
arr3 = arr2.T  # 轉置為列矩陣 [[1] [2] [3]]

在這里插入圖片描述

矩陣轉置：

# 列矩陣轉置
arr1 = np.arange(3).reshape(3,1)  # 列矩陣 [[0] [1] [2]]
arr2 = arr1.T  # 轉置為行矩陣 [[0 1 2]]# 普通矩陣轉置
arr1 = np.arange(4).reshape(2,2)  # [[0 1] [2 3]]
arr2 = arr1.T  # 轉置為 [[0 2] [1 3]]

在這里插入圖片描述

4.2 數組的翻轉

上下翻轉：np.flipud(arr)（up-down），向量只能用此方法。
左右翻轉：np.fliplr(arr)（left-right），僅對矩陣有效。

程序示例：

# 向量翻轉
arr1 = np.arange(10)  # [0 1 ... 9]
arr_ud = np.flipud(arr1)  # 輸出 [9 8 ... 0]# 矩陣翻轉
arr2 = np.arange(1,21).reshape(4,5)  # [[1..5], [6..10], [11..15], [16..20]]
arr_lr = np.fliplr(arr2)  # 左右翻轉，輸出 [[5..1], [10..6], [15..11], [20..16]]
arr_ud = np.flipud(arr2)  # 上下翻轉，輸出 [[16..20], [11..15], [6..10], [1..5]]

在這里插入圖片描述

4.3 數組的重塑

方法：使用.reshape(shape)，-1表示自動計算維度。

向量變形：

arr1 = np.arange(1,10)  # 向量 [1 ... 9]
arr2 = arr1.reshape(3,3)  # 重塑為3x3矩陣 [[1 2 3] [4 5 6] [7 8 9]]

矩陣變形：

arr1 = np.array([[1,2,3],[4,5,6]])  # 2x3矩陣
arr2 = arr1.reshape(6)  # 重塑為向量 [1 2 3 4 5 6]
arr3 = arr1.reshape(1,6)  # 重塑為1x6矩陣 [[1 2 3 4 5 6]]

在這里插入圖片描述

4.4 數組的拼接

向量拼接：np.concatenate([arr1, arr2])，結果為更長向量。

arr1 = np.array([1,2,3])
arr2 = np.array([4,5,6])
arr3 = np.concatenate([arr1, arr2])  # 輸出 [1 2 3 4 5 6]

矩陣拼接：np.concatenate([arr1, arr2], axis)，axis=0按行拼接，axis=1按列拼接（需維度吻合）。

arr1 = np.array([[1,2,3],[4,5,6]])
arr2 = np.array([[7,8,9],[10,11,12]])# 按行拼接（axis=0，默認）
arr3 = np.concatenate([arr1, arr2])
# 輸出 [[1 2 3] [4 5 6] [7 8 9] [10 11 12]]# 按列拼接（axis=1）
arr4 = np.concatenate([arr1, arr2], axis=1)
# 輸出 [[1 2 3 7 8 9] [4 5 6 10 11 12]]

注意：向量與矩陣不可直接拼接，需先將向量升級為矩陣。

在這里插入圖片描述

4.5 數組的分裂

向量分裂：np.split(arr, [索引1,索引2...])，按索引位置截斷。

arr = np.arange(10,100,10)  # [10 20 ... 90]
arr1, arr2, arr3 = np.split(arr, [2,8])  # 在索引2和8截斷
print(arr1)  # [10 20]
print(arr2)  # [30 40 50 60 70 80]
print(arr3)  # [90]

在這里插入圖片描述

矩陣分裂：np.split(arr, [索引1...], axis)，axis=0按行分裂，axis=1按列分裂。

arr = np.arange(1,9).reshape(2,4)  # [[1 2 3 4] [5 6 7 8]]# 按行分裂（axis=0）
arr1, arr2 = np.split(arr, [1])  # 在索引1截斷行
print(arr1)  # [[1 2 3 4]]
print(arr2)  # [[5 6 7 8]]# 按列分裂（axis=1）
arr1, arr2, arr3 = np.split(arr, [1,3], axis=1)  # 在索引1和3截斷列
print(arr1)  # [[1] [5]]
print(arr2)  # [[2 3] [6 7]]
print(arr3)  # [[4] [8]]

在這里插入圖片描述

5 數組的運算

5.1 數組與系數之間的運算

支持運算符：+、-、*、/、**、//（取整）、%（取余）。

程序示例：

arr = np.arange(1,9).reshape(2,4)  # [[1 2 3 4] [5 6 7 8]]
print(arr + 10)  # 加10，輸出 [[11..14] [15..18]]
print(arr * 10)  # 乘10，輸出 [[10..40] [50..80]]
print(arr / 10)  # 除10，輸出 [[0.1..0.4] [0.5..0.8]]
print(arr **2)  # 平方，輸出 [[1 4 9 16] [25 36 49 64]]
print(arr // 6)  # 取整，輸出 [[0 0 0 0] [0 1 1 1]]
print(arr % 6)   # 取余，輸出 [[1 2 3 4] [5 0 1 2]]

在這里插入圖片描述

5.2 數組與數組之間的運算

規則：同維度數組間為對應元素運算。

程序示例：

arr1 = np.arange(-1,-9,-1).reshape(2,4)  # [[-1 -2 -3 -4] [-5 -6 -7 -8]]
arr2 = -arr1  # [[1 2 3 4] [5 6 7 8]]print(arr1 + arr2)  # 加法，輸出 [[0 0 0 0] [0 0 0 0]]
print(arr1 - arr2)  # 減法，輸出 [[-2 -4 -6 -8] [-10 -12 -14 -16]]
print(arr1 * arr2)  # 逐元素乘，輸出 [[-1 -4 -9 -16] [-25 -36 -49 -64]]
print(arr1 / arr2)  # 逐元素除，輸出 [[-1. -1. -1. -1.] [-1. -1. -1. -1.]]

在這里插入圖片描述

5.3 廣播機制

規則：不同形狀數組運算時，自動擴展以適配形狀。
- 向量與矩陣：向量自動升級為行矩陣，再廣播為矩陣形狀（向量長度需與矩陣列數一致）。
- 行矩陣與列矩陣：分別廣播為同形狀矩陣。

示例：

# 向量被廣播
arr1 = np.array([-100, 0, 100])  # 向量
arr2 = np.random.random((10,3))  # 10x3矩陣
print(arr1 * arr2)  # 向量廣播為10x3矩陣，逐元素乘# 列矩陣被廣播
arr1 = np.arange(3).reshape(3,1)  # 3x1列矩陣
arr2 = np.ones((3,5))  # 3x5矩陣
print(arr1 * arr2)  # 列矩陣廣播為3x5矩陣，逐元素乘# 行矩陣與列矩陣同時廣播
arr1 = np.arange(3)  # 向量（行矩陣）
arr2 = np.arange(3).reshape(3,1)  # 列矩陣
print(arr1 * arr2)  # 均廣播為3x3矩陣，輸出 [[0 0 0] [0 1 2] [0 2 4]]

在這里插入圖片描述

6 數組的函數

6.1 矩陣乘積

方法：使用np.dot(a, b)，為線性代數中的矩陣乘積。

向量與向量：

arr1 = np.arange(5)  # [0 1 2 3 4]
arr2 = np.arange(5)
print(np.dot(arr1, arr2))  # 內積，0*0+1*1+...+4*4=30

在這里插入圖片描述

向量與矩陣：

arr1 = np.arange(5)  # 向量（1x5）
arr2 = np.arange(15).reshape(5,3)  # 5x3矩陣
print(np.dot(arr1, arr2))  # 結果為1x3向量，輸出 [90 100 110]

在這里插入圖片描述

矩陣與向量：

arr1 = np.arange(15).reshape(3,5)  # 3x5矩陣
arr2 = np.arange(5)  # 向量（5x1）
print(np.dot(arr1, arr2))  # 結果為3x1向量，輸出 [30 80 130]

在這里插入圖片描述

矩陣與矩陣：

arr1 = np.arange(10).reshape(5,2)  # 5x2矩陣
arr2 = np.arange(16).reshape(2,8)  # 2x8矩陣
print(np.dot(arr1, arr2))  # 結果為5x8矩陣

在這里插入圖片描述

6.2 數學函數

絕對值：np.abs(arr)。

arr_v = np.array([-10, 0, 10])
print(np.abs(arr_v))  # 輸出 [10 0 10]

三角函數：np.sin()、np.cos()、np.tan()。

theta = np.arange(3) * np.pi / 2  # [0, π/2, π]
print(np.sin(theta))  # 正弦，輸出 [0.0, 1.0, 1.22e-16]

指數函數：np.exp()（e^x）、2**x、10**x。

x = np.arange(1,4)  # [1 2 3]
print(np.exp(x))  # e^x，輸出 [2.718 7.389 20.086]

對數函數：np.log()（自然對數）、np.log(x)/np.log(2)（log2）、np.log(x)/np.log(10)（log10）。
```
x = np.array([1,10,100,1000])
print(np.log(x))  # 自然對數，輸出 [0. 2.303 4.605 6.908]
```

6.3 聚合函數

常用函數：np.max()、np.min()、np.sum()、np.prod()、np.mean()、np.std()，支持axis參數指定維度。

示例（矩陣）：

arr = np.arange(10).reshape(2,5)  # [[0 1 2 3 4] [5 6 7 8 9]]# 最大值
print(np.max(arr, axis=0))  # 按列（維度0），輸出 [5 6 7 8 9]
print(np.max(arr, axis=1))  # 按行（維度1），輸出 [4 9]
print(np.max(arr))          # 整體，輸出9# 求和
print(np.sum(arr, axis=0))  # 按列，輸出 [5 7 9 11 13]
print(np.sum(arr, axis=1))  # 按行，輸出 [10 35]
print(np.sum(arr))          # 整體，輸出45# 均值
print(np.mean(arr, axis=0))  # 按列，輸出 [2.5 3.5 4.5 5.5 6.5]

在這里插入圖片描述

7 布爾型數組

7.1 創建布爾型數組

方法：通過數組與標量/同維數組比較，或多條件組合（&與、|或、~非）。

數組與標量比較：

arr = np.arange(1,7).reshape(2,3)  # [[1 2 3] [4 5 6]]
print(arr >= 4)  # 輸出 [[False False False] [True True True]]

在這里插入圖片描述

同維數組比較：

arr1 = np.arange(1,6)  # [1 2 3 4 5]
arr2 = np.flipud(arr1)  # [5 4 3 2 1]
print(arr1 > arr2)  # 輸出 [False False False True True]

多條件組合：

arr = np.arange(1,10)  # [1..9]
print((arr < 4) | (arr > 6))  # 小于4或大于6，輸出 [T T T F F F T T T]

同樣的道理。

7.2 布爾型數組中True的數量

np.sum()：統計True的個數（True=1，False=0）。

arr = np.random.normal(0,1,10000)  # 10000個標準正態分布元素
num = np.sum(np.abs(arr) < 1)  # 絕對值小于1的元素個數，約6800（符合3σ準則）

np.any()：是否存在True（至少一個）。

arr1 = np.arange(1,10)
arr2 = np.flipud(arr1)
print(np.any(arr1 == arr2))  # 存在相同元素（5），輸出True

np.all()：是否全為True。

arr = np.random.normal(500,70,100000)  # 模擬六級成績
print(np.all(arr > 250))  # 是否所有成績>250，輸出False

7.3 布爾型數組作為掩碼

作用：篩選普通數組中滿足條件的元素，結果為向量。

程序示例：

# 篩選大于4的元素
arr = np.arange(1,13).reshape(3,4)  # [[1..4] [5..8] [9..12]]
mask = arr > 4  # 布爾掩碼 [[F F F F] [T T T T] [T T T T]]
print(arr[mask])  # 輸出 [5 6 ... 12]# 篩選數組比較結果
arr1 = np.arange(1,10)  # [1..9]
arr2 = np.flipud(arr1)  # [9..1]
mask = arr1 > arr2  # [F F F F F T T T T]
print(arr1[mask])  # 輸出 [6 7 8 9]
print(arr2[mask])  # 輸出 [4 3 2 1]

在這里插入圖片描述

7.4 滿足條件的元素所在位置

方法：使用np.where(condition)，返回滿足條件元素的索引元組。

程序示例：

arr = np.random.normal(500,70,1000)  # 模擬成績
# 超過650分的位置
print(np.where(arr > 650))  # 輸出 (array([索引1, 索引2...]),)
# 最高分位置
print(np.where(arr == np.max(arr)))  # 輸出 (array([最高分給索引]),)

在這里插入圖片描述

8 從數組到張量

8.1 數組與張量

關系：NumPy的n維數組對應PyTorch的n階張量，PyTorch吸收NumPy語法，運算從CPU升級到GPU。
轉換：
- 數組轉張量：ts = torch.tensor(arr)
- 張量轉數組：arr = np.array(ts)

8.2 語法不同點

NumPy函數	PyTorch函數	用法區別
`.astype()`	`.type()`	無
`np.random.random()`	`torch.rand()`	無
`np.random.randint()`	`torch.randint()`	不接納一維張量
`np.random.normal()`	`torch.normal()`	不接納一維張量
`np.random.randn()`	`torch.randn()`	無
`.copy()`	`.clone()`	無
`np.concatenate()`	`torch.cat()`	無
`np.split()`	`torch.split()`	參數含義優化
`np.dot()`	`torch.matmul()`	無
`np.dot(v,v)`	`torch.dot()`	無
`np.dot(m,v)`	`torch.mv()`	無
`np.dot(m,m)`	`torch.mm()`	無
`np.exp()`	`torch.exp()`	必須傳入張量
`np.log()`	`torch.log()`	必須傳入張量
`np.mean()`	`torch.mean()`	必須傳入浮點型張量
`np.std()`	`torch.std()`	必須傳入浮點型張量

9 小結

本文系統介紹了NumPy數組庫的核心知識，從數組基礎到創建方法，再到索引、變形、運算、函數及布爾型數組的應用，最后銜接至張量。NumPy通過數組提供高效的數值計算能力，其切片視圖、廣播機制等設計優化了內存與運算效率。理解NumPy與張量的語法差異可平滑過渡到深度學習框架的使用。