Python科學計算庫 — NumPy 基本方法

一、NumPy 簡介

• Numpy 是以矩陣為基礎的數學計算子產品，NumPy 子產品是Python的一種開源的數值計算擴充，是一個用Python實作的科學計算包，主要包括：

  （1）一個具有矢量算術運算和複雜廣播能力的快速且節省空間的多元數組，稱為ndarray(N-dimensional array object)

  （2）用于對整組資料進行快速運算的标準數學函數：ufunc(universal function object)

  （3）實用的線性代數、傅裡葉變換和随機數生成函數。

  （4）NumPy和稀疏矩陣的運算包Scipy配合使用更加友善。

• ndarray：NumPy 核心資料結構，通常被稱作數組。注意：numpy.array 和标準Python庫類 array.array 不同，後者隻處理一維數組和提供少量功能。
• 導入NumPy 子產品：

  import numpy as np

二、建立Ndarray

通過NumPy 子產品中的常用函數建立ndarray 多元數組對象，主要函數有：array(), zeros(), ones(), empty()；

通過其它一些函數建立，如：arange(), linspace(), logspace(), random().

1、array()

函數原型：

array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

傳回值：指定序列的數組

參數：

• object

  ：傳入一個序列，清單、元組或字典類型。

• dtype=None

  ：數組元素的資料類型，預設為None，表示資料類型由傳遞的object 确定。

• copy=True

  ：是否複制一份object 資料。預設為True，表示對原object 複制一份副本，array 方法對副本進行操作；如果為False，可能會改變原資料。

  list01 = [2, 3, 5, 8, 6] 
  np.array(list01)         #建立一維數組
  list02 = [[2,3], [5,4],[8,3]]
  np.array(list02)         #建立二維數組
  t = ("數學", "英語", "國文")
  np.array(t)         #通過元組建立數組
  dic01 = {"數學":98, "英語":95}
  np.array(dic01)     #通過字典建立數組
             

  輸出結果：

  array([2, 3, 5, 8, 6])

  array([[2, 3],

  [5, 4]])

  array([‘數學’, ‘英語’, ‘國文’], dtype=’<U2’)

  array({‘數學’: 98, ‘英語’: 95}, dtype=object)

2、zeros()

函數原型：

zeros(shape, dtype=None, order='C')

傳回值：指定形狀的全0數組

• shape

  ：指定數組的形狀(次元)。參數值為int 表示一維數組的長度；為tuple 表示多元數組的形狀，如(3, 4) 表示3*4，3行4列。

• dtype=None

  ：數組元素的資料類型，

np.zeros(5)        #一維
np.zeros((2, 3))   #二維: 形狀參數用元組表示
           

輸出結果：

array([0., 0., 0., 0., 0.])

array([[0., 0., 0.],

[0., 0., 0.]])

3、ones()

函數原型：

ones(shape, dtype=None, order='C')

傳回值：指定形狀的全1數組

參數：同 np.zeros()

np.ones(5)
np.ones((2,3))
           

4、empty()

函數原型：

empty(shape, dtype=None, order='C')

傳回值：一個沒有具體值的數組，即未初始化的數組，數組值為垃圾數字。該方法不常用。

參數：同np.zeros()

5、arange()

函數原型：

arange(start=None, stop=None, step=None, dtype=None)

傳回值：等差數列組成的一維數組

參數：

• start=None

  ：初值，預設為0

• stop=None

  ：終值，預設為無窮大

• step=None

  ：步長，即等差數列的公差，預設為1

  注意：Python 中的區間一般都是前閉後開，即初值能取到，終值取不到。

  np.arange(5)
  np.arange(1, 10, 2)
             

  輸出結果：

  array([0, 1, 2, 3, 4])

  array([1, 3, 5, 7, 9])

6、linspace()

函數原型：

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

傳回值：指定資料範圍和元素個數的等差數列構成的一維數組

參數：

• start

  ：初值

