python3 Numpy

一.Numpy

1.主要用於科學計算，主要特色是數組--ndarry

2.優勢：

（1）相比於python中的列表，numpy數組在建立時固定大小，更改ndarry的大小將建立一個新數組並刪除原始數組

（2）ndarry數組中的元素都須要具備相同的數據類型,所以在內存中的大小相同

（3）ndarry數組相比於python內置序列，相應操做的執行效率更高（速度快），代碼更少（內存小）

（4）numpy也是其餘一些科學計算庫的基礎，好比scipy，pandas等

3.http://www.numpy.org/

 

二.數組（ndarry）

1.ndarry的基本屬性

 1 import numpy as np
 2 a = np.arange(15).reshape(3, 5)
 3 print(a)         #顯示數組
 4 print(type(a))   #類型是ndarry（多維數組）
 5 print(a.shape)   #數組形狀，3行5列
 6 print(a.size)    #數組的元素總數，3*5=15
 7 print(a.ndim)    #數組軸數，2，從0開始即0,1,2
 8 print(a.dtype)   #數組中元素的類型，int32
 9 print(a.itemsize)#數組中每一個元素的大小（以字節爲單位）,32/8=4
10 print(a.data)    #包含數組實際元素的緩衝區,不經常使用
11 ----------------------------------------------------------------
12 [[ 0  1  2  3  4]
13  [ 5  6  7  8  9]
14  [10 11 12 13 14]]
15 <class 'numpy.ndarray'>
16 (3, 5)
17 15
18 2
19 int32
20 4
21 <memory at 0x0030D558>

ndarry-多維數組

2.建立數組

（1）array函數建立數組，將元組或列表做爲參數，

 1 import numpy as np
 2 
 3 # 建立數組，將元組或列表做爲參數,dtype設定元素類型
 4 a1 = np.array(  [2, 3, 4]   )#1*3
 5 a2 = np.array(  ([1, 2, 3, 4, 5], [6, 7, 8, 9, 10]) )#2*5
 6 a3 = np.array(  [(1.5, 2, 3), (4, 5, 6)], dtype=complex )#2*3
 7 a4 = np.array(  [[1, 2], [4, 5, 7], 3]  )#3*1
 8 print(a1)
 9 print(a2)
10 print(a3)
11 print(a4)
12 ------------------------------------------------------------
13 [2 3 4]
14 [[ 1  2  3  4  5]
15  [ 6  7  8  9 10]]
16 [[1.5+0.j 2. +0.j 3. +0.j]
17  [4. +0.j 5. +0.j 6. +0.j]]
18 [list([1, 2]) list([4, 5, 7]) 3]

array

（2）arange函數建立數組序列（一維），相似range，不過返回的是數組而不是列表

1 import numpy as np
2 a=np.arange(12)#利用arange函數建立數組
3 print(a)
4 a2=np.arange(1,2,0.1)#arang函數和range函數類似
5 print(a2)
6 ----------------------------------------------------------
7 [ 0  1  2  3  4  5  6  7  8  9 10 11]
8 [1.  1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9]

arange

（3）數組之間的基本操做

 1 import numpy as np
 2 
 3 a = np.array([[1, 1],
 4               [0, 1]])
 5 b = np.array([[2, 0],
 6               [3, 4]])
 7 print(a)
 8 print(b)
 9 print(a + b)  # 元素對應元素的加減
10 print(b ** 2)  # 每一個元素的乘方
11 print(10 * b)  # 10*每一個元素
12 print(a < 3)  # 每一個元素的比較
13 print(a * b)  # 每一個元素對應元素的相乘
14 print(a @ b)  # 矩陣相乘
15 print(a.dot(b))  # 矩陣相乘
16 print(a.sum())#全部元素的和
17 print(a.min(),a.max())#最大最小值
18 print(a.sum(axis=0))#axis=0表示對列進行操做，求每列的和
19 print(a.min(axis=1))#axis=1表示對行進行操做，求每行的最小值
20 print(a.cumsum(axis=1))#cumsum累加，對行操做
21 --------------------------------------------------------
22 [[1 1]
23  [0 1]]
24 [[2 0]
25  [3 4]]
26 [[3 1]
27  [3 5]]
28 [[ 4  0]
29  [ 9 16]]
30 [[20  0]
31  [30 40]]
32 [[ True  True]
33  [ True  True]]
34 [[2 0]
35  [0 4]]
36 [[5 4]
37  [3 4]]
38 [[5 4]
39  [3 4]]
40 3
41 0 1
42 [1 2]
43 [1 0]
44 [[1 2]
45  [0 1]]

數組操做

3.建立特殊數組（矩陣）

（1）linspace用於建立指定數量等間隔的序列，實際生成一個等差數列

