Pyhton科學計算工具Numpy（一） 之數組

科學計算工具Numpy（一） 之數組

一個用python實現的科學計算包。包括：
　1.一個強大的N維數組對象Array;
　 2、比較成熟的（廣播）函數庫；
　3、用於整合C/C++和Fortran代碼的工具包；
　4、實用的線性代數、傅里葉變換和隨機數生成函數。numpy和稀疏矩陣運算包scipy配合使用更加方便。
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　——摘自百度百科

　　總之，NumPy（Numeric Python）提供了許多高級的數值編程工具，專爲進行嚴格的數字處理而產生。多爲很多大型金融公司使用。是學習python數據分析必須要學習的科學計算工具。

1.數組

1.1 數組的基本屬性

import numpy as np

ar = np.array([1,2,3,4,5,6])   #定義一個數組（一維的）
print(ar)                               #輸出數組：注意輸出的形式和列表類似但是沒有逗號！！！
print('-----------------------')
print(type(ar))                     #輸出數組的類型
print('-----------------------')
print(ar.ndim)                        #輸出數組的維度個數（軸數），或者說是‘秩（zhi四聲）’，維度的數量也稱作rank
print('-----------------------')
print(ar.shape)                      #輸出數組的維度    對於n行m列的數組，shape爲（n,m） n行m列，一維數組顯示元素個數
print('-----------------------')
print(ar.size)                            #元素的總數
print('-----------------------')
print(type(ar),ar.dtype)            #.dtype  代表裏面元素的類型（注意了，type()是函數，.dtype是方法）
print('-----------------------')
print(ar.itemsize)                    # 數組中每個元素的字節大小，int32l類型字節爲4，float64的字節爲8
print('-----------------------')
print(ar.data)                       # 包含實際數組元素的緩衝區，由於一般通過數組的索引獲取元素，所以通常不需要使用這個屬性。
print('-----------------------')
ap = np.array([[1,2,3],[1,2,3]])    #二維數組
print(ap)
print(ap.ndim)

aw = np.array([[[1,2,3],[1,2,3]],[[1,2,3],[1,2,3]]])   #三維數組
print(aw)
print(aw.ndim)
# 數組的基本屬性
# ① 數組的維數稱爲秩（rank），一維數組的秩爲1，二維數組的秩爲2，以此類推
# ② 在NumPy中，每一個線性的數組稱爲是一個軸（axes），秩其實是描述軸的數量：
# 比如說，二維數組相當於是兩個一維數組，其中第一個一維數組中每個元素又是一個一維數組
# 所以一維數組就是NumPy中的軸（axes），第一個軸相當於是底層數組，第二個軸是底層數組裏的數組。
# 而軸的數量——秩，就是數組的維數。

[1 2 3 4 5 6]
-----------------------
<class 'numpy.ndarray'>
-----------------------
1
-----------------------
(6,)
-----------------------
6
-----------------------
<class 'numpy.ndarray'> int32
-----------------------
4
-----------------------
<memory at 0x00000212285D5AC8>
-----------------------
[[1 2 3]
 [1 2 3]]
2
[[[1 2 3]
  [1 2 3]]

 [[1 2 3]
  [1 2 3]]]
3

1.2 創建數組

　　在Numpy中 創建數組的方法有很多種，要學會根據需要使用不同的方法來創建

# array()  函數創建  括號內可以是列表，元組，數組和生成器等。


ar1 = np.array(range(0,10,2))
print(ar1)
print('--------------')

ar2 = np.arange(0,10,2)
print(ar2)
print('---------------')

ar3 = np.array([1,2,3,4])
print(ar3)
ar31 = np.array([[1,2.2,3],['a','b','c']])   #跟上面的比較，當數組中有字符型，則數值型也就變成了字符型
print(ar31,ar31.shape)
print('---------------')

ar32 = np.array([[1,2.2,3,4],['a','b','c','d','f']])
print(ar32,ar32.ndim,ar32.shape)
print(np.random.rand(10).reshape(2,5))