• stop

  ：終值

• num

  ：指定範圍内的元素個數

• endpoint=True

  ：是否包含終值，預設為True，表示包含。

• retstep=False

  ：是否傳回步長，預設為False，表示不傳回。

注意：linspace() 必須指定資料範圍(初值和終值)，不同于arange()方法。

np.linspace(1, 7, 3, endpoint=False)
np.linspace(1, 9, 3, retstep=True)
           

輸出結果：

array([1., 3., 5.])

(array([1., 5., 9.]), 4.0)

7、logspace()

函數原型：

logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

傳回值：指定範圍内和元素個數的等比數列組成的一維數組

參數：

• start

  ：初值的指數項，如3 表示base的3次方

• stop

  ：終值的指數項

• num=50

  ：指定範圍内數組的元素個數，預設為50

• endpoint=True

  ：是否包含終值，預設包含

• base=10.0

  ：底數，預設為10

np.logspace(2, 5, 4, base=2.0)   
# 以2 為底數，2的平方為初值，2的5次方為終值，生成4個元素組成的等比數列
np.logspace(1, 5, 3)  #10E1 到10E5 之間生成3個元素，構成等比數列
           

輸出結果：

array([ 4., 8., 16., 32.])

array([1.e+01, 1.e+03, 1.e+05])

8、random 子產品的相關方法

np.random.random(5)            #生成5個 0-1 的随機數組成的一維數組
np.random.random((3, 4))       #生成 0-1 随機數組成3行4列的二維數組
np.random.rand(8)        #生成8個符合平均分布的 0-1 的随機數組成的一維數組
np.random.rand(3, 4)     #生成符合0-1 随機分布的3*4 的二維數組
np.random.randn(10)           #生成10個符合正态分布的樣本
np.random.randn(10, 2)        #生成10個符合正态分布的2維資料樣本
np.random.randint(1, 5, 10)        #生成10個1-5之間的随機整數
np.random.randint(1, 5, (3, 4))    #生成1-5 之間的随機整數組成的3*4 的二維數組
           

三、NumPy 對象屬性

屬性	含義
ndim	數組軸(次元)的個數，軸的個數叫做秩
shape	數組的次元(形狀)，
size	數組元素的總個數
dtype	數組元素的資料類型，可以通過指定dtype 使用标準Python 類型，不過NumPy提供它自己的資料類型
itemsize	數組元素的大小，每個元素的位元組數

arr = np.array([[2,3, 5], [5,3, 4]])
print("次元的數量：", arr.ndim)
print("數組的形狀：", arr.shape)
print("數組的元素類型：", arr.dtype)
print("數組元素的數量：", arr.size)
print("數組元素的大小：", arr.itemsize)
           

輸出結果：

次元的數量： 2

數組的形狀： (2, 3)

數組的元素類型： int32

數組元素的數量： 6

數組元素的大小： 4

1、資料類型

• 建立numpy數組時可通過屬性dtype 顯式指定資料類型，如果不指定，numpy 會自動推斷出适合的資料類型，一般不需要顯式給定資料類型。
• astype() 方法修改數組元素的資料類型。

Example：顯式指定、修改數組元素的資料類型

arr01 = np.array([1.8, 5.24, 3.21], dtype=np.int32)
arr02 = np.array([2, 5, 8], dtype=np.float32)
arr03 = np.array([1.32, 2.5, 4.16])
print("arr03 元素資料類型：", arr03.dtype)
arr04 = arr03.astype(np.int32)   # 修改arr03 資料類型為int32，可直接傳入參數 int
print("arr04 元素資料類型：", arr04.dtype)
           

輸出結果：

array([1, 5, 3])

array([2., 5., 8.], dtype=float32)

arr03 元素資料類型： float64

arr04 元素資料類型： int32

NumPy 基本資料類型

