本教程適合於numpy基礎入門，更多詳盡內容請閱讀官網http://www.numpy.org/，此篇爲numpy基礎學習教程系列之數組（向量）的屬性和方法篇，本篇篇幅較長，爲同時也是numpy的核心基礎篇，其中包含數組的屬性和各種基本的操作方法，後續還會推出python與機器學習、人工智能的其它方面的教程，歡迎廣大圈友一起交流學習，並指出其中的錯誤。
注意：以下np爲import numpy as np中的np標識符
1. numpy數組的簡介
numpy中的ndarray是一個多維數組對象，該對象由兩部分組成：
◆實際的數據
◆描述這些數據的元數據
注意：與python中一樣，numpy中的數組也是從下標0開始的，數組中元素的類型用專門的對象表示。
2. numpy數組的基本操作
獲取數組元素的類型
>>> a = np.arange(9)
>>> a.dtype
dtype('int32')
獲取數組的維度
>>> a = np.arange(10)
>>> a.shape
(10L,)
創建一個數組（np.array()創建多維數組，np.arange()創建以爲數組）
>>> m = np.array([np.arange(3),np.arange(4)])
>>> m
array([array([0,1,2]),array(0,1,2,3)],dtype=object)
>>> m.shape
(2L,)
注意：array函數可以根據給定的對象生成數組，給定的對象是類數組，如python的list等。
選取數組中的元素
-------------
| [0,1] | [0,1] |
| [1,0] | [1,1] |
-------------
注意：對於數組a，只需要用a[m,n]選取各數組元素，其中m,n爲下標。
A = np.ones((2,3))：創建一個元素爲1的數組，參數爲一個元組，表示行數和列數
B = np.zeros((2,3))：創建一個元素爲0的數組，參數爲一個元組，表示行數和列數
在Numpy中，許多函數的參數中，可以指定數據類型，此參數爲可選。
>>>np.arange(7,dtype='int16')
array([0,1,2,3,4,5,6],dtype=int16)
複數不能轉換爲整數，這樣會觸發TypeError錯誤；複數也不能轉換爲浮點數，浮點可以轉換爲複數。
>>> np.complex(2.3)
(2.3+0j)
3. 一維數組的切片與索引
>>> a =np.arange(10)
>>> a[2:7:2]
array([2, 4, 6])
注意：索引格式爲->起點索引：終點索引：步長
>>> a[::-1]
array([9, 8, 7, 6, 5, 4, 3,2, 1, 0])
>>> a[:1:-1]
array([9, 8, 7, 6, 5, 4, 3,2])
注意：負數顛倒數組（元素和索引）
4. 多維數組的索引與切片
reshape函數：作用是改變數組的“形狀”，也就是改變數組的維度，其參數爲一個元組，分別指定數組在每個維度上的大小。
>>> b =np.arange(24).reshape(2,3,4)
(2L, 3L, 4L)
>>> b
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]]])
注意：如果reshape的維度參數爲-1，則新創建的數組視圖會根據原數組的長度和另外的維度來創建新數組視圖
>>>arr =np.arange(16).reshape((4,4))
>>>arr
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>>arr.reshape(-1)
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
>>>arr.reshape(-1,1)
array([[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5],
[ 6],
[ 7],
[ 8],
[ 9],
[10],
[11],
[12],
[13],
[14],
[15]])
>>>arr.reshape(-1,2)
array([[ 0, 1],
[ 2, 3],
[ 4, 5],
[ 6, 7],
[ 8, 9],
[10, 11],
[12, 13],
[14, 15]])
>>> b[:,:,2]
array([[ 2, 6, 10],
[14, 18, 22]])
注意：第一個逗號之前表示第一維，第二個逗號之前表示第二維等以此類推。冒號:表示該維度上所有。
>>>b[0,...]
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
注意：…表示多個冒號
>>> b[::-1]
array([[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]],
[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]])
注意：如果在多維數組中執行翻轉一維數組的命令，將在最前面的維度上翻轉元素的順序。
5. 改變數組的維度
>>> b
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]]])
>>>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])
>>>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])
注意：flatten函數與ravel函數的功能一致，不過flatten函數會請求分配內存來保存結果，而ravel函數只是返回數組的一個視圖。
除了用reshape函數設置數組的維度，還可以用一個整數元組來設置數組的維度。此操作方法直接改變數組。
>>>b.shape=(6,4)
>>> b
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]])
transpose函數：在多維數組或矩陣中常用
>>> b
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]])
>>>b.transpose()
array([[ 0, 4, 8,12, 16, 20],
[ 1, 5, 9, 13, 17, 21],
[ 2, 6, 10, 14, 18, 22],
[ 3, 7, 11, 15, 19, 23]])
resize函數：resize函數和reshape函數一樣直接修改數組。
>>>b.resize((2,12))
>>> b
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]])
6. 組合數組
>>> a =np.arange(9).reshape(3,3)
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> b = 2*a
>>> b
array([[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
hstack函數：水平組合
>>>np.hstack((a,b))
array([[ 0, 1, 2, 0, 2, 4],
[ 3, 4, 5, 6, 8,10],
[ 6, 7, 8, 12, 14, 16]])
concatenate函數：可以和hstack函數實現同樣的效果
>>>np.concatenate((a,b),axis=1)
array([[ 0, 1, 2, 0, 2, 4],
[ 3, 4, 5, 6, 8,10],
[ 6, 7, 8, 12, 14, 16]])
vstack函數：垂直組合
>>>np.vstack((a,b))
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
同樣可以用concatenate函數實現垂直組合
>>>np.concatenate((a,b),axis=0)
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
dstack函數：深度組合，就是將一系列數組沿着縱軸方向進行層疊組合。
>>>np.dstack((a,b))
array([[[ 0, 0],
[ 1, 2],
[ 2, 4]],
[[ 3, 6],
[ 4, 8],
[ 5, 10]],
[[ 6, 12],
[ 7, 14],
[ 8, 16]]])
column_stack函數：列組合，對於一維數組將按列方向進行組合。
>>>oned =np.arange(2)
>>>oned
array([0, 1])
>>>twice_oned =2*oned
>>>twice_oned
array([0, 2])
>>>np.column_stack((oned,twice_oned))
array([[0, 0],
[1, 2]])
注意：對於二維數組，column_stack與hstack效果是一樣的。
row_stack函數：行組合，對於兩個一維數組，將直接層疊起來組合成一個二維數組。
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> b
array([[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
>>>np.row_stack((a,b))
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
注意：對於二維數組，row_stack與vstack效果是一樣的。
7. 數組的分割
hsplit函數：水平方向分割
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>>np.hsplit(a,3)
[array([[0],
[3],
[6]]),
array([[1],
[4],
[7]]),
array([[2],
[5],
[8]])]
注意：split(a,3,axis=1)效果與水平分割一樣
vstack函數：垂直分割
>>>np.vsplit(a,3)
[array([[0, 1, 2]]),array([[3, 4, 5]]), array([[6, 7, 8]])]
注意：split(a,3,axis=0)效果與垂直分割一樣
dsplit函數：深度分割
>>> c =np.arange(27).reshape(3,3,3)
>>> c
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]]])
>>>np.dsplit(c,3)
[array([[[ 0],
[ 3],
[ 6]],
[[ 9],
[12],
[15]],
[[18],
[21],
[24]]]), array([[[ 1],
[ 4],
[ 7]],
[[10],
[13],
[16]],
[[19],
[22],
[25]]]), array([[[ 2],
[5],
[ 8]],
[[11],
[14],
[17]],
[[20],
[23],
[26]]])]
8. 數組的其它屬性
array.shape：獲取數組每一維度的大小
ndim屬性：數組的維度或軸的個數
>>> b
array([[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
>>>b.ndim
2
size屬性：給出數組元素的總個數
>>> b
array([[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16]])
>>>b.size
9
itemsize屬性：給出數組中的元素在內存中所佔的字節數
>>>b.itemsize
4
nbytes屬性：查看整個數組所佔的內存數
>>>b.nbytes
36
注意：也可以用b.size*b.itemsize來計算整個數組所佔內存的字節數。
T屬性：效果和transpose函數一樣
>>> b
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]])
>>>b.T
array([[ 0, 4, 8,12, 16, 20],
[ 1, 5, 9, 13, 17, 21],
[ 2, 6, 10, 14, 18, 22],
[ 3, 7, 11, 15, 19, 23]])
注意：對於一維數組，其T屬性就是原數組
複數虛部：用j表示
>>> b =np.array([1.j+1,2.j+3])
>> b
array([ 1.+1.j, 3.+2.j])
real屬性：給出複數數組的實部
array([ 1.+1.j, 3.+2.j])
>>>b.real
array([ 1., 3.])
imag屬性：給出複數的虛部
>>>b.imag
array([ 1., 2.])
注意：如果數組中包含複數元素，則其數據類型自動變爲複數
flat屬性：該屬性將返回一個numpy.flatiter對象，這是獲得flatiter對象的唯一方式。這個所謂的“扁平迭代器”可以讓我們向遍歷一維數組一樣遍歷多維數組。
>>> b =np.arange(12).reshape(3,4)
>>> b
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> f = b.flat
>>> for item in f:
print item
0
1
2
3
4
5
6
7
8
9
10
11
12
注意：還可以通過flatiter對象直接獲取一個數組元素
>>> b
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]])
>>>b.flat[2]
2
注意：flat屬性是一個可以賦值的屬性，對flat屬性賦值將會導致整個數組的元素都會被覆蓋
>>>b.flat = 8
>>> b
array([[8, 8, 8, 8],
[8, 8, 8, 8],
[8, 8, 8, 8],
[8, 8, 8, 8],
[8, 8, 8, 8],
[8, 8, 8, 8]])
9. 數組的轉換
toList：將numpy數組轉換爲python列表
>>> b =np.arange(12).reshape(3,4)
>>> b
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>>b.tolist()
[[0, 1, 2, 3], [4, 5, 6, 7],[8, 9, 10, 11]]
astype函數：可以在轉換數組時指定數據類型
>>> b =np.array([1.+1.j,3.+2.j])
>>> b
array([ 1.+1.j, 3.+2.j])
>>>b.astype(int)
Warning (from warningsmodule):
File "__main__", line 2
ComplexWarning: Castingcomplex values to real discards the imaginary part array([1, 3])
注意：將複數轉換爲整數的過程中，會丟失複數的虛部，astype也可以接受數據類型爲字符串的參數。
10. 數組的修剪與壓縮
clip方法返回一個修剪過的數組，也就是將所有比給定最大值還大的元素全部設爲給定的最大值，而所有比給定最小值還小的元素全部設爲給定的最小值。
a = np.array([1,23,65,7,98])
print a.clip(20,80)
結果：[20 23 65 20 98]
compress方法返回一個根據給定條件篩選後的數組。
a = np.array([1,23,65,7,98])
print a.compress(a>50)
結果：[65 98]
11. 計算階乘
prod方法計算數組中所有元素的乘積
a = np.array([1,23,65,7,98])
print a.prod()
結果爲：1025570
cumprod方法計算數組元素的累積乘積
a = np.array([1,23,65,7,98])
print a.cumprod()
結果爲：[ 1 23 1495 10465 1025570]
12. 數組的其它方法
np.isreal(array)：判斷數組元素是否爲實數
np.trim_zeros(array)：去掉一維數組中開頭和結尾的0元素
np.asarray(a,dtype=None,order=None)：將列表轉換爲數組
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)：產生一個數組，其中數組中每個元素都是10的次冪，指數均勻的分佈在start到stop之間。也就是說返回的數組的對數服從start到stop之間的均勻分佈。
np.eye(2)：創建一個2*2的單位矩陣
A*B表示對應的元素相乘，得到另一個新的矩陣
np.dot(A, B)：數學意義上的矩陣相乘，如果形狀不匹配，則會報錯，如果A和B爲一維向量，則表示內積（點積）
np.version.version：numpy的版本號
np.diff(array)：求數組array相鄰元素的差構成的數組（差分）。
np.log(array)：計算數組array各個元素的對數
np.sqrt(array)：計算數組array中各元素的均方根值
np.take(array, indices)：表示從數組array中按照索引indices取出相應的元素
np.argmax(array)：返回數組array中最大元素的索引值
np.nanargmax(array)：與argmax函數有相同的功能，但忽略NaN值
np.argmin(array)：返回數組array中最小元素的索引值
np.argwhere(array<num)：根據條件搜索符合條件的元素，返回符合條件的元素的下標。
np.searchsorted(array, [-1, 8])：爲指定的插入值尋找維持數組排序的索引的位置，並返回該索引的值，該函數使用二分查找算法，計算複雜度爲O(logn)
np.extract(conditions, array)：基於指定條件，從數組array中抽取元素
np.nonzero(array)：從數組array中抽取非零元素。
np.exp(array)：計算數組array每個元素的指數
np.linspace(start, end, num)：返回一個元素值在指定範圍類均勻分佈的數組。
array.fill(numb)：將數組array設置爲指定的值
np.ones_like(array)：構造一個元素全爲1，結構與array相同的數組
np.zeros_like(array)：構造一個元素全爲0，結構與array相同的數組
np.intersect1d(array1,array2)：返回一個由兩個數組的公共元素組成的數組
np.unique(array, return_index=True)：返回數組中不同的值，return_index默認爲False，爲True時，既返回值，也返回元素的索引。
np.sign(array)：可以返回數組中每個元素的正負符號，數組元素爲負是返回-1，爲正時返回+1，否則返回0
aa = np.arange(-5,5)
print np.sign(aa)
結果：[-1 -1 -1 -1 -1 0 1 1 1 1]
np.piecewise(array)：獲取元素的正負，可以分段給定取值，使用合適的返回值和給定的條件。
aa = np.arange(-5,5)
print np.piecewise(aa,[aa>3,aa<3],[1,-1])
結果爲：[-1 -1 -1 -1 -1 -1 -1 -1 0 1]
ndarray.round(decimals=0, out=None)：將數組中的元素按指定的精度進行四捨五入
>>>np.around([0.37, 1.64]) # 沒有指定decimals參數，則取最近整數值。
array([ 0., 2.])
>>>np.around([0.37, 1.64], decimals=1)
array([ 0.4, 1.6])
>>>np.around([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value
array([ 0., 2., 2., 4., 4.])
>>>np.around([1,2,3,11], decimals=1) # ndarray of ints is returned
array([ 1, 2, 3, 11])
>>>np.around([1,2,3,11], decimals=-1)
array([ 0, 0, 0, 10])
add：沿着指定的軸，在連續的數組元素之間遞歸地調用通用函數，即可得到輸入數組的規約計算結果。
a = np.arange(9)
print np.add.reduce(a)
結果：36
accumulate方法同樣的可以遞歸地作用於輸入數組，與reduce方法不同，它可以存儲運算的中間結果並返回。
a = np.arange(9)
print np.add.accumulate(a)
結果：[ 0 1 3 6 10 15 21 28 36]
reduceat：輸入一個數組和一個索引值列表
a = np.arange(9)
print np.add.reduceat(a,[0,5,2,7])
結果：[10 5 20 15]
過程：第一次求索引0到5的元素之和，第二次求索引5到2的元素之和，由於2比5小，所以直接返回索引值爲5的元素。第三次求索引2到7的元素之和，第四次求索引7到末端的元素之和。
outer方法：返回一個數組，它的值等於輸入數組的兩個值之和。
print np.add.outer(np.arange(3),a)
結果：[[ 0 1 2 3 4 5 6 7 8]
[ 1 2 3 4 5 6 7 8 9]
[ 2 3 4 5 6 7 8 9 10]]
numpy.cov
函數計算協方差矩陣
a = np.array([1,23,65,7,98])
b = np.array([2,43,21,5,65])
print np.cov(a,b)
結果爲：[[ 1720.2 871.05]
[ 871.05 711.2 ]]
numpy.diagonal
函數查看對角線上的元素
a = np.array([1,23,65,7,98])
b = np.array([2,43,21,5,65])
covariance = np.cov(a,b)
print covariance.diagonal()
結果爲：[ 1720.2 711.2]
numpy.trace
計算矩陣的跡，即對角線上的元素之和
a = np.array([1,23,65,7,98])
b = np.array([2,43,21,5,65])
covariance = np.cov(a,b)
print covariance.trace()
結果爲：2431.4
numpy.corrcoef
函數計算相關係數矩陣
a = np.array([1,23,65,7,98])
b = np.array([2,43,21,5,65])
print np.corrcoef(a,b)
結果爲：[[ 1. 0.78751301]
[ 0.78751301 1. ]]
numpy.where函數是三元表達式x if condition else y的矢量化版本，定義一個布爾數組和兩個值數組。
>>>xarr=np.array([1.1,1.2,1.3,1.4,1.5])
>>>yarr=np.array([2.1,2.2,2.3,2.4,2.5])
>>>cond=np.array([True,False,True,True,False])
>>> result=[(x if c else y) for x,y,c in zip(xarr,yarr,cond)]
>>> result
[1.1000000000000001, 2.2000000000000002, 1.3, 1.3999999999999999, 2.5]
以上做法有幾個問題：第一，速度不夠快；第二：無法用於多維數組。若用np.where，則可以將該功能寫得非常簡潔。
>>>reslut=np.where(cond,xarr,yarr)
>>> result
[1.1000000000000001, 2.2000000000000002, 1.3, 1.3999999999999999, 2.5]
例：
>>>np.where([[True, False], [True, True]],
... [[1, 2], [3, 4]],
... [[9, 8], [7, 6]])
結果：array([[1, 8],
[3, 4]])
>>>x =np.arange(9.).reshape(3, 3)
>>>np.where( x >5 )
(array([2, 2, 2]), array([0, 1, 2])) # 前面一個數組爲行座標，後面一個數組爲列座標
>>>x[np.where( x >3.0 )] # Note: result is 1D.
array([ 4., 5., 6., 7., 8.])
>>>np.where(x <5, x, -1) # Note: broadcasting.
array([[ 0., 1., 2.],
[ 3., 4., -1.],
[-1., -1., -1.]])
# 一維情況
>>>aa = np.array([1,34,65,12,98])
>>>np.where(aa>50)
(array([2, 4], dtype=int64),)
numpy.delete(arr, obj, axis=None)：刪除向量的某一個分量
參數：arr—輸入向量
obj—表明哪一個子向量應該被移除，可以爲一個整數或int向量
axis—表明刪除哪個軸的子向量，若默認，則返回一個被拉平的向量
a = np.array(np.arange(12).reshape(3,4))
a
Out[301]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
np.delete(a,1,0)
Out[302]:
array([[ 0, 1, 2, 3],
[ 8, 9, 10, 11]])
np.delete(a,1,1)
Out[303]:
array([[ 0, 2, 3],
[ 4, 6, 7],
[ 8, 10, 11]])
np.delete(a,[0,1],1)
Out[304]:
array([[ 2, 3],
[ 6, 7],
[10, 11]])
np.delete(a,np.s_[::2],1)
Out[306]:
array([[ 1, 3],
[ 5, 7],
[ 9, 11]])
注意：numpy.s_[::2]表示選取奇數
numpy.insert(arr, obj, value, axis=None)
參數：arr爲目標向量
obj爲目標位置
value爲想要插入的值
axis爲插入的維度
np.insert(a,1,[1,1,1,1],0)
Out[309]:
array([[ 0, 1, 2, 3],
[ 1, 1, 1, 1],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
numpy.append(arr,values,axis=None)：將values插入到目標arr的最後
a
Out[312]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
np.append(a,[[1,1,1,1]],axis=0)
Out[313]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[ 1, 1, 1, 1]])
注意：values跟arr應該爲相同維度的向量。
numpy.select(condlist,choicelist,default=0):根據condlist條件從choicelist中返回元素。
參數：condlist-條件列表
choiclist-被選擇的元素列表，其長度與condlist相同
實例：
X = np.arange(10)
condlist = [x<3,x>5]
choicelist = [x,x**2]
np.select(condlist,choicelist)
結果爲：array([0,1,2,0,0,0,36,49,64,81])
condlist2 = [x>3,x<7] #以第一個條件爲準，第二個條件與第一個條件有重疊的元素，重疊部分以第一個條件爲準。
np.select(condlist2,choicelist)
結果爲：array([0,1,4,9,4,5,6,7,8,9])
numpy.aply_along_axis(func1d,axis,arr,*args)：在指定的軸axis上對arr運用func1d
參數：func1d—該函數接受一個一維數組，運用在一維數組arr的指定軸
axis—整形數，指定arr的哪個軸，進行運算
arr—輸入數組
args-func1d的另外的參數
實例1：
>>>defmy_func(a):
... """Average first and last element of a 1-D array"""
... return (a[0] + a[-1]) * 0.5
>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>>np.apply_along_axis(my_func, 0, b)
array([ 4., 5., 6.])
>>>np.apply_along_axis(my_func, 1, b)
array([ 2., 5., 8.])
實例2：
>>>defnew_func(a):
... """Divide elements of a by 2."""
... return a * 0.5
>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>>np.apply_along_axis(new_func, 0, b)
array([[ 0.5, 1. , 1.5],
[ 2. , 2.5, 3. ],
[ 3.5, 4. , 4.5]])