Numpy詳解
阿新 • • 發佈：2018-04-29
perm multi 多維 source dia fill 分隔符 convert isnan
NumPy 簡介
Python並沒有提供數組功能。雖然列表可以完成基本的數組功能，但它不是真正的數組，而且在數據量比較大時，使用列表的速度會很慢。為此，Numpy提供了真正的數組功能，以及對數據進行快速處理的函數。
NumPy的主要對象是同種元素的多維數組。這是一個所有的元素都是一種類型、通過一個正整數元組索引的元素表格(通常是元素是數字)。在NumPy中維度(dimensions)叫做軸(axes)，軸的個數叫做秩(rank)。
例如，在3D空間一個點的坐標 [1, 2, 3] 是一個秩為1的數組，因為它只有一個軸。那個軸長度為3.又例如，在以下例子中，數組的秩為2(它有兩個維度).第一個維度長度為2,第二個維度長度為3.
[[ 1., 0., 0.],
[ 0., 1., 2.]]NumPy的數組類被稱作 ndarray 。通常被稱作數組。註意numpy.array和標準Python庫類array.array並不相同，後者只處理一維數組和提供少量功能。
數據類型
numpy的數據類型有下面的幾個
| 數據類型 | 描述 |
|---|---|
| bool_ | 以字節存儲的布爾值（True 或 False） |
| int_ | 默認的整數類型（和 C 的 long 一樣，是 int64 或者 int32） |
| intc | 和 C 的 int 相同（一般為 int64 或 int32） |
| intp | 用於下標的整數（和 C 的 ssize_t 相同，一般為int64 或者 int32） |
| int8 | 字節（-128 到 127） |
| int16 | 整數（-32768 到 32767） |
| int32 | 整數（-2147483648 到 2147483647） |
| int64 | 整數（-9223372036854775808 到 9223372036854775807） |
| uint8 | 無符號整數（0 到 255） |
| uint16 | 無符號整數（0 到 65535） |
| uint32 | 無符號整數（0 到 4294967295） |
| uint64 | 無符號整數（0 到 18446744073709551615） |
| float_ | float64 的簡寫 |
| float16 | 半精度浮點：1位符號，5位指數，10位尾數 |
| float32 | 單精度浮點：1位符號，8位指數，23位尾數 |
| float64 | 雙精度浮點：1位符號，11位指數，52位尾數 |
| complex_ | complex128 的簡寫 |
| complex64 | 由兩個32位浮點（實部和虛部）組成的復數 |
| complex128 | 由兩個64位浮點（實部和虛部）組成的復數 |
此外，Intel平臺相關的C整數類型 short、long，long long 和它們的無符號版本是有定義的。
NumPy 數組對象
NumPy中的 ndarray 是一個多維數組對象，該對象由兩部分組成：
- 實際的數據；
- 描述這些數據的元數據。
大部分的數組操作僅僅修改元數據部分，而不改變底層的實際數據。
數組對象的創建
第一種就是創建數組的方式：使用array函數從常規的 list， tuple等格式的數據轉創建為ndarray， 默認創建一個新的數組，所創建的數組類型由原序列中的元素類型推導而來。
- 第二種方法的應用場景是很多時候我們對所創建的數組內的元素未知，但數組的大小已知。針對這種情況，NumPy提供了一些使用占位符創建數組的函數，也就是說一個常量值初始化一個數組。比如：用函數zeros可創建一個全是0的數組，用函數ones可創建一個全為1的數組，函數empty創建一個內容隨機並且依賴與內存狀態的數組（默認數組類型(dtype)為float64）。這些函數有助於滿足除了數組擴展的需要，同時降低了高昂的運算開銷。
- 第三種常見的創建數組的方法.我們可以使用 arange方法，創建數組序列。
第四種創建隨機數組
最後，創建具有隨機數字的數組通常是非常有用的。 np.random模塊包含許多可用於此效果的函數，例如，這將生成一個從標準正態分布（0均值和方差1）中抽取的5個隨機樣本數組：
| 生成函數 | 作用 |
|---|---|
| np.array( x )np.array( x, dtype ) | 將輸入數據轉化為一個ndarray將輸入數據轉化為一個類型為type的ndarray |
| np.asarray( array ) | 將輸入數據轉化為一個新的（copy）ndarray |
| np.ones( N )np.ones( N, dtype)np.ones_like( ndarray ) | 生成一個N長度的一維全一ndarray生成一個N長度類型是dtype的一維全一ndarray生成一個形狀與參數相同的全一ndarray |
| np.zeros( N)np.zeros( N, dtype)np.zeros_like(ndarray) | 生成一個N長度的一維全零ndarray生成一個N長度類型位dtype的一維全零ndarray類似np.ones_like( ndarray ) |
| np.empty( N )np.empty( N, dtype)np.empty(ndarray) | 生成一個N長度的未初始化一維ndarray生成一個N長度類型是dtype的未初始化一維ndarray類似np.ones_like( ndarray ) |
| np.eye( N )np.identity( N ) | 創建一個N * N的單位矩陣（對角線為1，其余為0） |
| np.arange( num)np.arange( begin, end)np.arange( begin, end, step) | 生成一個從0到num-1步數為1的一維ndarray生成一個從begin到end-1步數為1的一維ndarray生成一個從begin到end-step的步數為step的一維ndarray |
| np.mershgrid(ndarray, ndarray,...) | 生成一個ndarray * ndarray * ...的多維ndarray |
| np.where(cond, ndarray1, ndarray2) | 根據條件cond，選取ndarray1或者ndarray2，返回一個新的ndarray |
| np.in1d(ndarray, [x,y,...]) | 檢查ndarray中的元素是否等於[x,y,...]中的一個，返回bool數組 |
np.zeros(5,dtype=int)
Out[8]: array([0, 0, 0, 0, 0])
np.zeros(5,dtype=complex)
Out[9]: array([0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j])
np.zeros((2,3),int)
Out[10]:
array([[0, 0, 0],
[0, 0, 0]])
np.ones((2, 3))
Out[11]:
array([[1., 1., 1.],
[1., 1., 1.]])
arr2 = np.array([1.1,1.2,1.3,1.4,1.5])
arr2
Out[13]: array([1.1, 1.2, 1.3, 1.4, 1.5])
np.ones_like(arr2)
Out[14]: array([1., 1., 1., 1., 1.])
np.zeros_like(arr2)
Out[15]: array([0., 0., 0., 0., 0.])
np.linspace(0, 1, 12,endpoint=False,retstep=True)
Out[16]:
(array([0. , 0.08333333, 0.16666667, 0.25 , 0.33333333,
0.41666667, 0.5 , 0.58333333, 0.66666667, 0.75 ,
0.83333333, 0.91666667]), 0.08333333333333333)
np.linspace(0, 1, 12,endpoint=False,retstep=False)
Out[17]:
array([0. , 0.08333333, 0.16666667, 0.25 , 0.33333333,
0.41666667, 0.5 , 0.58333333, 0.66666667, 0.75 ,
0.83333333, 0.91666667])
np.linspace(2.0, 3.0, num=5, retstep=True)
Out[18]: (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)
np.empty((2,3))
Out[19]:
array([[1., 1., 1.],
[1., 1., 1.]])
np.eye(4, 3) #創建一個對角線為 1 其他為 0 的矩陣
Out[20]:
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.]])
np.identity(3) #創建一個主對角線為 1 其他為 0 的方陣.
Out[21]:
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
c=np.arange(10,30,5)
c
Out[23]: array([10, 15, 20, 25])
d=np.random.randn(7)
d
Out[25]:
array([-2.42305704, -1.4176937 , -1.30105816, -0.2540588 , -0.01241032,
-0.79794669, 0.71402996])
e=np.random.normal(10,3,(2,4))
e
Out[27]:
array([[10.12814319, 11.56238839, 10.75997039, 9.09078182],
[12.16908517, 13.34197263, 7.9504137 , 11.87499528]])
b = np.arange(24).reshape(6,4)
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]])
Out[30]: b.ravel()
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])
Out[31]: b.flatten()
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])NumPy.ndarray的屬性
ndarray對象屬性有：
- ndarray.ndim
數組軸的個數，在python的世界中，軸的個數被稱作秩
- ndarray.shape
數組的維度。這是一個指示數組在每個維度上大小的整數元組。例如一個n排m列的矩陣，它的shape屬性將是(2,3),這個元組的長度顯然是秩，即維度或者ndim屬性
- ndarray.size
數組元素的總個數，等於shape屬性中元組元素的乘積。
- ndarray.dtype
一個用來描述數組中元素類型的對象，可以通過創造或指定dtype使用標準Python類型。另外NumPy提供它自己的數據類型。
- ndarray.itemsize
數組中每個元素的字節大小。例如，一個元素類型為float64的數組itemsiz屬性值為8(=64/8),又如，一個元素類型為complex32的數組item屬性為4(=32/8).
- ndarray.data
包含實際數組元素的緩沖區，通常我們不需要使用這個屬性，因為我們總是通過索引來使用數組中的元素。
一個例子
>>> from numpy import *
>>> a = arange(15).reshape(3, 5)
>>> a
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim
2
>>> a.dtype.name
'int32'
>>> a.itemsize
4
>>> a.size
15
>>> type(a)
numpy.ndarray
>>> b = array([6, 7, 8])
>>> b
array([6, 7, 8])
>>> type(b)
numpy.ndarray| ndarray.ndim | 獲取ndarray的維數 |
|---|---|
| ndarray.shape | 獲取ndarray各個維度的長度 |
| ndarray.dtype | 獲取ndarray中元素的數據類型 |
| ndarray.T | 簡單轉置矩陣ndarray |
NumPy.ndarray的函數
基本運算
數組的算術運算是按元素的。新的數組被創建並且被結果填充。
>>> a = array( [20,30,40,50] )
>>> b = arange( 4 )
>>> b
array([0, 1, 2, 3])
>>> c = a-b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9])
>>> 10*sin(a)
array([ 9.12945251, -9.88031624, 7.4511316 , -2.62374854])
>>> a<35
array([True, True, False, False], dtype=bool)不像許多矩陣語言，NumPy中的乘法運算符 * 指示按元素計算，矩陣乘法可以使用 dot 函數或創建矩陣對象實現(參見教程中的矩陣章節)
>>> A = array( [[1,1],
... [0,1]] )
>>> B = array( [[2,0],
... [3,4]] )
>>> A*B # elementwise product
array([[2, 0],
[0, 4]])
>>> dot(A,B) # matrix product
array([[5, 4],
[3, 4]])有些操作符像 += 和 *= 被用來更改已存在數組而不創建一個新的數組。
>>> a = ones((2,3), dtype=int)
>>> b = random.random((2,3))
>>> a *= 3
>>> a
array([[3, 3, 3],
[3, 3, 3]])
>>> b += a
>>> b
array([[ 3.69092703, 3.8324276 , 3.0114541 ],
[ 3.18679111, 3.3039349 , 3.37600289]])
>>> a += b # b is converted to integer type
>>> a
array([[6, 6, 6],
[6, 6, 6]])當運算的是不同類型的數組時，結果數組和更普遍和精確的已知(這種行為叫做upcast)。
>>> a = ones(3, dtype=int32)
>>> b = linspace(0,pi,3)
>>> b.dtype.name
'float64'
>>> c = a+b
>>> c
array([ 1. , 2.57079633, 4.14159265])
>>> c.dtype.name
'float64'
>>> d = exp(c*1j)
>>> d
array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
-0.54030231-0.84147098j])
>>> d.dtype.name
'complex128' 許多非數組運算，如計算數組所有元素之和，被作為ndarray類的方法實現
>>> a = random.random((2,3))
>>> a
array([[ 0.6903007 , 0.39168346, 0.16524769],
[ 0.48819875, 0.77188505, 0.94792155]])
>>> a.sum()
3.4552372100521485
>>> a.min()
0.16524768654743593
>>> a.max()
0.9479215542670073這些運算默認應用到數組好像它就是一個數字組成的列表，無關數組的形狀。然而，指定 axis 參數你可以吧運算應用到數組指定的軸上：
>>> b = arange(12).reshape(3,4)
>>> b
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>>
>>> b.sum(axis=0) # sum of each column
array([12, 15, 18, 21])
>>>
>>> b.min(axis=1) # min of each row
array([0, 4, 8])
>>>
>>> b.cumsum(axis=1) # cumulative sum along each row
array([[ 0, 1, 3, 6],
[ 4, 9, 15, 22],
[ 8, 17, 27, 38]])| 計算函數 | 說明 |
|---|---|
| ndarray.mean( axis=0 ) | 求平均值 |
| ndarray.sum( axis= 0) | 求和 |
| ndarray.cumsum( axis=0)ndarray.cumprod( axis=0) | 累加 累乘 |
| ndarray.std()ndarray.var() | 方差標準差 |
| ndarray.max()ndarray.min() | 最大值最小值 |
| ndarray.argmax()ndarray.argmin() | 最大值索引最小值索引 |
| ndarray.any()ndarray.all() | 是否至少有一個True是否全部為True |
| ndarray.dot( ndarray) | 計算矩陣內積 |
形狀操作
更改數組的形狀
| 函數 | 說明 |
|---|---|
| ndarray.astype(dtype) | 轉換類型，若轉換失敗則會出現TypeError |
| ndarray.copy() | 復制一份ndarray(新的內存空間) |
| ndarray.reshape((N,M,...)) | 將ndarray轉化為NM...的多維ndarray（非copy） |
| ndarray.transpose((xIndex,yIndex,...)) | 根據維索引xIndex,yIndex...進行矩陣轉置，依賴於shape，不能用於一維矩陣（非copy） |
| ndarray.swapaxes(xIndex,yIndex) | 交換維度（非copy） |
一個數組的形狀由它每個軸上的元素個數給出：
>>> a = floor(10*random.random((3,4)))
>>> a
array([[ 7., 5., 9., 3.],
[ 7., 2., 7., 8.],
[ 6., 8., 3., 2.]])
>>> a.shape
(3, 4)一個數組的形狀可以被多種命令修改：
>>> a.ravel() # flatten the array
array([ 7., 5., 9., 3., 7., 2., 7., 8., 6., 8., 3., 2.])
>>> a.shape = (6, 2)
>>> a.transpose()
array([[ 7., 9., 7., 7., 6., 3.],
[ 5., 3., 2., 8., 8., 2.]])由 ravel() 展平的數組元素的順序通常是“C風格”的，就是說，最右邊的索引變化得最快，所以元素a[0,0]之後是a[0,1]。如果數組被改變形狀(reshape)成其它形狀，數組仍然是“C風格”的。NumPy通常創建一個以這個順序保存數據的數組，所以 ravel() 將總是不需要復制它的參數 3 。但是如果數組是通過切片其它數組或有不同尋常的選項時，它可能需要被復制。函數 reshape()和 ravel() 還可以被同過一些可選參數構建成FORTRAN風格的數組，即最左邊的索引變化最快。
reshape 函數改變參數形狀並返回它，而 resize 函數改變數組自身。
>>> a
array([[ 7., 5.],
[ 9., 3.],
[ 7., 2.],
[ 7., 8.],
[ 6., 8.],
[ 3., 2.]])
>>> a.resize((2,6))
>>> a
array([[ 7., 5., 9., 3., 7., 2.],
[ 7., 8., 6., 8., 3., 2.]])如果在改變形狀操作中一個維度被給做-1，其維度將自動被計算
組合(stack)不同的數組
幾種方法可以沿不同軸將數組堆疊在一起：
>>> a = floor(10*random.random((2,2)))
>>> a
array([[ 1., 1.],
[ 5., 8.]])
>>> b = floor(10*random.random((2,2)))
>>> b
array([[ 3., 3.],
[ 6., 0.]])
>>> vstack((a,b))
array([[ 1., 1.],
[ 5., 8.],
[ 3., 3.],
[ 6., 0.]])
>>> hstack((a,b))
array([[ 1., 1., 3., 3.],
[ 5., 8., 6., 0.]])函數 column_stack 以列將一維數組合成二維數組，它等同與 vstack 對一維數組。
>>> column_stack((a,b)) # With 2D arrays
array([[ 1., 1., 3., 3.],
[ 5., 8., 6., 0.]])
>>> a=array([4.,2.])
>>> b=array([2.,8.])
>>> a[:,newaxis] # This allows to have a 2D columns vector
array([[ 4.],
[ 2.]])
>>> column_stack((a[:,newaxis],b[:,newaxis]))
array([[ 4., 2.],
[ 2., 8.]])
>>> vstack((a[:,newaxis],b[:,newaxis])) # The behavior of vstack is different
array([[ 4.],
[ 2.],
[ 2.],
[ 8.]])row_stack 函數，另一方面，將一維數組以行組合成二維數組。
對那些維度比二維更高的數組， hstack 沿著第二個軸組合， vstack 沿著第一個軸組合, concatenate 允許可選參數給出組合時沿著的軸。
Note
在復雜情況下， r_[] 和 c_[] 對創建沿著一個方向組合的數很有用，它們允許範圍符號(“:”):
>>> r_[1:4,0,4]
array([1, 2, 3, 0, 4])當使用數組作為參數時， r_ 和 c_ 的默認行為和 vstack 和 hstack 很像，但是允許可選的參數給出組合所沿著的軸的代號。
將一個數組分割(split)成幾個小數組
使用 hsplit 你能將數組沿著它的水平軸分割，或者指定返回相同形狀數組的個數，或者指定在哪些列後發生分割:
>>> a = floor(10*random.random((2,12)))
>>> a
array([[ 8., 8., 3., 9., 0., 4., 3., 0., 0., 6., 4., 4.],
[ 0., 3., 2., 9., 6., 0., 4., 5., 7., 5., 1., 4.]])
>>> hsplit(a,3) # Split a into 3
[array([[ 8., 8., 3., 9.],
[ 0., 3., 2., 9.]]), array([[ 0., 4., 3., 0.],
[ 6., 0., 4., 5.]]), array([[ 0., 6., 4., 4.],
[ 7., 5., 1., 4.]])]
>>> hsplit(a,(3,4)) # Split a after the third and the fourth column
[array([[ 8., 8., 3.],
[ 0., 3., 2.]]), array([[ 9.],
[ 9.]]), array([[ 0., 4., 3., 0., 0., 6., 4., 4.],
[ 6., 0., 4., 5., 7., 5., 1., 4.]])]vsplit 沿著縱向的軸分割， array split 允許指定沿哪個軸分割。
ndarray索引/切片方式
| ndarray[n] | 選取第n+1個元素 |
|---|---|
| ndarray[n:m] | 選取第n+1到第m個元素 |
| ndarray[:] | 選取全部元素 |
| ndarray[n:] | 選取第n+1到最後一個元素 |
| ndarray[:n] | 選取第0到第n個元素 |
| ndarray[ bool_ndarray ]註：bool_ndarray表示bool類型的ndarray | 選取為true的元素 |
| ndarray[[x,y,m,n]]... | 選取順序和序列為x、y、m、n的ndarray |
| ndarray[n,m]ndarray[n][m] | 選取第n+1行第m+1個元素 |
| ndarray[n,m,...]ndarray[n][m].... | 選取n行n列....的元素 |
當少於軸數的索引被提供時，確失的索引被認為是整個切片：
>>> b[-1] # the last row. Equivalent to b[-1,:]
array([40, 41, 42, 43])b[i] 中括號中的表達式被當作 i 和一系列 : ，來代表剩下的軸。NumPy也允許你使用“點”像 b[i,...] 。
點 (…)代表許多產生一個完整的索引元組必要的分號。如果x是秩為5的數組(即它有5個軸)，那麽:
- x[1,2,…] 等同於 x[1,2,:,:,:],
- x[…,3] 等同於 x[:,:,:,:,3]
- x[4,…,5,:] 等同 x[4,:,:,5,:].
Numpy的常用函數
| 矩陣函數 | 說明 |
|---|---|
| np.diag( ndarray)np.diag( [x,y,...]) | 以一維數組的形式返回方陣的對角線（或非對角線）元素將一維數組轉化為方陣（非對角線元素為0） |
| np.dot(ndarray, ndarray) | 矩陣乘法 |
| np.trace( ndarray) | 計算對角線元素的和 |
| 排序函數 | 說明 |
|---|---|
| np.sort( ndarray) | 排序，返回副本 |
| np.unique(ndarray) | 返回ndarray中的元素，排除重復元素之後，並進行排序 |
| np.intersect1d( ndarray1, ndarray2)np.union1d( ndarray1, ndarray2)np.setdiff1d( ndarray1, ndarray2)np.setxor1d( ndarray1, ndarray2) | 返回二者的交集並排序。返回二者的並集並排序。返回二者的差。返回二者的對稱差 |
| 一元計算函數 | 說明 |
|---|---|
| np.abs(ndarray)np.fabs(ndarray) | 計算絕對值計算絕對值（非復數） |
| np.mean(ndarray) | 求平均值 |
| np.sqrt(ndarray) | 計算x^0.5 |
| np.square(ndarray) | 計算x^2 |
| np.exp(ndarray) | 計算e^x |
| log、log10、log2、log1p | 計算自然對數、底為10的log、底為2的log、底為(1+x)的log |
| np.sign(ndarray) | 計算正負號：1（正）、0（0）、-1（負） |
| np.ceil(ndarray)np.floor(ndarray)np.rint(ndarray) | 計算大於等於改值的最小整數計算小於等於該值的最大整數四舍五入到最近的整數，保留dtype |
| np.modf(ndarray) | 將數組的小數和整數部分以兩個獨立的數組方式返回 |
| np.isnan(ndarray) | 返回一個判斷是否是NaN的bool型數組 |
| np.isfinite(ndarray)np.isinf(ndarray) | 返回一個判斷是否是有窮（非inf，非NaN）的bool型數組返回一個判斷是否是無窮的bool型數組 |
| cos、cosh、sin、sinh、tan、tanh | 普通型和雙曲型三角函數 |
| arccos、arccosh、arcsin、arcsinh、arctan、arctanh | 反三角函數和雙曲型反三角函數 |
| np.logical_not(ndarray) | 計算各元素not x的真值，相當於-ndarray |
| 多元計算函數 | 說明 |
|---|---|
| np.add(ndarray, ndarray)np.subtract(ndarray, ndarray)np.multiply(ndarray, ndarray)np.divide(ndarray, ndarray)np.floor_divide(ndarray, ndarray)np.power(ndarray, ndarray)np.mod(ndarray, ndarray) | 相加相減乘法除法圓整除法（丟棄余數）次方求模 |
| np.maximum(ndarray, ndarray)np.fmax(ndarray, ndarray)np.minimun(ndarray, ndarray)np.fmin(ndarray, ndarray) | 求最大值求最大值（忽略NaN）求最小值求最小值（忽略NaN） |
| np.copysign(ndarray, ndarray) | 將參數2中的符號賦予參數1 |
| np.greater(ndarray, ndarray) np.greater_equal(ndarray, ndarray) np.less(ndarray, ndarray) np.less_equal(ndarray, ndarray) np.equal(ndarray, ndarray) np.not_equal(ndarray, ndarray) |
> >=<br><<br><= == != |
| logical_and(ndarray, ndarray) logical_or(ndarray, ndarray) logical_xor(ndarray, ndarray) |
& | ^ |
| np.dot( ndarray, ndarray) | 計算兩個ndarray的矩陣內積 |
| np.ix_([x,y,m,n],...) | 生成一個索引器，用於Fancy indexing(花式索引) |
| 文件讀寫 | 說明 |
|---|---|
| np.save(string, ndarray) | 將ndarray保存到文件名為 [string].npy 的文件中（無壓縮） |
| np.savez(string, ndarray1, ndarray2, ...) | 將所有的ndarray壓縮保存到文件名為[string].npy的文件中 |
| np.savetxt(sring, ndarray, fmt, newline=‘\n‘) | 將ndarray寫入文件，格式為fmt |
| np.load(string) | 讀取文件名string的文件內容並轉化為ndarray對象（或字典對象） |
| np.loadtxt(string, delimiter) | 讀取文件名string的文件內容，以delimiter為分隔符轉化為ndarray |
NumPy.random函數和屬性
| 函數 | 說明 |
|---|---|
| seed()seed(int)seed(ndarray) | 確定隨機數生成種子 |
| permutation(int)permutation(ndarray) | 返回一個一維從0~9的序列的隨機排列返回一個序列的隨機排列 |
| shuffle(ndarray) | 對一個序列就地隨機排列 |
| rand(int)randint(begin,end,num=1) | 產生int個均勻分布的樣本值從給定的begin和end隨機選取num個整數 |
| randn(N, M, ...) | 生成一個NM...的正態分布（平均值為0，標準差為1）的ndarray |
| normal(size=(N,M,...)) | 生成一個NM...的正態（高斯）分布的ndarray |
| beta(ndarray1,ndarray2) | 產生beta分布的樣本值，參數必須大於0 |
| chisquare() | 產生卡方分布的樣本值 |
| gamma() | 產生gamma分布的樣本值 |
| uniform() | 產生在[0,1)中均勻分布的樣本值 |
NumPy.linalg函數和屬性
| 函數 | 說明 |
|---|---|
| det(ndarray) | 計算矩陣列式 |
| eig(ndarray) | 計算方陣的本征值和本征向量 |
| inv(ndarray)pinv(ndarray) | 計算方陣的逆計算方陣的Moore-Penrose偽逆 |
| qr(ndarray) | 計算qr分解 |
| svd(ndarray) | 計算奇異值分解svd |
| solve(ndarray) | 解線性方程組Ax = b，其中A為方陣 |
| lstsq(ndarray) | 計算Ax=b的最小二乘解 |
函數和方法(method)總覽
這是個NumPy函數和方法分類排列目錄。
創建數組
arange, array, copy, empty, empty_like, eye, fromfile, fromfunction, identity, linspace, logspace, mgrid, ogrid, ones, ones_like, r , zeros, zeros_like 轉化
astype, atleast 1d, atleast 2d, atleast 3d, mat 操作
array split, column stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, item, newaxis, ravel, repeat, reshape, resize, squeeze, swapaxes, take, transpose, vsplit, vstack 詢問
all, any, nonzero, where 排序
argmax, argmin, argsort, max, min, ptp, searchsorted, sort 運算
choose, compress, cumprod, cumsum, inner, fill, imag, prod, put, putmask, real, sum 基本統計
cov, mean, std, var 基本線性代數
cross, dot, outer, svd, vdotNumpy詳解