資料類型	類型簡寫	說明
int_	預設整型
intc	等價于long 的整型
int8	i1	位元組整型，1個位元組，範圍：[-128, 127]
int16	i2	整型，2個位元組，範圍：[-32768, 32767]
int32	i3	整型，4個位元組，範圍：[-2^31, 2^31-1]
int64	i4	整型，8個位元組，範圍：[-2^63, 2^63-1]
uint8	u1	無符号整型，1個位元組，範圍：[0, 255]
uint16	u2	無符号整型，2個位元組，範圍：[0, 65535]
uint32	u3	無符号整型，4個位元組，範圍：[0, 2^32-1]
uint64	u4	無符号整型，8個位元組，範圍：[0, 2^64-1]
bool_	以一個位元組形成存儲的布爾值，True 或 False
float_	float64 簡寫形式
float16	F2	半精度浮點型(2位元組)：1符号位+5位指數+10位的小數部分
float32	f4或者f	單精度浮點型(4位元組)：1符号位+8位指數+23位的小數部分
float64	f8或者d	雙精度浮點型(8位元組)：1符号位+11位指數+52位的小數部分
complex_	c16	complex128 的簡寫形式
complex64	c8	複數，由兩個32位的浮點數來表示
complex128	c16	複數，由兩個64位的浮點數來表示
object	O	Python對象類型
String_	S	固定長度的字元串類型(每個字元1個位元組)，比如：要建立一個長 度為8的字元串，應該使用S8
Unicode_	U	固定長度的unicode類型的字元串(每個字元占用位元組數由平台決 定)，長度定義類似String_類型

2、ndarray 修改形狀

• 直接修改數組對象的shape 屬性值（int或元組類型），要求修改前後數組的size 不變。
• 通過數組對象的reshape() 方法傳回一個指定shape的新數組，原數組形狀不變，但是新數組和原數組共享同一個記憶體空間，也就是修改任何一個數組中的值都會對另外一 個産生影響，要求新數組的元素個數和原數組一緻（此方法還可以進行降維操作）。

注：修改數組形狀時應保持數組的size 值不變，即數組元素的個數不變；

當指定某一個軸為-1的時候，表示将根據數組元素的數量自動計算該軸的 長度值。

arr = np.array([[1, 3, 5, 7, 9, 1], [2, 4, 6, 8, 10, 12]])  #建立一個2*6的二維數組
print("原數組次元：", arr.shape)
# 1. 修改數組的shape值
arr.shape = (3, 4)    
print("修改之後數組次元：", arr.shape)
# 2. 通過reshape方法修改形狀為4*3
arr02 = arr.reshape(4, 3)    # 傳回一個4*3的二維數組
print("reshape 傳回的數組次元：", arr02.shape)
print("原數組次元：", arr.shape)
arr03 = arr.reshape(6, -1)   # 傳回一個6行的數組，-1 表示列數自動計算
arr04 = arr.reshape(12)      # 降維：傳回一個一維數組
print("arr03 的次元：", arr03.shape)
print("arr04：", arr04)
           

輸出結果：

原數組次元： (2, 6)

修改之後數組次元： (3, 4)

reshape 傳回的數組次元： (4, 3)

原數組次元： (3, 4)

arr03 的次元： (6, 2)

arr04： [ 1 3 5 7 9 1 2 4 6 8 10 12]

四、Numpy 基本操作

1、數組與标量、數組之間的運算

arr01 = np.array([1, 2, 3, 4, 5])
arr02 = np.array([3, 4, 5, 6, 7])
# 1、數組與标量的運算: 标量與每個數組元素都進行運算
print("數組與标量運算：", arr01 + 10)  
# 2、數組之間的運算：元素級運算,相同位置的元素進行運算。要求數組形狀相同
print("數組與數組運算：", arr01 + arr02)
# 3、廣播：多元數組與一維數組之間的運算  形狀：次元要麼相同，要麼為1
# 一維數組為行向量：行向量與多元數組的每一行運算
# 一維數組為列向量：列向量與多元數組的每一列運算
row = np.array([1,2,3])   # 行向量：1行3列
column = np.array([[5],[6]])   #列向量：2行1列
arr03 = np.array([[2, 5, 3], [4, 8, 6]])  # 2*3的二維數組
print("廣播-行運算：\n", arr03 + row)
print("廣播-列運算：\n", arr03 + column)
           

