更改數組形狀
import numpy as np

# a = np.arange(8)                          # 創建0-8的一維數組
a = np.array([[1, 2, 3, 4], [3, 4, 5, 6]])
# 修改原數組的形狀，即改變行列,order按照什么方式取出，排列，C按行，F按列，K內存中的順序，A原順序
a1 = a.reshape(4, 2, order='C')             # 新形狀應要兼容原形狀，即元素個數要能填充完要求的行列

b = np.arange(10).reshape(5, 2)
for i in b.flat:                            # flat 迭代器，可以迭代數組中的每個元素，不受維度影響
    break

b1 = b.flatten(order='F').reshape(2, 5)     # flatten 返回一份拷貝的數組元素，修改不會影響原數組

b2 = b.ravel(order='C')                     # ravel 展開數組元素成一維數組，修改會影響原數組
b2[1] = 11

c = np.arange(4).reshape(2,1,2)
c1 = c.squeeze()                            # squeeze 去除數組中維度為1的項目，修改會影響原數組
c1[1] = 20
"""
flatten , ravel , squeeze 異同
    都是將多維數組降為一維數組
    flatten 返回的是拷貝，修改不影響原數組
    ravel 返回的是視圖view，修改會影響原數組
    squeeze 去除數組中維度為1的項目，修改也會影響原數組
"""

數組翻轉
d = np.arange(8).reshape(2,2,2)

d1 = np.transpose(d)                       # transpose 行列轉換，行變成列，列變成行
dd1 = d.transpose(2, 1, 0)                 # 帶參數時，將軸按參數排列，如例將軸2轉到軸0

d2 = d.T                                   # .T 行列轉換,和不帶參數的transpose一樣

d3 = np.rollaxis(d, 2,0)                   # rollaxis 將某個軸移到另一個軸前面，三個參數：數組，要滾動的軸，目標位置（默認為0）

d4 = np.swapaxes(d, 0, 2)                  # swapaxes 將兩個軸交換，三個參數：數組，軸，軸

"""
軸：數組從外到里依次為 0 1 2·····
rollaxis：滾動軸位置，就相當于數組里面的元素索引下標改變
    如: 將軸2滾動到軸0前，則索引下標由（001）→（100）
        將軸1滾動到軸0前，則索引下標由（010）→（100）
        將軸2滾動到軸1前，則索引下標由（010）→（001）
swapaxes：將軸位置互換，與帶參數的transpose類似
兩者區別：rollaxis是將某個軸提到指定軸的前面，swapaxes是將兩個軸互換
"""
如例：

e = np.array([[[0,1,2,3],[11,22,33,44],[4,5,6,7]],[[8,9,10,11],[66,77,88,99],[12,13,14,15]]])
print(e)
print(e.shape) # 形狀為（2,3,4）
e1 = np.rollaxis(e,2,0) # 滾動軸
print(e1)
print(e1.shape) # 形狀為（4, 2，3）
e2 = np.swapaxes(e,2,0) # 交換軸
print(e2.shape) # 形狀為（4, 3，2）

修改數組維度
x = np.array([[1],[2],[3]])
y = np.array([11,22,33])
s = np.broadcast(x,y)                       # 對y廣播x,得到是對象，可以使用iters迭代
# r,w = s.iters                               # 迭代得到也是對象，使用next()調用
# print(next(r),next(w))                      # 依次將廣播的結果迭代出來如（1,11）（1,22）...
z = np.empty(s.shape)                       # 根據指定的形狀生成相應形狀的空數組
z.flat = [u+v for (u,v) in s]               # u為數組x的元素，v為數組y的元素
print(z)                                    # 結果和x+y廣播效果一樣

s1 = np.broadcast_to(x,(3,3))               # 將數組廣播到指定形狀

aa = np.array([[1,2],[3,4]])
aa1 = np.expand_dims(aa,axis=1)             # 將某個數組作為一個整體插入到另外一個數組的某個軸內
print(aa.shape,aa1.shape)                   # 得到的aa1形狀是（2,1,2）

連接及分割數組

bb = np.array([[5,6],[7,8]])
ab1 = np.concatenate((aa,bb))               # concatenate ，連接兩個或多個數組，注意必須是維度相同的數組
ab2 = np.concatenate((aa,bb),axis=1)        # 參數axis可以指定以哪個軸進行連接