[0 2 4 6 8]
--------------
[0 2 4 6 8]
---------------
[1 2 3 4]
[['1' '2.2' '3']
 ['a' 'b' 'c']] (2, 3)
---------------
[list([1, 2.2, 3, 4]) list(['a', 'b', 'c', 'd', 'f'])] 1 (2,)
[[ 0.30231139  0.17027745  0.89875408  0.9032712   0.06097689]
 [ 0.39610319  0.91138507  0.4159645   0.97732752  0.24083066]]

# 創建數組：arange()，類似range()，在給定間隔內返回均勻間隔的值。


print(np.arange(5,10))            
print(np.arange(1.0,10,2))
print(np.arange(10000))

[5 6 7 8 9]
[ 1.  3.  5.  7.  9.]
[   0    1    2 ..., 9997 9998 9999]

# 創建數組：linspace():返回在間隔[開始，停止]上計算的num個均勻間隔的樣本。


ar1 = np.linspace(10,20,num = 10)     #以爲num個數包含邊界，所以實際上是把10-20分成了9份
ar2 = np.linspace(10,20,num = 11)      #分成10份就要num = 11
ar3 = np.linspace(10,20,num = 10,endpoint = False)   #endpoint默認爲True ，即包含最後一個數。
ar4 = np.linspace(10,20,num = 10,endpoint = False,retstep = True)
# retstep：如果爲真，返回（樣本，步驟），其中步長是樣本之間的間距 → 輸出爲一個包含2個元素的元組，
#第一個元素爲array，第二個爲步長實際值

print(ar1,ar1.dtype)
print('---------------')

print(ar2,ar2.dtype)
print('---------------')

print(ar3,type(ar3))
print('---------------')

print(ar4)

[ 10.          11.11111111  12.22222222  13.33333333  14.44444444
  15.55555556  16.66666667  17.77777778  18.88888889  20.        ] float64
---------------
[ 10.  11.  12.  13.  14.  15.  16.  17.  18.  19.  20.] float64
---------------
[ 10.  11.  12.  13.  14.  15.  16.  17.  18.  19.] <class 'numpy.ndarray'>
---------------
(array([ 10.,  11.,  12.,  13.,  14.,  15.,  16.,  17.,  18.,  19.]), 1.0)

# 創建數組：zeros()/zeros_like()/ones()/ones_like()


print(np.zeros((3,5),dtype = np.int))               #數組的值都爲0

ar = np.array([list(range(10)),list(range(10))])
print(np.zeros_like(ar))
print('---------------')

print(np.ones(9))
print(np.ones((2,3,4)))
print('---------------')

ar = np.linspace(0,10,num =11)
print(ar)
print(np.ones(11))                       #數組的值都爲1
print(np.ones_like(ar))

[[0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]]
[[0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]]
---------------
[ 1.  1.  1.  1.  1.  1.  1.  1.  1.]
[[[ 1.  1.  1.  1.]
  [ 1.  1.  1.  1.]
  [ 1.  1.  1.  1.]]

 [[ 1.  1.  1.  1.]
  [ 1.  1.  1.  1.]
  [ 1.  1.  1.  1.]]]
---------------
[  0.   1.   2.   3.   4.   5.   6.   7.   8.   9.  10.]
[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]
[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]

# 創建數組：eye()


print(np.eye(5))
# 創建一個正方的N*N的單位矩陣，對角線值爲1，其餘爲0

[[ 1.  0.  0.  0.  0.]
 [ 0.  1.  0.  0.  0.]
 [ 0.  0.  1.  0.  0.]
 [ 0.  0.  0.  1.  0.]
 [ 0.  0.  0.  0.  1.]]

