先學了R，最近剛剛上手python,所以想着將python和R結合起來互相對比來更好理解python。最好就是一句python，對應寫一句R。
python中的numpy模塊相當於R中的matirx矩陣格式，化爲矩陣，很多內容就有矩陣的屬性，可以方便計算。
以下符號：
=R=
代表着在R中代碼是怎麼樣的。
array模塊定義了一種序列數據結構，看起來和list很相似，但是所有成員必須是相同基本類型。
array-固定類型數據序列array作用是高效管理固定類型數值數據的序列。
筆者在使用的時候，覺得array十分特別，筆者這樣的新手，感覺有點駕馭不了。
————————————————————————————————————
速查手冊：（來源：NumPy 的 Array 介紹）
np.set_printoptions(suppress=True) # 不用科學計數法
# 屬性
ndarray.shape: 多維陣列的大小（形狀）
ndarray.ndim: 多維陣列的維度
ndarray.itemsize: 陣列當中元素的大小（佔幾個 byte）
ndarray.nbytes: 整個陣列所有元素的大小總計
ndarray.T: 轉置矩陣，只能在維度 <= 2 的時候使用，與 self.transpose() 效果相同
ndarray.flat: 把陣列扁平化輸出
# 格式轉換
ndarray.item: 類似 List 的 Index，把 Array 扁平化取得某 Index 的 value
ndarray.tolist: 把 NumPy.ndarray 輸出成 Python 原生 List 型態
ndarray.itemset: 把 ndarray 中的某個值（純量）改掉
# 維度操作
ndarray.reshape(shape): 把同樣的資料以不同的 shape 輸出（array 的 total size 要相同）
ndarray.resize(shape): 重新定義陣列的大小
ndarray.flatten(): 把多維陣列收合成一維陣列（扁平化＆Copy）
ndarray.ravel(): 回傳扁平化的陣列（無 Copy）
# 項目選擇與操作
ndarray.take(indices): 根據輸入索引值來得到指定陣列
ndarray.put(indices, values): 根據索引值改變陣列 value
ndarray.repeat(times): 重複陣列的值（類似擴張）
ndarray.sort(): 把陣列當中的元素排序
ndarray.sum(): 加總多維陣列（可指定加總的維度根據）
# 實用模塊
np.squeeze(array) # 去掉array的第一列
np.maximin(x,0,y) # 比較兩個值大小，若有小於0的，則爲0
————————————————————————————————————
一、數據生成與複製、重複
1、數列生成
構造單一數列
arange(10) =R=1:10 生成一個連貫的數列
arange(3,7) =R=3:7
arange(3,10,2) =R= seq(3, 9, by = 2)
array(arange(4)) =R= matrix(1:4)
生成的過程：
np.array([1,2])
需要np.，筆者在寫的時候，常常用R的思維去寫...
出錯： array(1,2) array([1,2]) np.array([1,2],[1,2])
類似cut分組
np.linspace(2.0, 3.0, num=5) =R= cut(2:3,5) #類似cut功能，在2,3之間分成5份
matrix矩陣組
ma=arange(10).reshape(5,2) #matrix(rep(1:10),nrow=5,ncol=2) 按行或列生成一定規則的 ones((2,3), dtype=int) =R= matrix(rep(1,6),2,3) #矩陣內元素都爲1 random.random((2,3)) =R= matrix(runif(6),2,3) #生成隨機數
構造空白數組：
ones創建全1矩陣
zeros創建全0矩陣
eye創建單位矩陣
empty創建空矩陣（實際有值）
import numpy as np a_ones = np.ones((3,4)) # 創建3*4的全1矩陣 print(a_ones) # 結果 [[ 1. 1. 1. 1.] [ 1. 1. 1. 1.] [ 1. 1. 1. 1.]] a_zeros = np.zeros((3,4)) # 創建3*4的全0矩陣 print(a_zeros) # 結果 [[ 0. 0. 0. 0.] [ 0. 0. 0. 0.] [ 0. 0. 0. 0.]] a_eye = np.eye(3) # 創建3階單位矩陣 print(a_eye) # 結果 [ 1. 0. 0.] [ 0. 1. 0.] [ 0. 0. 1.]] a_empty = np.empty((3,4)) # 創建3*4的空矩陣 print(a_empty) # 結果 [[ 1.78006111e-306 -3.13259416e-294 4.71524461e-309 1.94927842e+289] [ 2.10230387e-309 5.42870216e+294 6.73606381e-310 3.82265219e-297] [ 6.24242356e-309 1.07034394e-296 2.12687797e+183 6.88703165e-315]]
等差、等比數列
linspace()和matlab的linspace很類似，用於創建指定數量等間隔的序列，實際生成一個等差數列。
import numpy as np a = np.linspace(0,10,7) # 生成首位是0，末位是10，含7個數的等差數列 print(a) # 結果 [ 0. 1.66666667 3.33333333 5. 6.66666667 8.33333333 10. ]
linspace用於生成等差數列，而logspace用於生成等比數列。
下面的例子用於生成首位是100，末位是102，含5個數的等比數列。
import numpy as np a = np.logspace(0,2,5) print(a) # 結果 [ 1. 3.16227766 10. 31.6227766 100. ]
2、複製/重複repeat、title
貌似是list/tuple/dict唯一一個擁有重複屬性的吧？ 兩個重複函數：repeat/tile
repeat函數功能：對數組中的元素進行連續重複複製
用法有兩種：
1) numpy.repeat(a, repeats, axis=None)
2) a.repeats(repeats, axis=None)
>>>import numpy as np
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a.repeat(5)
array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4,
4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9,
9, 9, 9, 9])
>>> a
np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) #a數組的內容沒改變
tile函數功能：對整個數組進行復制拼接
用法：numpy.tile(a, reps)
其中a爲數組，reps爲重複的次數
>>> np.tile(a,2)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a
np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a=np.array([10,20])
>>>a
array([10,20])
>>>np.tile(a, (3,2)) #構造3*2個copy
array([[10, 20, 10, 20],
[10, 20, 10, 20],
[10, 20, 10, 20]])
——————————————————————————————————————————————————
二、array屬性與統計、運算
1、矩陣屬性
ma.shape #輸出5,2（矩陣橫縱維度） ma.ndim =R=dim(ma) #維度,dim(data) ma.size #元素總數，5*2
In [26]: arr3.dtype #dtype方法返回數組的數據類型 Out[26]: dtype('int32')
缺失值填補：
example = np.where(np.isnan(example), 0, example) example = np.where(np.isnan(example), 0, example)
2、數組拉直
拉直的辦法有兩個：arr3.ravel() 和 arr3.flatten()
第一種辦法：
a = arr3.ravel() #通過ravel的方法將數組拉直（多維數組降爲一維數組）
In [24]: arr3
Out[24]:
array([[ 1, 1, 2, 3],
[ 5, 8, 13, 21],
[ 34, 55, 89, 144]])
第二種辦法：
In [29]: b = arr3.flatten() #通過flatten的方法將數組拉直
In [30]: b
Out[30]: array([ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144])
兩者的區別在於ravel方法生成的是原數組的視圖，無需佔有內存空間，但視圖的改變會影響到原數組的變化。而flatten方法返回的是真實值，其值的改變並不會影響原數組的更改。
通過下面的例子也許就能明白了：
In [31]: b[:3] = 0
In [32]: arr3
Out[32]:
array([[ 1, 1, 2, 3],
[ 5, 8, 13, 21],
[ 34, 55, 89, 144]])
通過更改b的值，原數組沒有變化。
3、矩陣運算——相乘、求積
(arange(4).reshape(2,2))* (arange(8).reshape(2,2)) #組內數字相乘 dot( (arange(4).reshape(2,2)),(array([[1,2],[3,5]]))) #矩陣相乘 ma*=2 #ma=ma*2,會原地的改變數組而不是創建一個新的數組
所有元素之積：
prod()
得到數組所有元素之積，是個數字。也可以aaa.sum(axis)，分別求每一行或者是每一列的元素之積
累計積：cumprod()
all() ：如果所有元素爲真，返回真；否則返回假
特徵值 ：linalg.eigvals()
返回A的特徵值
4、矩陣運用函數——加總、求均值、累積和、極大值、極小值
ma.sum()
ma.min()
ma.max()
ma.sum(axis=0) =R=apply(b,1,sum) =R=colSums（data） #axis=0代表縱向,列；axis=1，代表橫向
ma.cumsum(axis=1) #按行，累計加總的結果
（1）求和：
ma.sum/min代表所有元素加總.
其中，如果是矩陣連加，有兩種方式：array+array=矩陣，array.sum()=數值
第一種就是mat + mat,用加號，生成的還是矩陣，高緯度；
第二種就是sum(mat)，用sum，一維單個數值.
同時注意，跟ma.sum()不一樣，.sum()返回的是一個矩陣總和。
場景一：矩陣相加-均值
data_array + data_array - data_array.mean()
場景二：矩陣小於某閾值的，賦值
data.array[data.array< 0 ] = 0
矩陣小於0的，都設置爲0
場景三：矩陣變一維向量:ravel()
data.array.ravel()
（2）求平均：
獲得矩陣中元素的平均值可以通過函數mean()。同樣地，可以獲得整個矩陣、行或列的平均值。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.mean()) #結果爲： 3.5
# 同樣地，可以通過關鍵字axis參數指定沿哪個方向獲取平均值
print(a.mean(axis=0)) # 結果 [ 2.5 3.5 4.5]
print(a.mean(axis=1)) # 結果 [ 2. 5.]
（3）進行正弦計算：
>>> y = np.sin(x)
>>> y
array([ 0.00000000e+00, 6.42787610e-01, 9.84807753e-01,
8.66025404e-01, 3.42020143e-01, -3.42020143e-01,
-8.66025404e-01, -9.84807753e-01, -6.42787610e-01,
-2.44921271e-16])
矩陣函數 說明
np.sin(a) 對矩陣a中每個元素取正弦,sin(x)
np.cos(a) 對矩陣a中每個元素取餘弦,cos(x)
np.tan(a) 對矩陣a中每個元素取正切,tan(x)
np.arcsin(a) 對矩陣a中每個元素取反正弦,arcsin(x)
np.arccos(a) 對矩陣a中每個元素取反餘弦,arccos(x)
np.arctan(a) 對矩陣a中每個元素取反正切,arctan(x)
np.exp(a) 對矩陣a中每個元素取指數函數,ex
np.sqrt(a) 對矩陣a中每個元素開根號√x
（4）累計和：
aaa.cumsum()
2 結果爲：array([ 10, 19, 27, 34, 40, 45, 87, 120, 122])
（5）求最大值，最小值：
獲得矩陣中元素最大最小值的函數分別是max和min，可以獲得整個矩陣、行或列的最大最小值。
例如
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.max()) #獲取整個矩陣的最大值 結果： 6
print(a.min()) #結果：1
# 可以指定關鍵字參數axis來獲得行最大（小）值或列最大（小）值
# axis=0 行方向最大（小）值，即獲得每列的最大（小）值
# axis=1 列方向最大（小）值，即獲得每行的最大（小）值
# 例如
print(a.max(axis=0))
# 結果爲 [4 5 6]
print(a.max(axis=1))
# 結果爲 [3 6]
# 要想獲得最大最小值元素所在的位置，可以通過argmax函數來獲得
print(a.argmax(axis=1))
# 結果爲 [2 2]
（6）求方差與標準差
方差：比較簡單，分別是np.sum(), np.mean(), np.var(), np.std()(這個是標準差)，關鍵是在加入axis參數以後要很好的區分
>>> a
array([[6, 7, 1, 6],
[1, 0, 2, 3],
[7, 8, 2, 1]])
方差：
>>> np.var(a)
7.7222222222222223
>>> np.var(a,axis=0)
array([ 6.88888889, 12.66666667, 0.22222222, 4.22222222])
>>> np.std(a,axis=0)
array([ 2.62466929, 3.55902608, 0.47140452, 2.05480467])
5、偏度、峯度
參考：Python統計學一數據的概括性度量、《Python數據分析基礎教程：Numpy學習指南》- 速記 - 第十章
在scipy模塊中
偏度（skewness）、描述的是概率分佈的偏斜（非對稱）程度。偏度檢驗有兩個返回值，其中第二個返回值爲p-value，即觀察到的數據集服從正態分佈的概率，取值範圍爲0~1
峯度（kurtosis）描述的是概率分佈曲線的陡峭程度。
偏態係數：偏度(Skewness)亦稱偏態、偏態係數，偏度是統計數據分佈偏斜方向和程度的度量，是統計數據分佈非對稱程度的數字特徵。Sk>0時，分佈呈正偏態（右偏），Sk<0時，分佈呈負偏態（左偏）。
峯態係數：（Kurtosis)峯度係數是用來反映頻數分佈曲線頂端尖峭或扁平程度的指標。在正態分佈情況下，峯度係數值是3。>3的峯度係數說明觀察量更集中，有比正態分佈更短的尾部；<3的峯度係數說明觀測量不那麼集中，有比正態分佈更長的尾部，類似於矩形的均勻分佈。峯度係數的標準誤用來判斷分佈的正態性。峯度係數與其標準誤的比值用來檢驗正態性。如果該比值絕對值大於2，將拒絕正態性。
from scipy import stats
import matplotlib.pyplot as plt
generated = stats.norm.rvs(size=900) #使用scipy.stats包按正態分佈生成隨機數。
print "Mean", "Std", stats.norm.fit(generated) #用正態分佈去擬合生成的數據，得到其均值和標準差。
#偏度（skewness）描述的是概率分佈的偏斜（非對稱）程度。偏度檢驗有兩個返回值，其中第二個返回值爲p-value，即觀察到的數據集服從正態分佈的概率，取值範圍爲0~1。
print "Skewtest", "pvalue", stats.skewtest(generated)
#output
#Skewtest pvalue (-0.62120640688766893, 0.5344638245033837)
#該數據集有53%的概率服從正態分佈。
#峯度（kurtosis）描述的是概率分佈曲線的陡峭程度。
print "Kurtosistest","pvalue",stats.kurtosistest(generated)
#正態性檢驗（normality test）可以檢查數據集服從正態分佈的程度。我們來做一個正態性檢驗。該檢驗同樣有兩個返回值，其中第二個返回值爲p-value。
print "Normaltest", "pvalue", stats.normaltest(generated)
#得到95%處的數值如下
print "95 percentile", stats.scoreatpercentile(generated, 95)
#將前一步反過來，可以從數值1出發找到對應的百分比
print "Percentile at 1", stats.percentileofscore(generated, 1)
6、numpy的除法
很多情況會遇到，1/2=0的情況，所以需要了解一下。
精確除法
除法總是會返回真實的商，不管操作數是整形還是浮點型。執行from __future__ import division 指令就可以做到這一點。
>>>from __future__ import division
>>>1/2
0.5
>>>1//2 0 >>>1.0//2 0 >>>-1//2.0 -1
>>>1.0/2.0 0.5
地板除
從Python2.2開始，增加了一個操作符 // ，以執行地板除：//除法不管操作數爲何種數值類型，總是會捨去小數部分，返回數字序列中比真正的商小的最接近的數字。
>>>1//2
0
>>>1.0//2
0
>>>-1//2.0
-1
傳統除法
如果是整數除法則執行地板除，如果是浮點數除法則執行精確除法。
>>>1/2
0
>>>1.0/2.0
0.5
7、白化（Whitening）
來源於：訓練深度神經網絡的必知技巧，你知道哪些？
白化相當於在零均值化和歸一化操作之間插入一個旋轉操作，將數據投影到主軸上。一張圖片經過白化後，可以認爲每個像素之間是統計獨立的。然而白化很少在卷積神經網絡中使用，可能原因是圖像信息本來就是依靠像素之間的相對差異來體現的，白化讓像素間去相關，讓這種差異變得不確定，損失了信息。
將數據零均值化，再計算協方差矩陣（convariance matrix）來觀察數據中的相關結構。
X-=np.mean(X,axis=0)
cov=np.dot(X.T,X)/X.shape[0] #計算協方差矩陣
然後做去相關操作, 即通過將原始數據（零均值化後的數據）投影到特徵基空間（eigenbasis）。
U,S,V=np.linalg.svd(cov) #計算數據協方差矩陣的奇異值分解（SVDfactorization）
Xrot=np.dot(X,U) #對數據去相關
最後一步變換是白化，即把特徵基空間的數據除以每個維度的特徵值來標準化尺度。
Xwhite=Xrot/np.sqrt(S+1e-5) #除以奇異值的平方根，注意到這裏加了個 1e-5 是爲了防止分母是 0 的情況。
PCA 白化的一個缺點是會增加數據中的噪聲，因爲它把輸入數據的所有維度都延伸到相同的大小，這些維度中就包含噪音維度（往往表現爲不相關的且方差較小）。這種缺點在實際操作中可以通過把 1e-5 增大到一個更大的值來引入更強的平滑。
——————————————————————————————————————————
三、numpy如何導出以及導入、數列格式轉換
1、numpy如何導出、導入
參考：Python Numpy數組保存
Numpy提供了幾種數據保存的方法。
以3*4數組a爲例：
1. a.tofile("filename.bin")
這種方法只能保存爲二進制文件，且不能保存當前數據的行列信息，文件後綴不一定非要是bin，也可以爲txt，但不影響保存格式，都是二進制。
這種保存方法對數據讀取有要求，需要手動指定讀出來的數據的的dtype，如果指定的格式與保存時的不一致，則讀出來的就是錯誤的數據。
b = numpy.fromfile("filename.bin",dtype = **)
讀出來的數據是一維數組，需要利用
b.shape = 3,4重新指定維數。
2.numpy.save("filename.npy",a)
利用這種方法，保存文件的後綴名字一定會被置爲.npy，這種格式最好只用
numpy.load("filename")來讀取。
3.numpy.savetxt("filename.txt",a)
b = numpy.loadtxt("filename.txt")
用於處理一維和二維數組
2、數組格式轉換
數組轉換：tolist將數組轉換爲列表，astype()強制轉換數組的數據類型，下面是兩個函數的例子：
In [53]: b = a.tolist()
In [54]: b
Out[54]:
[[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]
In [55]: type(b)
Out[55]: list
In [56]: c = a.astype(float)
In [57]: c
Out[57]:
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.]])
In [58]: a.dtype
Out[58]: dtype('int32')
In [59]: c.dtype
Out[59]: dtype('float64')
這裏有一個非常實際的問題：
一般結果輸出都是array格式，然後我要加一個字符串形式進行，總不能.append的加，所以需要把array轉化格式。譬如有一個名稱爲a的array格式數據。
['a1.jpg',] + a.tolist()
其中，[]中間有一個"，"，這個很有意思，如果你不加就是單純的字符格式，需要加一個逗號，才能識別爲[]
其他格式轉化：
1. list轉化爲numpy.ndarray：
np.array(example)
2. numpy.ndarray轉化爲list：
list(example)
3. numpy.ndarray轉化爲dataframe:
pd.DataFrame(example)
4. dataframe轉化爲numpy.ndarray：
example.values[:, :]
————————————————————————————————————————————————————
四、array添加數據、切片、合併
1、array添加數據
a=[]
#append
a.append([1,2])
#insert
a.insert(2,1)
a.insert(2,[1,2])
append加在後面，insert(位置，內容)可以加在指定位置。這邊筆者又要吐槽自己了...以爲又在使用R，如果a是array格式的，append是不可以使用的。只有a=[]元組的時候，纔可以append加進去。
注意append用法：其中append用在list之中，在DataFrame/array無法使用
2、切片過程：
>>>Array[0:] ——>切片從前面序號“0”開始到結尾，包括“0”位
[2, 3, 9, 1, 4, 7, 6, 8]
>>>Array[:-1] ——>切片從後面序號“-1”到最前，不包括“-1”位
[2, 3, 9, 1, 4, 7, 6]
>>>Array[3:-2] ——>切從前面序號“3”開始(包括)到從後面序號“-2”結束(不包括)
[1, 4, 7]
>>>Array[3::2] ——>從前面序號“3”(包括)到最後，其中分隔爲“2”
[1, 7, 8]
3、numpy對象縱向合併
用numpy中的concatenation函數進行合併。
4、用邏輯符bool定位出numpy中的內容
vector = numpy.array([5, 10, 15, 20])
print(vector)
[ 5 10 15 20]
equal_to_ten = (vector == 10)
print(equal_to_ten)
[False True False False]
# 輸出只有相對於位布爾值是True位置上的值
print(vector[equal_to_ten])
[10]
5、橫向拼接
In [40]: arr3
Out[40]:
array([[ 0, 0, 0, 3],
[ 5, 8, 13, 21],
[ 34, 55, 89, 144]])
In [41]: arr4
Out[41]:
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
In [42]: np.hstack((arr3,arr4))
Out[42]:
array([[ 0, 0, 0, 3, 1, 2, 3, 4],
[ 5, 8, 13, 21, 5, 6, 7, 8],
[ 34, 55, 89, 144, 9, 10, 11, 12]])
橫向拼接arr3和arr4兩個數組，但必須滿足兩個數組的行數相同。
In [43]: np.vstack((arr3,arr4))
Out[43]:
array([[ 0, 0, 0, 3],
[ 5, 8, 13, 21],
[ 34, 55, 89, 144],
[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
縱向拼接arr3和arr4兩個數組，但必須滿足兩個數組的列數相同。
In [44]: np.column_stack((arr3,arr4)) #與hstack函數具有一樣的效果
Out[44]:
array([[ 0, 0, 0, 3, 1, 2, 3, 4],
[ 5, 8, 13, 21, 5, 6, 7, 8],
[ 34, 55, 89, 144, 9, 10, 11, 12]])
In [45]: np.row_stack((arr3,arr4)) #與vstack函數具有一樣的效果
Out[45]:
array([[ 0, 0, 0, 3],
[ 5, 8, 13, 21],
[ 34, 55, 89, 144],
[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
————————————————————————————————————————
延展一：range的用法
一開始還是R的思維以爲[1:2]就可以得到一個序列，python裏面不是，需要range，有點像R裏面的rep
range(0,2) =R= [1,2]
range(0,10,2) 0-9每隔2個取數一次
xrange 用法與 range 完全相同，所不同的是生成的不是一個list對象，而是一個生成器。
>>> xrange(5)
xrange(5)
>>> list(xrange(5))
[0, 1, 2, 3, 4]
>>> xrange(1,5)
xrange(1, 5)
>>> list(xrange(1,5))
[1, 2, 3, 4]
>>> xrange(0,6,2)
xrange(0, 6, 2)
>>> list(xrange(0,6,2))
[0, 2, 4]
參考：Python xrange與range的區別
————————————————————————————————————————
延伸二：高緯度array表示[0,0,0,0]
一個array有四個維度：[1,1024,19,19]，代表的意思是，有1024個19*19矩陣，如果要抽取其中一個19*19的矩陣，則表示爲：
[0,1,:,:]
————————————————————————————————————————
延伸三：array中數據的替換
ndarray.itemset: 把 ndarray 中的某個值（純量）改掉，使用範例如下：
>>> x = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]], np.int32)
>>> x
array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]], dtype=int32)
# 把 index = 1 的 value 改成 999
>>> x.itemset(1, 999)
>>> x
array([[[ 1, 999, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[ 10, 11, 12]]], dtype=int32)
# 把 index = (1, 1, 2) 的值改成 888
>>> x.itemset((1, 1, 2), 888)
>>> x
array([[[ 1, 999, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[ 10, 11, 888]]], dtype=int32)
---------------------
作者：悟乙己
來源：CSDN
原文：https://blog.csdn.net/sinat_26917383/article/details/52290505
版權聲明：本文爲博主原創文章，轉載請附上博文鏈接！
已知reshape函數可以有一維數組形成多維數組
ravel函數可以展平數組
b.ravel()
flatten()函數也可以實現同樣的功能
區別：ravel只提供視圖view，而flatten分配內存存儲
重塑：
用元祖設置維度
>>> b.shape=(4,2,3)
>>> 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
array(［0, 1],
[2, 3］)
>>> b.transpose()
array(［0, 2],
[1, 3］)
=============數組的組合==============
>>> a
array(［0, 1, 2],
[3, 4, 5],
[6, 7, 8］)
>>> b = a*2
>>> b
array(［ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16］)
1.水平組合
>>> np.hstack((a,b))
array(［ 0, 1, 2, 0, 2, 4],
[ 3, 4, 5, 6, 8, 10],
[ 6, 7, 8, 12, 14, 16］)
>>> 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］)
2.垂直組合
>>> np.vstack((a,b))
array(［ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16］)
>>> 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］)
3.深度組合：沿着縱軸方向組合
>>> np.dstack((a,b))
array(［[ 0, 0],
[ 1, 2],
[ 2, 4］,
［ 3, 6],
[ 4, 8],
[ 5, 10］,
［ 6, 12],
[ 7, 14],
[ 8, 16］])
4.列組合column_stack()
一維數組：按列方向組合
二維數組：同hstack一樣
5.行組合row_stack()
以爲數組：按行方向組合
二維數組：和vstack一樣
6.==用來比較兩個數組
>>> a==b
array(［ True, False, False],
[False, False, False],
[False, False, False］, dtype=bool)
#True那個因爲都是0啊
==================數組的分割===============
>>> a
array(［0, 1, 2],
[3, 4, 5],
[6, 7, 8］)
>>> b = a*2
>>> b
array(［ 0, 2, 4],
[ 6, 8, 10],
[12, 14, 16］)
1.水平分割（難道不是垂直分割？？？）
>>> np.hsplit(a,3)
[array(［0],
[3],
[6］),
array(［1],
[4],
[7］),
array(［2],
[5],
[8］)]
split(a,3,axis=1)同理達到目的
2.垂直分割
>>> np.vsplit(a,3)
[array(［0, 1, 2］), array(［3, 4, 5］), array(［6, 7, 8］)]
split(a,3,axis=0)同理達到目的
3.深度分割
某三維數組：：：
>>> d = np.arange(27).reshape(3,3,3)
>>> d
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］])
深度分割後（即按照深度的方向分割）
注意：dsplite只對3維以上數組起作用
raise ValueError('dsplit only works on arrays of 3 or more dimensions')
ValueError: dsplit only works on arrays of 3 or more dimensions
>>> np.dsplit(d,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］])]
===================數組的屬性=================
>>> a.shape #數組維度
(3, 3)
>>> a.dtype #元素類型
dtype('int32')
>>> a.size #數組元素個數
9
>>> a.itemsize #元素佔用字節數
4
>>> a.nbytes #整個數組佔用存儲空間=itemsize*size
36
>>> a.T #轉置=transpose
array(［0, 3, 6],
[1, 4, 7],
[2, 5, 8］)
選取某一行的數據：pandas DataFrame
選擇DataFrame裏面某一列等於某個值的所有行，用一條命令即可解決即：
df.loc[df['columnName']=='the value']