ab3 = np.stack((aa,bb),0)                   # stack 連接維度相同的數組，但是以新增一個軸的方式連接，參數指定以哪個軸堆疊
ab4 = np.hstack((aa,bb))                    # hstack 水平堆疊
ab5 = np.vstack((aa,bb))                    # vstack 垂直堆疊
"""
concatenate：以哪個軸連接時，就將哪個軸里的元素依次添加到另一個數組對應的軸中
        如上例：以軸0連接時結果為  [[1,2],[3,4],[5,6],[7,8]]
               以軸1連接時結果為  [[1,2,5,6],[3,4,7,8]]
        不會增加一個維度，因為軸里的元素是一個一個添加進去的
stack：數組形狀必須相同，結果必將多一維
        如上例：以軸0堆疊時結果為  [[[1,2],[3,4]], [[5,6],[7,8]]]
               以軸1堆疊時結果為  [[[1,2],[5,6]], [[3,4],[7,8]]]
        以哪個軸就將這個軸里的元素作為一個整體添加到另一個數組對應的軸中
        
hstack：數組至少兩維時，如兩維時相當于np.concatenate((aa,bb),axis=1)
        但當只有一維時，則不相同，反而和np.concatenate((aa,bb),axis=0)相同
vstack：數組至少兩維時，如兩維時相當于np.concatenate((aa,bb),axis=0)
        但當只有一維時，與之不相同,反而類似stack，會整體添加進去，并增加一個維度
        如：a=[1,2,3]     b=[4,5,6] 
            np.vstack((a,b))得到的結果是 [[1,2,3], [4,5,6]]
"""

cc1 = np.split(aa,2)                        # split 分割，參數指定分割成相同的幾個部分
cc2 = np.split(aa,[1,2])                    # 參數是數組時，則為指定位置分割

cc3 = np.hsplit(aa,2)                       # hsplit 依據橫軸分割，參數為數字等分分割，為數組則指定位置分割
cc4 = np.vsplit(aa,2)                       # vsplit 依據縱軸分割，參數為數字等分分割，為數組則指定位置分割

 如示圖：hsplit ：按照橫軸豎著分割

　　　　 vsplit ：按照縱軸橫著分割

添加與刪除 

dd = np.array([1,2,3,4,5,6])
dd1 = np.resize(dd,(2,4))                   # resize 改變數組形狀
# dd.resize((2,3))                          # 直接使用數組調用resize時，沒有返回值，直接改變原數組形狀
dd.resize((2,4))                            # 當改變數組形狀，原數組中元素個數不夠時，用0補足，多的時候舍去
"""
reshape：不管有無返回值，都不會改變原數組的形狀，且里面的元素也不會變化
        變換后的形狀要能完全容納原數組的元素，不能多也不能少
resize：當使用 numpy 調用 resize 時會返回一個指定形狀的新數組，此時不會改變原數組的形狀
        當直接使用 數組 調用 resize 時，不會返回一個新數組，返回的是none，此時會改變原數組的形狀
        當直接數組直接調用且原數組里的 元素不夠填充 新形狀時，用 0 補足
        當直接調用且原數組里的 元素填充完還有剩余時，舍去多余的元素
"""

ee = np.array([[1,2,3],[4,5,6]])
ee1 = np.append(ee,[11,22])                 # append 向數組尾部添加元素，無定義axis參數時返回必是一維數組
ee2 = np.append(ee,[[11,22,33]],axis=0)     # 當有axis參數時，則添加的元素必須和對應的軸形狀相匹配
ee3 = np.append(ee,[[11],[33]],axis=1)      # 如例軸 1 append時，原數組有2行，則必須添加2項
# 注意：axis有定義時添加項需放在array中，且向數組添加時，每個子元素都是作為一個整體進行添加，所以每個子元素是array類型

ff = np.array([[1,2],[3,4],[5,6]])
ff1 = np.insert(ff,2,[11,22])               # insert 在指定位置 之前 插入值，無定義axis時，返回一維數組
ff2 = np.insert(ff,1,[11],axis=0)           # 定義axis參數時，則按照指定軸進行位置索引
ff3 = np.insert(ff,1,[[11],[22]],axis=1)    # 如例axis=1時，索引是1時，則在2,4,6之前都插入個11，22

ff11 = np.delete(ff,3)                      # delete 刪除指定位置的元素，未定義axis時返回一維數組
ff22 = np.delete(ff,1,axis=0)               # 定義axis時，則按照指定軸進行位置索引
ff33 = np.delete(ff,np.s_[::2])             # 以步進為二的索引

g = np.array([2,3,1,2,3,5,7,3,4,5,6])
g1 = np.unique(g)                           # unique 去重，返回的是一個無重復元素的數組
g2,u1 = np.unique(g,return_index=True)      # return_index=True 返回去重后的數組每個元素在原數組中的索引下標
g3,u2 = np.unique(g,return_inverse=True)    # return_inverse=True 返回未去重的原數組的每個元素在去重后的數組中的索引下標
gg = g3[u2]                                 # 這樣可以用已經去重后的數組重構原數組
g4,u3 = np.unique(g,return_counts=True)     # return_counts=True 返回每個元素重復的個數