1 import numpy as np
2 a=np.linspace(0,1,12)#從0開始到1結束，共12個數的等差數列
3 print(a)
4 -------------------------------------------------------------------
5 [0.         0.09090909 0.18181818 0.27272727 0.36363636 0.45454545
6  0.54545455 0.63636364 0.72727273 0.81818182 0.90909091 1.        ]

linspace

（2）logspace用於生成等比數列

1 import numpy as np
2 a = np.logspace(0,2,5)#生成首位是10的0次方，末位是10的2次方，含5個數的等比數列
3 print(a)
4 -----------------------------------------------------------------
5 [  1.           3.16227766  10.          31.6227766  100.        ]

logspace

（3）其餘特殊矩陣建立方式等

 1 import numpy as np
 2 a_ones = np.ones((3,4))# ones(N)生成一個N長度的一維全一的數組，建立3*4的全1矩陣
 3 print(a_ones)#全1矩陣
 4 
 5 a_zeros = np.zeros((3,4))#zeros(N)生成一個N長度的一維全零的數組，建立3*4的全0矩陣
 6 print(a_zeros)#全0矩陣
 7 
 8 a_eye = np.eye(3)#eye(N)建立一個N * N的單位矩陣，建立3階單位矩陣
 9 print(a_eye)#單位矩陣,等同於np.identity( N )
10 
11 a_empty = np.empty((3,4))#empty(N)生成一個N長度的未初始化一維的數組，建立3*4的空矩陣
12 print(a_empty)#空矩陣（實際有值）
13 ----------------------------------------------------------------------------------
14 [[1. 1. 1. 1.]
15  [1. 1. 1. 1.]
16  [1. 1. 1. 1.]]
17 [[0. 0. 0. 0.]
18  [0. 0. 0. 0.]
19  [0. 0. 0. 0.]]
20 [[1. 0. 0.]
21  [0. 1. 0.]
22  [0. 0. 1.]]
23 [[0. 0. 0. 0.]
24  [0. 0. 0. 0.]
25  [0. 0. 0. 0.]]

矩陣建立

 

三.數組的索引和切片和迭代，類似於序列

 1 import numpy as np
 2 a = np.array([[1,2,3,4,5],[6,7,8,9,10]])
 3 print(a)
 4 print(a[:])#選取所有元素
 5 print(a[1])#選取行爲1的所有元素
 6 print(a[0:1]) #截取[0,1)的元素
 7 print(a[1,2:5]) #截取第二行第[2,5）的元素[ 8  9 10]
 8 print(a[1,:]) #截取第二行,返回 [ 6  7  8  9 10]
 9 print(a[1,2])#截取行號爲一，列號爲2的元素8
10 print(a[1][2])#截取行號爲一，列號爲2的元素8,與上面的等價
11 #與序列索引切片類似，冒號從哪到哪，逗號分隔行列
12 
13 #按條件截取
14 print(a[a>6])# 截取矩陣a中大於6的數，範圍的是一維數組
15 print(a>6)#比較a中每一個數和6的大小，輸出值False或True
16 
17 a[a>6] = 0#把矩陣a中大於6的數變成0，
18 print(a)
19 --------------------------------------------------------------
20 [[ 1  2  3  4  5]
21  [ 6  7  8  9 10]]
22 [[ 1  2  3  4  5]
23  [ 6  7  8  9 10]]
24 [ 6  7  8  9 10]
25 [[1 2 3 4 5]]
26 [ 8  9 10]
27 [ 6  7  8  9 10]
28 8
29 8
30 [ 7  8  9 10]
31 [[False False False False False]
32  [False  True  True  True  True]]

索引和切片

 1 import numpy as np
 2 a=np.arange(4,16).reshape(4,3)
 3 print(a)
 4 print('*'*30)
 5 for i in a:#迭代數組
 6     print(i,end=' ')
 7 print()
 8 print('*'*30)
 9 for row in a:#以行迭代數組
10     print(row,end=' ')
11 print()
12 print('*'*30)
13 for column in a.T:#以列迭代數組
14     print(column,end=' ')
15 print()
16 print('*'*30)
17 print(a.flatten())#以一個列表的形式存儲全部元素
18 for item in a.flat:#迭代數組的每個元素
19     print(item,end=' ')
20 print()
21 print('*'*30)
22 ------------------------------------------------------
23 [[ 4  5  6]
24  [ 7  8  9]
25  [10 11 12]
26  [13 14 15]]
27 ******************************
28 [4 5 6] [7 8 9] [10 11 12] [13 14 15] 
29 ******************************
30 [4 5 6] [7 8 9] [10 11 12] [13 14 15] 
31 ******************************
32 [ 4  7 10 13] [ 5  8 11 14] [ 6  9 12 15] 
33 ******************************
34 [ 4  5  6  7  8  9 10 11 12 13 14 15]
35 [[ 4  5  6]
36  [ 7  8  9]
37  [10 11 12]
38  [13 14 15]]
39 4 5 6 7 8 9 10 11 12 13 14 15 
40 ******************************