輸出結果：

數組與标量運算： [11 12 13 14 15]

數組與數組運算： [ 4 6 8 10 12]

廣播-行運算：

[[ 3 7 6]

[ 5 10 9]]

廣播-列運算：

[[ 7 10 8]

[10 14 12]]

廣播：行向量的每一行與數組的每一行進行運算，或列向量的每一行與數組的每一列進行運算。

2、數組的矩陣積(matric product)

兩個數組求矩陣積要求：前數組的行數 = 後數組的列數， 同矩陣乘法。

# np.dot(arr1, arr2) 前數組的行數 = 後數組的列數，條件同矩陣乘法
arr1 = np.array([[2, 3], [1, 5], [8, 2]])  # 3行2列：3*2
arr2 = np.array([[1, 3, 2, 5], [4, 2, 1, 2]])  #2行4列：2*4
print(np.dot(arr1, arr2))
           

輸出結果：

[[14 12 7 16]

[21 13 7 15]

[16 28 18 44]]

3、數組的索引與切片

arr = np.array([[[1,2,3,4],[5,6,7,8],[9,10,11,12]],[[21,22,23,24],[25,26,27,28],[29,30,31,32]]])
arr       # 三維數組shape：2*3*4， 2塊，3行，4列
# 1、索引：擷取指定位置的元素
print("擷取第0塊，第2行，第3列的元素：", arr[0, 2, 3])
# 2、切片：切片操作擷取的是原數組的視圖，對新數組進行操作會影響原數組，即淺拷貝！
print("擷取第0塊，第1行，第2到4列的資料", arr[0, 1, 2:5]) 
# 3、花式索引：擷取多行或多列資料
# 通過花式索引擷取的新數組是一個副本，修改新數組不會影響原數組，相當于深拷貝！
# 數組名[行索引，列索引]  中括号内從左到右依次是：行索引，列索引；或：塊索引，行索引，列索引 
print("擷取第0塊，第1行，第1列和第3列的資料：", arr[0, 1, [1,3]])  
print("擷取第1塊，第2行，第1列到第3列的資料：", arr[1, 2, 1:]) 
print("擷取第1塊，所有行，第2列的資料：", arr[1, :, 2]) 
print("擷取所有塊，第0，2行的所有列的資料：\n", arr[:, [0,2], :])
           

輸出結果：

array([[[ 1, 2, 3, 4],

[ 5, 6, 7, 8],

[ 9, 10, 11, 12]],

[[21, 22, 23, 24],

[25, 26, 27, 28],

[29, 30, 31, 32]]])

擷取第0塊，第2行，第3列的元素： 12

擷取第0塊，第1行，第2到4列的資料 [7 8]

擷取第0塊，第1行，第1列和第3列的資料： [6 8]

擷取第1塊，第2行，第1列到第3列的資料： [30 31 32]

擷取第1塊，所有行，第2列的資料： [23 27 31]

擷取所有塊，第0，2行的所有列的資料：

[[[ 1 2 3 4]

[ 9 10 11 12]]

[[21 22 23 24]

[29 30 31 32]]]

# 4、索引器：取多行多列的資料
print("擷取所有塊的第0，2行的第0，1，3列的6個資料：\n", arr[np.ix_([0,1], [0,2],[0,1,3])])

