目錄

 

使用

基本操作

陣列與標量、陣列之間的運算

陣列的 矩陣積

布林索引

---

科學計算庫，新的資料結構ndarry，多維陣列物件，處理後交給pandas進一步處理

使用

import numpy as np;

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

array([[1, 2],

       [2, 3],

       [4, 5]])

#維度數量：二維陣列，前邊有兩個方括號

#建立NDarray多維陣列，可以直接使用巢狀列表

arr.dim                                       #維度數量,定義時前邊有幾個方括號就是幾個維度的陣列

arr.dtype                                    #資料型別

arr.array(['1','2','3','4'],dtype=int)           #zhuanhaun轉換資料型別

arr.size                                                          #資料多少

np.zeros((m,n))                                           #m行n列純0二維陣列

np.ones((m,n))                                           #m行n列純1二維陣列

np.empty((m,n))                                         #m行n列空二維陣列

 

arr3=arr2.astype('|U2')                            #改變資料型別

arr4=arr2.astype('|S2')

arr5=np.arange(20)

arr6=np.arange(1,20,2)                            #從[0,20,1)

arr7=arr5.reshape(4,5)                #reshape不會改變原來的資料型別，得到的新的ndarray是原陣列的檢視；元素的形狀可變，總個數不可變；

 

改變ndarray形狀：

a=np.arange(0,20,2)

a.reshape(2,5)

a.reshape(-1,5)

a.reshape(2,-1)

a.shape

a.shape=5,-1

a.shape=-1,2

 

檢視：改變arr7中的元素，arr5中的元素會相應進行修改；

副本:拷貝資料放到了新的記憶體空間,副本元素的改變不會引起原始資料的改變

對於ndarray的操作，一定要清楚改變的物件是副本還是檢視，是否會對原始資料造成改變

 

arr8=arr5.copy()            

 

 

基本操作

陣列與標量、陣列之間的運算

1. 陣列不用迴圈即可對每個元素執行批量計算，這通常叫做向量化，用陣列表示式代替迴圈的做法（通常使用迴圈進行計算）

arr+arr2

arr*arr2

arr/arr2

arr3=np.random.random((2,3))

arr3+arr4.reshape(2,3)

arr3.dot(arr4)

arr4.dot(arr3)

行軸 axis[0] 垂直的軸

列軸 axis[1] 水平的軸

arr4.dot(arr3)

arr.transpose()

np.transpose()

 

arr2

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

       [ 5,  6,  7,  8,  9],

       [10, 11, 12, 13, 14],

       [15, 16, 17, 18, 19],

       [20, 21, 22, 23, 24]])

arr2.sum(axis=0)               #沿axis=0的方向求和，也就是列方向

array([50, 55, 60, 65, 70])

 

1. 向量化陣列運算效能比純python方式快1~2個數量級
2. 大小相等的陣列之間的任何算術運算都會將運算應用到元素級
3. 大小相等的兩個陣列之間的任何算術運算都會將其運算應用到元素級上的操作
4. 元素級操作：在NumPy中，大小相等的陣列之間的運算，為元素級運算，即只用於位置相同的元素之間，所得的運算結果組成一個新的陣列，運算結果的位置跟運算元位置相同。

陣列的 矩陣積

陣列的索引

布林索引

arr5>0.1

array([[ True,  True,  True],

       [ True,  True,  True],

       [ True,  True,  True]], dtype=bool)

array([[ True,  True,  True,  True],

       [ True,  True,  True,  True],

       [ True,  True,  True,  True],

       [ True,  True,  True, False],

       [False, False, False, False],

       [False, False, False, False],

       [False, False, False, False],

       [False, False, False, False]], dtype=bool)

arr6[arr6<15]        #將布林值為真的數值取出組成一個新的陣列(是副本，不是檢視)

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

 

花式索引:

花式索引(Fancy indexing)指的是利用整數陣列進行索引的方式。

arr[][]                                                  #巢狀索引

arr[, , ]                                                 #花式索引

arr[][   ,  ,  ]                                 #花式索引與巢狀索引聯合使用

arr[[ , , ], :]

arr6[[0,3,5],:]

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

       [12, 13, 14, 15],

       [20, 21, 22, 23]])