迭代

 

四.數組的基本方法

1.改變數組形狀

 1 a = np.floor(10*np.random.random((3,4)))
 2 print(a)
 3 #1.改變數組形狀,返回已修改的數組，但不更改原始數組
 4 print(a.ravel())#返回全部元素的一維數組，從左到右，從上到下
 5 print(a.reshape(6, 2))#reshape方法改變數組的形狀
 6 print(a.T)#轉置
 7 print(a)
 8 print('#'*30)
 9 #2.resize方法修改數組自己
10 a.resize((2,6))
11 print(a)
12 a.reshape(3,-1)#尺寸指定爲-1，則會自動計算其餘尺寸
13 print(a)
14 ------------------------------------------------
15 [[3. 2. 2. 7.]
16  [0. 8. 0. 9.]
17  [7. 8. 2. 2.]]
18 [3. 2. 2. 7. 0. 8. 0. 9. 7. 8. 2. 2.]
19 [[3. 2.]
20  [2. 7.]
21  [0. 8.]
22  [0. 9.]
23  [7. 8.]
24  [2. 2.]]
25 [[3. 0. 7.]
26  [2. 8. 8.]
27  [2. 0. 2.]
28  [7. 9. 2.]]
29 [[3. 2. 2. 7.]
30  [0. 8. 0. 9.]
31  [7. 8. 2. 2.]]
32 ##############################
33 [[3. 2. 2. 7. 0. 8.]
34  [0. 9. 7. 8. 2. 2.]]
35 [[3. 2. 2. 7. 0. 8.]
36  [0. 9. 7. 8. 2. 2.]]

改變形狀

2.數組的堆疊

 1 import numpy as np
 2 a1 = np.array([[1,2],[3,4]])
 3 a2 = np.array([[5,6],[7,8]])
 4 
 5 #!注意 參數傳入時要以列表list或元組tuple的形式傳入
 6 print(np.hstack([a1,a2]))
 7 #橫向合併，np.concatenate( (a1,a2), axis=1)等價於np.hstack( (a1,a2) ) 
 8 
 9 print(np.vstack((a1,a2)))
10 #縱向合併，np.concatenate( (a1,a2), axis=0)等價於np.vstack( (a1,a2) )
11 ----------------------------------------------------
12 [[1 2 5 6]
13  [3 4 7 8]]
14 [[1 2]
15  [3 4]
16  [5 6]
17  [7 8]]

數組堆疊

3.數組拆分

 1 import numpy as np
 2 a=np.arange(12).reshape(3,4)
 3 print(a)
 4 
 5 print(np.split(a,2,axis=1))#對a進行分割成2塊，以列方向進行操做
 6 print(np.split(a,3,axis=0))#對a進行分割成3塊，以行方向進行操做
 7 # print(np.split(a,2,axis=0))array split does not result in an equal division
 8 #split分割只能進行相等的分割
 9 