# 5、布爾索引：arr[condition] 傳回condition中為True 的位置對應的元素組成的數組
score = np.array([82, 78, 93, 100, 75])
condition = score>=80       #數組與元素比較時，傳回的是一個布爾類型數組
print("擷取>=80的成績：", score[condition])
names = np.array( ['Tom', 'Arthur', 'Selina'])
scores = np.array([[98,95,89], [88,85,80], [100, 99, 95]])
classes = np.array(['國文', '數學', '英語'])
print("擷取Arthur的分數：", scores[(names == 'Arthur')])
print("擷取Selina的數學分數：", scores[names == 'Selina', classes == '數學'])
           

輸出結果：

擷取所有塊的第0，2行的第0，1，3列的6個資料：

[[[ 1 2 4]

[ 9 10 12]]

[[21 22 24]

[29 30 32]]]

擷取>=80的成績： [ 82 93 100]

擷取Arthur的分數： [[88 85 80]]

擷取Selina的數學分數： [99]

4、數組的轉置與軸對換

# 1、通過T 屬性進行轉置
arr1 = np.array([[1,2,3], [4,5,6]])  # 2*3 的數組
print("數組次元為：", arr1.shape)
print("轉置後的數組次元為：", arr1.T.shape)

# 2、通過transpose()方法可以轉置；多元數組可以将任意軸進行對換，(2,0,1)
arr2 = np.array([[[1,2,3,4],[5,6,7,8],[9,10,11,12]],[[21,22,23,24],[25,26,27,28],[29,30,31,32]]]) # 數組次元：2*3*4
arr3 = arr2.transpose(2, 0, 1)   # 原始數組軸的順序：0，1，2；對換後的軸順序：2，0，1
print("原始數組的次元為：", arr2.shape)
print("軸對換後數組的次元為：", arr3.shape)
print("通過T屬性轉置後的次元為：", arr2.T.shape)
           

輸出結果：

數組次元為： (2, 3)

轉置後的數組次元為： (3, 2)

原始數組的次元為： (2, 3, 4)

軸對換後數組的次元為： (4, 2, 3)

通過T屬性轉置後的次元為： (4, 3, 2)

5、數組的拉伸與合并

• np.tile(A, rep) ： 将數組A 進行拉伸，沿着A 的次元重複rep次。

# 拉伸：np.tile(arr, rep) 将數組arr 拉伸為原來的rep 倍
# rep為int，表示橫向拉伸倍數；rep 為清單[m, n]，表示縱向拉伸為m 倍，橫向拉伸為n倍
# np.tile(arr,[m,n])  m為數組縱向拉伸倍數，n為橫向拉伸的倍數
arr = np.array([[1,2,3], [4,5,6]])
print("原始數組為：\n", arr)
arr2 = np.tile(arr, [3, 2])
print("拉伸後的數組為：\n", arr2)
           

輸出結果：

原始數組為：

[[1 2 3]

[4 5 6]]

拉伸後的數組為：

[[1 2 3 1 2 3]

[4 5 6 4 5 6]

[1 2 3 1 2 3]

[4 5 6 4 5 6]

[1 2 3 1 2 3]

[4 5 6 4 5 6]]

• 合并：将數組合并的方法主要有3種。

  np.stack((arr1, arr2), axis=0)

  ：取出兩數組的每一行作為一個元素進行合并。

  np.hstack()

  ：橫向合并

  np.vstack()

  ：縱向合并

# 合并：stack(), hstack(), vstack()
a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])
np.stack((a,b))  
#等價于：np.stack((a,b), axis=0)   取出兩數組的每一行作為一個元素進行合并，直接在最外面套個大盒子
np.stack([a,b], 1)     #取出兩數組的每一列作為一個元素進行合并

arr1 = np.array([[1,2,3],[4,5,6]])
arr2 = np.array([[11,12,13],[14,15,16]])
np.hstack((a,b))    # hstack：依次取出每個數組的第一行、第二行，構成新數組的第一行、第二行
np.vstack((a,b))    # vstack：依次取出每個數組的第一列、第二列，構成新數組的第一列、第二列
np.hstack((arr1, arr2))
np.vstack((arr1, arr2))

           