arr6[[0,3,5],[0,3,2]]                           #按位取，前邊取出行，後邊按位取出對應的列

array([ 0, 15, 22])

 

array([   1.,    2.,  nan,    3.,  nan])

cc[np.isnan(cc)]=111

array([   1.,    2.,  111.,    3.,  111.])

 

 

np.ix_([0,3,5],[0,2,3])                      #生成一個所引器

(array([[0],

        [3],

        [5]]), array([[0, 2, 3]]))

ran

array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],

       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],

       [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],

       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],

       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],

       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],

       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],

       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79]])

ran[np.ix_([0,1,2],[0,1,2])]   花式索引得出的值是兩個軸共同確定的矩陣

array([[ 0,  1,  2],

       [10, 11, 12],

       [20, 21, 22]])

可以使用巢狀來實現：

ran [[0,1,2],:][:,[0,1,2]]    或ran[[0,1,2]][:,[0,1,2]] 

ran[[0,1,2],[0,1,2]]

array([ 0, 11, 22])

 

陣列的轉置與軸對換：注意：建立的是檢視

transpose()函式用於陣列的轉置，對於2維陣列來說是行列互換；     #arr.transpose()

陣列的T屬性，也是轉置             #arr.T

 

通用函式：

• ufunc：numpy模組中對ndarray中資料進行快速元素級運算的函式，也可以看做是簡單的函式(接受一個或多個標量值，併產生一個或多個標量值)的向量化包裝器。

•  主要包括一元函式和二元函式

 

一元ufunc	描述	呼叫方式
modf	將陣列中元素的小數位和整數位以兩部分獨立陣列的形式返回	np.modf(arr)
isnan	返回一個表示“那些值是NaN(不是一個數字)”的布林型別陣列	np.isnan(arr)
isfinite、isinf	分別一個表示”那些元素是有窮的(非inf、非NaN)”或者“那些元素是無窮的”的布林型陣列	np.isfinite(arr) np.isinf(arr)
cos、cosh、sin、sinh、tan、tanh	普通以及雙曲型三角函式	np.cos(arr) np.sin(arr) np.tan(arr)
arccos、arccosh、arcsin、arcsinh、arctan、arctanh	反三角函式	np.arccos(arr) np.arrsin(arr) np.arrtan(arr)

二元ufunc	描述	呼叫方式
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)
logical_and、logical_or、logical_xor	執行元素級別的布林邏輯運算，相當於中綴運算子&、|、^	np.logical_and(arr1,arr2) np.logical_or(arr1,arr2) np.logical_xor(arr1,arr2)
power	求解對陣列中的每個元素進行給定次數的指數值，類似於: arr ** 3	np.power(arr, 3) np.power(arr, arr2)#按位次方運算

 

聚合函式：

聚合函式是對一組值(eg一個數組)進行操作，返回一個單一值作為結果的函式。當然聚合函式也可以指定對某個具體的軸進行資料聚合操作；常將的聚合操作有：平均值、最大值、最小值、方差等等

max

min

mean

std

sum

 

arr6.sum(axis=0)              #按照列去取值      #

arr6.sum(axis=1)         # 按照行去取值    #

 

 

np.where(): 函式是三元表示式：x if condition else y的向量化版本

三元表示式：1 if 2>3  else 0

conditon=np.array([ture,false,ture,false])

x=np.array([1,1.1,1.2,1.3,1.4,1.5])

y=np.array([2,2.1,2.2,2.3,2.4,2.5])

 

np.where[condition,xarr,yarr]

等同於

zip_arr=zip(x,y,condition)

result=[x if bl else y for x,y,bl in zip_arr]

 

np.where(np.isnan(arr),0,arr);

 

 

np.unique()函式:    主要作用是將陣列中的元素進行去重操作(也就是隻儲存不重複的資料)

 

資料檔案讀寫

以二進位制方式儲存到磁碟

array_name=np.array([ … ])

np.save(‘datafile_name’,array_name)    #不需用新增字尾，將多維陣列儲存到檔案，自動新增字尾 .npy （二進位制檔案）

np.load(‘data.npy’)         #注意，此處需要字尾進行讀操作

 

文字檔案

存取文字檔案，讀取資料：

np.loadtxt(‘example.csv’,delimiter=’,’);

 1366