10 print(np.array_split(a,2,axis=0))
11 #array_split進行不等分割
12 
13 print(np.vsplit(a,3))#縱向分割
14 print(np.hsplit(a,3))#橫向分割
15 ----------------------------------------------------------
16 [[ 0  1  2  3]
17  [ 4  5  6  7]
18  [ 8  9 10 11]]
19 [array([[0, 1],
20        [4, 5],
21        [8, 9]]),
22  array([[ 2,  3],
23        [ 6,  7],
24        [10, 11]])]
25 [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
26 [array([[0, 1, 2, 3], [4, 5, 6, 7]]), 
27   array([[ 8,  9, 10, 11]])]
28 [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

數組分割

4.數組的拷貝

 1 a = np.arange(12)
 2 #賦值,改變a則至關於改變b
 3 b = a
 4 print(id(a)==id(b))
 5 print(b is a )
 6 print(b.base is a)
 7 print('#'*30)
 8 
 9 #淺拷貝：拷貝父對象，不會拷貝對象的內部的子對象,不一樣的數組對象共享相同的數據，即底部數據相同
10 c = a.view()#view方法建立一個查看相同數據的新數組對象
11 print(id(a)==id(c))
12 print(c is a )
13 print(c.base is a)
14 print('#'*30)
15 
16 #深拷貝：copy方法生成數組及其數據的完整副本，徹底拷貝了父對象及其子對象
17 d = a.copy()
18 print(id(a)==id(d))
19 print(d is a )
20 print(d.base is a)
21 a = np.arange(12).reshape(3,4)
22 print(a)
23 --------------------------------------------
24 True
25 True
26 False
27 ##############################
28 False
29 False
30 True
31 ##############################
32 False
33 False
34 False
35 [[ 0  1  2  3]
36  [ 4  5  6  7]
37  [ 8  9 10 11]]

拷貝

 

五.矩陣matrix

1.矩陣和數據相似

2.matrix矩陣類 繼承 ndarray類

3.產生一個矩陣類

 1 x = np.array([[1, 2], [3, 4]])
 2 m1 = np.mat(x)#若是x是矩陣或數組，則m1和x指向同一個對象，=asmatrix
 3 m2=  np.matrix(x)#建立一個全新的對象
 4 x[0,0] = 5
 5 print(m1)
 6 print(m2)
 7 print(type(m1))
 8 ----------------------------------------------
 9 [[5 2]
10  [3 4]]
11 [[1 2]
12  [3 4]]
13 <class 'numpy.matrixlib.defmatrix.matrix'>

矩陣matrix

4.矩陣相關操做

 1 import numpy as np
 2 a = np.matrix([[1,2,3],[4,5,6]])
 3 print(a)
 4 print(a.T)#轉置
 5 print(a.getI())#a的逆
 6 print(a.max()) #獲取整個矩陣的最大值 結果： 6
 7 print(a.min()) #結果：1
 8 print(a.max(axis=0))#得到每列的最大（小）值
 9 print(a.max(axis=1))#得到每行的最大（小）值
10 print(a.argmax(axis=1))# 要想得到最大最小值元素所在的位置，能夠經過argmax函數來得到
11 print(a.mean())#元素的平均值
12 print(a.mean(axis=0))#每列平均值
13 print(a.mean(axis=1))#每行平均值
14 print(a.var())#方差至關於函數mean(abs(x - x.mean())**2)
15 print(a.std())#標準差至關於sqrt(mean(abs(x - x.mean())**2))
16 print(a.sum())# 對整個矩陣求和
17 print(a.cumsum())#對整個矩陣求累積和,某位置累積和指的是該位置以前(包括該位置)全部元素的和
18 print(a.tolist())#把矩陣變成一維的
19 ---------------------------------------------------------------
20 [[1 2 3]
21  [4 5 6]]
22 [[1 4]
23  [2 5]
24  [3 6]]
25 [[-0.94444444  0.44444444]
26  [-0.11111111  0.11111111]
27  [ 0.72222222 -0.22222222]]
28 6
29 1
30 [[4 5 6]]
31 [[3]
32  [6]]
33 [[2]
34  [2]]
35 3.5
36 [[2.5 3.5 4.5]]
37 [[2.]
38  [5.]]
39 2.9166666666666665
40 1.707825127659933
41 21
42 [[ 1  3  6 10 15 21]]
43 [[1, 2, 3], [4, 5, 6]]

矩陣操做

 

六.numpy裏的random 模塊

 

 1 import numpy as np
 2 # 浮點數數組
 3 print(np.random.rand(2, 3))#給定形狀，生成隨機0-1的數組
 4 print(np.random.randn(2,3))#返回一個具備標準正太分佈的樣本
 5 print(np.random.random((3, 2)))#返回隨機的浮點數，在半開區間 [0.0, 1.0)
 6 #rangdom方法至關於ranf/sample/random_sample
 7 
 8 #整數數組
 9 print(np.random.randint(5, size=(2, 4)))#返回【0,5）的整數數組
10 print(np.random.random_integers(5, size=(3, 2)))#返回隨機的整數，位於閉區間 [0,5]
11 
12 #子數組
13 print(np.random.choice([5,4,5,6,2],[3,2]))#從給定的數組，生成知足形式的數組
14 
15 print(np.random.bytes(10))#返回隨機字節。
16 
17 #排序
18 arr = np.arange(10)
19 np.random.shuffle(arr)#修改序列，改變自身內容
20 print(arr)
21 arr2=np.random.permutation(10)#    返回一個隨機排列
22 print(arr2)
23 ---------------------------------------------
24 [[0.56087409 0.24298699 0.198769  ]
25  [0.16400281 0.03769762 0.6634636 ]]
26 [[ 0.91762298 -0.93118239  0.09195282]
27  [ 1.18961487 -0.37537299 -1.34785821]]
28 [[0.40749711 0.76773468]
29  [0.30788695 0.7469718 ]
30  [0.14610159 0.40701196]]
31 [[1 4 1 2]
32  [3 3 4 3]]
33 [[4 4]
34  [1 4]
35  [1 5]]
36 [[2 5]
37  [5 5]
38  [5 5]]
39 b'\xbfu\xa5R\xb5c\xbf\x85\x99l'
40 [5 7 9 2 3 8 1 4 0 6]
41 [7 0 4 9 3 2 1 5 6 8]

numpy的random模塊

 

七.其餘

線性代數linalg；測試支持testing；離散傅里葉變化fft；數學函數emath等