輸出結果：

array([[ 1, 2, 3, 4],

[10, 20, 30, 40]])

array([[ 1, 10],

[ 2, 20],

[ 3, 30],

[ 4, 40]])

array([ 1, 2, 3, 4, 10, 20, 30, 40])

array([[ 1, 2, 3, 4],

[10, 20, 30, 40]])

array([[ 1, 2, 3, 11, 12, 13],

[ 4, 5, 6, 14, 15, 16]])

array([[ 1, 2, 3],

[ 4, 5, 6],

[11, 12, 13],

[14, 15, 16]])

更多關于stack(), hstack(), vstack() 的用法和差別，請參考：

https://blog.csdn.net/qq_39521554/article/details/80469666

五、ndarray 通用函數/常用函數

一進制函數

函數名	調用方法	描述
abs, fabs	np.fabs(arr)	計算整數、浮點數或者複數的絕對值。對于非複數，一般使用更快的fabs
sqrt	np.sqrt(arr)	計算各個元素的平方根，相當于arr ** 0.5， 要求arr的每個元素必須是非負數
square	np.square(arr)	計算各個元素的平方，相當于arr**2
exp	np.exp(arr)	計算各個元素的指數e的x次方
log、log10、log2、log1p	np.log(arr) np.log10(arr) np.log2(arr) np.log1p(arr)	分别計算自然對數、底數為10的log、底數為2的log以及log(1+x)要求arr中的每個元素必須為正數
sign	np.sign(arr)	計算各個元素的正負号: 1 正數，0：零，-1：負數
ceil	np.ceil(arr)	計算各個元素的ceiling值，即大于等于該值的最小整數
floor	np.floor(arr)	計算各個元素的floor值，即小于等于該值的最大整數
rint	np.rint(arr)	将各個元素值四舍五入到最接近的整數，保留dtype的類型
modf	np.modf(arr)	将數組中元素的小數位和整數位以兩部分獨立數組的形式傳回
isnan	np.isnan(arr)	傳回一個表示“哪些值是NaN(不是一個數字)”的布爾類型數組
isfinite、isinf	np.isfinite(arr)、isinf(arr)	分别傳回表示”哪些元素是有窮的(非inf、非NaN)”或者“哪些元素是無窮的”的布爾型數組
cos、cosh、sin、sinh、tan、tanh	np.cos(arr)、np.sinh(arr)	普通及雙曲型三角函數
arccos、arccosh、arcsin、arcsinh、 arctan、arctanh	np.arctan(arr)	反三角函數

Example - Jupyter代碼：

# 絕對值函數：abs，fabs(非複數的絕對值)
arr01 = np.array([-8, 4, -5, 6])
np.fabs(arr01)

# 平方根：sqrt()
np.sqrt(arr01)   #負數的平方根為nan 

# 平方運算：square()
np.square(arr01)

# 計算各元素的指數e的x次方
arr02 = np.array([1,2,3])
np.exp(arr02)

# 對數：log，log2，log10 分别是求底數為e，2，10 的對數
arr03 = np.array([2, 2.718, 4, 5, 10, 25, 100 ])
print("底數為e的對數：", np.log(arr03).round(3))   # arr.round(3) 表示四舍五入保留3位小數
print("底數為2的對數：", np.log2(arr03).round(3))
print("底數為10的對數：", np.log10(arr03).round(3))
# 随機底數用換底公式，如求以5為底的對數：換底公式 -- np.log2(arr)/np.log2(5)
print("底數為5的對數：", (np.log2(arr03)/np.log2(5)).round(3))
           

輸出結果：

array([8., 4., 5., 6.])

array([ nan, 2. , nan, 2.44948974])

array([64, 16, 25, 36], dtype=int32)

array([ 2.71828183, 7.3890561 , 20.08553692])

底數為e的對數： [0.693 1. 1.386 1.609 2.303 3.219 4.605]