ndarray的數據類型
bool 用一個字節存儲的布爾類型（True或False）
inti 由所在平臺決定其大小的整數（一般爲int32或int64）
int8 一個字節大小，-128 至 127
int16 整數，-32768 至 32767
int32 整數，-2 31 至 2 32 -1
int64 整數，-2 63 至 2 63 - 1
uint8 無符號整數，0 至 255
uint16 無符號整數，0 至 65535
uint32 無符號整數，0 至 2 ** 32 - 1
uint64 無符號整數，0 至 2 ** 64 - 1
float16 半精度浮點數：16位，正負號1位，指數5位，精度10位、
float32 單精度浮點數：32位，正負號1位，指數8位，精度23位
float64或float 雙精度浮點數： 64位，正負號1位，指數11位，精度52位
complex64 複數，分別用兩個32位浮點數表示實部和虛部
complex128或complex 複數，分別用兩個64位浮點數表示實部和虛部

2.數組的基本函數和方法

2.1 數組的轉置

# 數組的基本形狀     .T/.reshape()/.resize()    !!!!  都是返回新的數組


import numpy as np

ar1 = np.arange(10)
ar2 = np.zeros((2,5))
print(ar1)
print(ar2)


print('---------')
print(ar1.T)
print(ar2.T)
# .T方法：轉置，例如原shape爲(3,4)/(2,3,4)，
#轉置結果爲(4,3)/(4,3,2) → 所以一維數組轉置後結果不變


print('--------')
print(ar1.reshape(5,2))
print(ar2.reshape(10,))

print('--------')
print(np.ones((4,4)).reshape(2,8))   #可直接在數組生成式後面添加
print(np.reshape(np.arange(10),(2,5)))  #*****
print('--------')


print(np.resize(np.arange(5),(3,4)))
print(np.resize(np.arange(14),(3,4)))

[0 1 2 3 4 5 6 7 8 9]
[[ 0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.]]
---------
[0 1 2 3 4 5 6 7 8 9]
[[ 0.  0.]
 [ 0.  0.]
 [ 0.  0.]
 [ 0.  0.]
 [ 0.  0.]]
