先學了R，最近剛剛上手python,所以想著將python和R結合起來互相對比來更好理解python。最好就是一句python，對應寫一句R。

python中的numpy模組相當於R中的matirx矩陣格式，化為矩陣，很多內容就有矩陣的屬性，可以方便計算。

以下符號：

=R=

代表著在R中程式碼是怎麼樣的。

   array模組定義了一種序列資料結構，看起來和list很相似，但是所有成員必須是相同基本型別。

   array-固定型別資料序列array作用是高效管理固定型別數值資料的序列。

   筆者在使用的時候，覺得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、偏度、峰度

在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如何匯出、匯入

  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]

————————————————————————————————————————

延伸二：高緯度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)