底數為2的對數： [1. 1.443 2. 2.322 3.322 4.644 6.644]

底數為10的對數： [0.301 0.434 0.602 0.699 1. 1.398 2. ]

底數為5的對數： [0.431 0.621 0.861 1. 1.431 2. 2.861]

# 取整  ceil：向上取整； floor：向下取整
arr = np.array([2.346, 3.652, 5.849, 8.192])
print("向上取整：", np.ceil(arr))
print("向下取整：", np.floor(arr))

# rint：四舍五入取整；round(arr, n)：四舍五入保留n 位小數
print("四舍五入取整：", np.rint(arr))
print("四舍五入保留2位小數：", np.round(arr, 2))
           

輸出結果：

向上取整： [3. 4. 6. 9.]

向下取整： [2. 3. 5. 8.]

四舍五入取整： [2. 4. 6. 8.]

四舍五入保留2位小數： [2.35 3.65 5.85 8.19]

# isnan(): 判斷數組元素是否為nan 類型，傳回一個布爾類型數組
arr = np.array([2, 5, np.nan, 8, np.nan, np.Infinity])
np.isnan(arr)
# 過濾掉nan 類型的資料：condition為 isnan()的傳回值取反 
arr[~np.isnan(arr)]  

# isfinite(): 判斷元素是否是有窮的(非inf，非nan)
# isinf()：判斷元素是否是無窮的   傳回布爾類型的數組
np.isfinite(arr)
np.isinf(arr)
           

輸出結果：

array([False, False, True, False, True, False])

array([ 2., 5., 8., inf])

array([ True, True, False, True, False, False])

array([False, False, False, False, False, True])

二進制函數

常用的二進制函數主要有：取模，點積，比較大小，邏輯與/或/異或，指數運算。

函數名	調用方法	描述
mod	np.mod(arr1, arr2)	元素級的取模計算（除法取餘）
dot	np.dot(arr1, arr2)	求兩個數組的點積
greater、greater_equal、less、less_equal、equal、not_equal	np.greater(arr1, arr2) np.less(arr1, arr2) np.equal(arr1, arr2)	執行元素級的比較運算，傳回一個布爾型數組。greater：大于，less：小于，equal：等于
logical_and、logical_or、logical_xor	np.logical_and(arr1,arr2) np.logical_or(arr1,arr2) np.logical_xor(arr1,arr2)	執行元素級的布爾邏輯運算，相當于中綴運算符&、^ 、| （與，或，異或）
power	np.power(arr, 3)	求解對數組中的每個元素進行給定次數的指數值，類似于: arr ** 3

# 取餘操作：mod(num, mod)  num為被除數，mod 為除數 (num 和 mod 可以是一個數或數組)
arr01 = np.array([7, 12, 25, 18])
arr02 = np.array([3, 8, 10, 12])
print("數組arr01 對數組arr02 取模：", np.mod(arr01, arr02))
print("數組arr01 對數字8 取模：", np.mod(arr01, 8))

# 點積：矩陣的數量積 dot(arr1, arr2)
print(np.dot(arr01, arr02))     # 等于7*3+12*8+25*10+18*12

# power(x, m): 求指數，x的m次方
np.power(arr01, 2)
           

輸出結果：

數組arr01 對數組arr02 取模： [1 4 5 6]

數組arr01 對數字8 取模： [7 4 1 2]

583

array([ 49, 144, 625, 324], dtype=int32)

# 比較大小：greater/equal/less
arr1 = np.array([7, 12, 25, 18, 16])
arr2 = np.array([13, 8, 30, 18, 15])
print("arr1是否大于arr2：", np.greater(arr1, arr2))  #大于：若arr1>arr2, 則傳回True；否則傳回False
print("arr1是否等于arr2：", np.equal(arr1, arr2))
print("arr1是否小于等于arr2：", np.less_equal(arr1, arr2))