--------
[[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]
[ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]
--------
[[ 1.  1.  1.  1.  1.  1.  1.  1.]
 [ 1.  1.  1.  1.  1.  1.  1.  1.]]
[[0 1 2 3 4]
 [5 6 7 8 9]]
--------
[[0 1 2 3]
 [4 0 1 2]
 [3 4 0 1]]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

2.2 數組的複製

#數據的複製


ar1 = np.zeros((2,5))
ar2 = ar1
print(ar2 is ar1)
ar1[1] = 100
print(ar1,'\n',ar2)    #ar1和ar2  都指向同一個數組 ，所以都會變化

print('------')

ar2 = ar1.copy()
ar1[1] = 50
print(ar1,'\n',ar2)

print('------')
s = np.arange(10)
print(np.resize(s,(2,6)))    #生成一個新數組
print(s.resize(2,6))     #   修改了原本的數組 
print(s)      #可以看到原數組已經修改

True
[[   0.    0.    0.    0.    0.]
 [ 100.  100.  100.  100.  100.]] 
 [[   0.    0.    0.    0.    0.]
 [ 100.  100.  100.  100.  100.]]
------
[[  0.   0.   0.   0.   0.]
 [ 50.  50.  50.  50.  50.]] 
 [[   0.    0.    0.    0.    0.]
 [ 100.  100.  100.  100.  100.]]
------
[[0 1 2 3 4 5]
 [6 7 8 9 0 1]]
None
[[0 1 2 3 4 5]
 [6 7 8 9 0 0]]

2.3 數組類型的轉換

# 數組的類型轉換   .astype()


ar1 = np.arange(10,dtype = float)
ar2 = ar1.astype(np.int64)
print(ar1,ar1.dtype)
print(ar2,ar2.dtype)

[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9.] float64
[0 1 2 3 4 5 6 7 8 9] int64

2.4 數組連接

#數組的堆疊（連接）  相當於是數據的字段或記錄的增加


a = np.arange(6)
b = np.arange(3,9)
print(a)
print(b)
print(np.hstack((a,b)))       #橫向連接（相當於是字段的連接）
print(np.vstack((a,b)))       #豎向連接   變成了（2,6）   如果豎向堆疊的兩個
print('----------')               #數組數量不一致，則會報錯
# numpy.hstack(tup)：水平（按列順序）堆疊數組


a = np.array([[1],[2],[3]])
b = np.array([['a'],['b'],['c']])
print(np.hstack((a,b)))      #橫向堆疊
print(np.vstack((a,b)))      #豎向堆疊，這裏形狀可以不一樣
print('-------')
# numpy.vstack(tup)：垂直（按列順序）堆疊數組


a = np.arange(5)    
b = np.arange(5,10)
print(np.stack((a,b)))     
print(np.stack((a,b),axis = 1))  


# numpy.stack(arrays, axis=0)：沿着新軸連接數組的序列，形狀必須一樣！
# 重點解釋axis參數的意思，假設兩個數組[1 2 3]和[4 5 6]，shape均爲(3,0)
# axis=0：[[1 2 3] [4 5 6]]，shape爲(2,3)
# axis=1：[[1 4] [2 5] [3 6]]，shape爲(3,2)

[0 1 2 3 4 5]
[3 4 5 6 7 8]
[0 1 2 3 4 5 3 4 5 6 7 8]
[[0 1 2 3 4 5]
 [3 4 5 6 7 8]]
----------
[['1' 'a']
 ['2' 'b']
 ['3' 'c']]
[['1']
 ['2']
 ['3']
 ['a']
 ['b']
 ['c']]
-------
[[0 1 2 3 4]
 [5 6 7 8 9]]
[[0 5]
 [1 6]
 [2 7]
 [3 8]
 [4 9]]

2.5 數組的拆分

#   數組的拆分     


ar =np.arange(16).reshape(4,4)
print(ar)
print(np.hsplit(ar,2),type(np.hsplit(ar,2)))     #橫向拆分，生成的是一個列表
print('--------')
print(np.hsplit(ar,2)[0])  

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])] <class 'list'>
--------
[[ 0  1]
 [ 4  5]
 [ 8  9]
 [12 13]]
---------
[[0 1 2 3 4]
 [5 6 7 8 9]]

2.6 數組的簡單運算

#與標量的運算


ar = np.arange(16).reshape(4,4)
print(ar)
print('-----------')
print(ar + 10)
print(ar - 2)
print(ar * 2)
print(ar / 2)
print(ar ** 10)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
-----------
[[10 11 12 13]
 [14 15 16 17]
 [18 19 20 21]
 [22 23 24 25]]
[[-2 -1  0  1]
 [ 2  3  4  5]
 [ 6  7  8  9]
 [10 11 12 13]]
[[ 0  2  4  6]
 [ 8 10 12 14]
 [16 18 20 22]
 [24 26 28 30]]
[[ 0.   0.5  1.   1.5]
 [ 2.   2.5  3.   3.5]
 [ 4.   4.5  5.   5.5]
 [ 6.   6.5  7.   7.5]]
[[         0          1       1024      59049]
 [   1048576    9765625   60466176  282475249]
 [1073741824 -808182895 1410065408  167620825]
 [1787822080  419538377 1491846144 1124772961]]

#  數組的函數運算


print(ar.mean())  #平均數
print(ar.max())
print(ar.min())
print(ar.std())   #標準差
print(ar.var())  #方差
print(ar.sum(),np.sum(ar,axis = 0))           # 求和，np.sum() → axis爲0，按列求和；axis爲1，按行求和
print(np.sort(np.array([1,4,3,6,8,3,6])))      #排序

7.5
15
0
4.60977222865
21.25
120 [24 28 32 36]
[1 3 3 4 6 6 8]

下一篇會講到數組索引和切片，Numpy的隨機數，文件的生成和讀取