# 邏輯運算：與/或/異或  
# logical_and(arr1, arr2)：&
# logical_or(arr1, arr2)：|
# logical_xor(arr1, arr2)：^
arr = np.array([21, 70, 45, 9, 62, 49, 71, 13, 50, 80])
condition = np.logical_and(arr>=60, arr<=80)
print(condition)
arr[condition]
           

輸出結果：

arr1是否大于arr2： [False True False False True]

arr1是否等于arr2： [False False False True False]

arr1是否小于等于arr2： [ True False True True False]

[False True False False True False True False False True]

array([70, 62, 71, 80])

六、聚合函數

聚合函數是對一組（eg一個數組）進行操作，傳回一個單一值作為結果的函數。 聚合函數也可以指定對某個具體的軸進行資料聚合操作；常見的聚合操作有： 平均值、最大值、最小值、總體标準偏差等。

• 最大值：

  np.amax(arr)

  ; 等價于

  arr.max()

• 最小值：

  np.amin(arr)

  ; 等價于

  arr.min()

• 平均值：

  np.mean(arr)

  ; 等價于

  arr.mean()

• 标準差：

  np.std(arr)

  ; 等價于

  arr.std()

• 方差：

  np.var(arr)

  ; 公式：np.mean((arr - arr.mean())**2)

arr = np.array([[23, 12, 35], [19, 26, 8]])
print("每一列的最大值：", np.amax(arr, axis=0))  #axis=0：求每一列 的最大值
print("每一行的最小值：", np.amin(arr, axis=1))  #axis=1：求每一行 的最小值
print("數組的最大值：", arr.max())     #求數組的最大值
print("數組的最大值：", arr.min())     #求數組的最小值
print("每一行的平均值：", np.mean(arr, axis=1).round(3))  #求每一行的平均值
print("數組的标準差：", np.std(arr).round(3))  #求數組的标準差
print("數組的标準差：", arr.std().round(3))    
print("數組的方差：",np.var(arr).round(3))
           

輸出結果：

每一列的最大值： [23 26 35]

每一行的最小值： [12 8]

數組的最大值： 35

數組的最大值： 8

每一行的平均值： [23.333 17.667]

數組的标準差： 8.921

數組的标準差： 8.921

數組的方差： 79.583

七、np.where函數

• 三元表達式：

  x if condition else y

  : condition為真傳回x，否則傳回y。

• np.where(condition, x, y)

  ：condition為True傳回x，否則傳回y。
• 三元表達式可用清單遞推式表達：

  arr = [x if c else y for x,y,c in zip(arr1, arr2, condition)]
  #zip函數: 依次從arr1,arr2,condition 數組中取值按順序賦給x,y,c
             

  等價于：

  np.where(condition, arr1, arr2)  
  #where函數：condition為True則傳回arr1，否則傳回arr2
             

  Example：

  arr1 = np.random.randint(1,20, (2,5))
  arr2 = np.random.randint(1,20, (2,5))
  print("arr1：\n", arr1)
  print("arr2：\n", arr2)
  cond = arr1>arr2
  np.where(cond, arr1, arr2)  #傳回兩數組對應位置較大的數
             

  輸出結果：

  arr1：

  [[14 15 1 15 18]

  [ 1 8 16 10 4]]

  arr2：

  [[ 4 13 1 15 11]

  [ 7 8 13 4 18]]

  array([[14, 15, 1, 15, 18],

  [ 7, 8, 16, 10, 18]])

八、np.unique函數

np.unique(arr)

：去重+排序，隻保留不重複的資料。

arr = np.array([2, 6, 4, 2, 5, 8, 3, 6, 5])
np.unique(arr)
           

輸出結果：

array([2, 3, 4, 5, 6, 8])

*以上是Numpy 的基本屬性及常用方法，更多相關知識請參考：

1、NumPy官網：http://www.numpy.org/

2、官方文檔：https://docs.scipy.org/doc/numpy/user/index.html