複製以下的程式碼，選擇執行的函式，驗證有關陣列的操作。
相關參考：Python語言程式設計（上海交通大學出版社 趙璐主編）<<----傳送門
原諒我沒有找到電子版，不然一定爬下來

解釋和輸出都在註釋中

# -*- coding: utf-8 -*-
import numpy as np


# 建立陣列的相關操作----------------------------------------------------------------------------------------
def arrayTest():
    """ 
    核心物件ndarray，稱為n維陣列，由同質元素組成，元素數量是事先定義好的

    同質是指元素的型別相同，即陣列的dtype屬性，此屬性可以指定

    以下為使用array()函式建立numpy陣列的例項

    """

    # 建立一維陣列
    aArray = np.array([1, 2, 3])
    print(type(aArray))  # <class 'numpy.ndarray'>
    print(aArray.ndim)  # 秩，陣列的維數 1
    print(aArray.size)  # 元素的個數 3
    print(aArray.shape)  # 陣列的形狀，返回型別為元組 (3,)
    print(aArray.dtype)  # 陣列的元素型別 int32
    print(aArray.itemsize)  # 元素佔用的位元組數 4

    # 建立二維陣列
    bArray = np.array([[1, 2, 3], [4, 5, 6]])
    print(bArray.ndim)
    print(bArray.size)
    print(bArray.shape)  # (2,3)
    print(bArray.dtype)
    print(bArray.itemsize)  # 4

    # 制定型別
    cArray = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int64)
    print(cArray.dtype)  # int64


# 建立陣列的其他方法----------------------------------------------------------------------------------------
def createAnArray():
    """ 
    除了array()函式建立陣列，還有其它多種函式

    如果在互動式的模式下，如python終端，IDLE等，在不用print函式的情況下，輸出時行和列之間加逗號 ','

    若用print函式輸出則行和列之間不加逗號 ','

    """

    # arange(start=None, stop, step=None, , dtype=None),與array()功能類似，但支援浮點數
    Array1 = np.arange(10.0)
    print(Array1)  # [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

    # linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
    # 建立一個指定的起止值，等分數的等差陣列，num為陣列元素個數
    Array2 = np.linspace(1, 10, 4)
    print(Array2)  # [ 1.  4.  7. 10.]

    # ones(shape, dtype=None, order='C')建立全1陣列
    Array3 = np.ones(shape=5)
    print(Array3)  # [1. 1. 1. 1. 1.]
    Array4 = np.ones((2, 3))  # 建立兩行三列的全1陣列
    print(Array4)
    # [[1. 1. 1.]
    #  [1. 1. 1.]]

    # zeros(hape, dtype=float, order='C')建立全0陣列
    Array5 = np.zeros((2, 3))
    print(Array5)
    # [[0. 0. 0.]
    #  [0. 0. 0.]]

    # full(shape, fill_value, dtype=None, order='C')建立每個元素都是full_value的陣列
    Array6 = np.full((3, 4), 2)
    print(Array6)
    # [[2 2 2 2]
    #  [2 2 2 2]
    #  [2 2 2 2]]

    # eye(N, M=None, k=0, dtype=float, order='C')建立N行，M列的單位陣列
    # M省略時，建立N行，N列的單位陣列
    Array7 = np.eye(3, dtype=int)
    print(Array7)
    # [[1 0 0]
    #  [0 1 0]
    #  [0 0 1]]
    Array8 = np.eye(3, 5, dtype=int)
    print(Array8)
    # [[1 0 0 0 0]
    #  [0 1 0 0 0]
    #  [0 0 1 0 0]]

    # random.rand(d0,d1,...,dn)建立n維陣列，元素為0~1之間的隨機小數
    Array9 = np.random.rand(2, 3)
    print(Array9)
    # [[0.23277296 0.21518778 0.62794264]
    #  [0.11016466 0.26008708 0.08924181]]


# 陣列的相關運算------------------------------------------------------------------------------------------
def basicOperation():
    """ 
    陣列的基本運算，與列表不同，列表是元素個數的變化，而這是元素數值的變化

    除了相同形狀的陣列可以進行運算外，不同形狀的陣列也可以進行相關運算

    Array4對Array3進行廣播計算，即對Array3的每一行都做運算，前提是兩陣列要 “形狀相容”

    """

    Array1 = Array2 = np.ones((2, 3), dtype=int)
    print(Array1+Array2)
    # [[2 2 2]
    #  [2 2 2]]

    print(Array1-Array2)
    # [[0 0 0]
    #  [0 0 0]]

    print(Array1*Array2)
    # [[1 1 1]
    #  [1 1 1]]

    print(Array1/Array2)
    # [[1. 1. 1.]
    #  [1. 1. 1.]]

    Array3 = np.ones((2, 3), dtype=int)
    Array4 = np.arange(3)
    print(Array3+Array4)
    # [[1 2 3]
    #  [1 2 3]]

    print(Array3+Array4 > 2)
    # [[False False  True]
    #  [False False  True]]

    print(Array3 < Array4)
    # [[False False  True]
    #  [False False  True]]

    # 陣列和普通值的計算
    print(Array3+1)
    # [[2 2 2]
    #  [2 2 2]]
    print(Array3*5)
    # [[5 5 5]
    #  [5 5 5]]


# 陣列的切片和索引-----------------------------------------------------------------------------------------
def theIndexSection():
    """ 
    ndarray與序列一樣也可以進行索引和切片的操作，方式與序列類似

    ndarray可以在不同的維度上進行

    """
    room = np.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]]])

    # room陣列是一個2*3*4的三維陣列，想象成兩層樓，每層又有3行4列
    print(room)
    # [[[0  1  2  3]
    #   [4  5  6  7]
    #   [8  9 10 11]]

    #  [[12 13 14 15]
    #   [16 17 18 19]
    #   [20 21 22 23]]]

    # 輸出0層樓0行0列房間的內容
    print(room[0, 0, 0])  # 0 也可以寫成room[0][0][0]

    # 如果不關心樓層，輸出每一層的0行0列的內容，可以將樓層用冒號 ':' 代替
    print(room[:, 0, 0])  # [ 0 12]

    # 同理，還有很多切片方式，獲取指定位置資訊
    print(room[0, :, :])
    # [[0  1  2  3]
    #  [4  5  6  7]
    #  [8  9 10 11]]
    print(room[0, 1, :])  # [4 5 6 7]

    # 選定間隔的房間
    print(room[0, 1, 0:4:2])  # [4 6]  獲取第0層，1行，第0列和第2列的內容 0,4,2依次為起始，終止，步長


# 改變陣列的形狀------------------------------------------------------------------------------------------
def formChange():

    # reshape(shape)函式改變陣列的形狀，返回一個指定形狀的陣列，不會改變原陣列
    Array1 = np.arange(12)
    Array2 = Array1.reshape((2, 6))
    print(Array2)
    # [[0  1  2  3  4  5]
    #  [6  7  8  9 10 11]]

    Array3 = Array1.reshape((2, 2, 3))
    print(Array3)
    # [[[0  1  2]
    #   [3  4  5]]

    #  [[6  7  8]
    #   [9 10 11]]]

    print(Array1)  # [ 0  1  2  3  4  5  6  7  8  9 10 11]

    # resize(new_space)直接改變原陣列，返回空值
    Array1.resize((3, 4))
    print(Array1)
    # [[0  1  2  3]
    #  [4  5  6  7]
    #  [8  9 10 11]]

    print(type(Array1))  # < class 'numpy.ndarray' >
    print(type(Array1.resize((3, 4))))  # <class 'NoneType'>

    # transpose(*axes)函式實現對陣列按軸進行轉置，即維度的變換，返回轉置後的新陣列
    Array4 = Array1.transpose()
    print(Array4)
    # [[0  4  8]
    #  [1  5  9]
    #  [2  6 10]
    #  [3  7 11]]
    print(Array1)
    # [[0  1  2  3]
    #  [4  5  6  7]
    #  [8  9 10 11]]

    # 若引數為空，則預設為完全轉置，當要按指定維度進行轉置時，可用元組方式重新編排軸的順序
    # 0，1，2 分別代表著 層，行，列
    Array5 = np.arange(24).reshape((2, 3, 4))
    print(Array5)
    # [[[0  1  2  3]
    # [4  5  6  7]
    # [8  9 10 11]]

    # [[12 13 14 15]
    # [16 17 18 19]
    # [20 21 22 23]]]

    print(Array5.transpose())  # 完全轉置，軸的順序變為(2,1,0)
    # [[[0 12]
    #   [4 16]
    #   [8 20]]

    #  [[1 13]
    #   [5 17]
    #   [9 21]]

    #  [[2 14]
    #   [6 18]
    #   [10 22]]

    #  [[3 15]
    #   [7 19]
    #   [11 23]]]

    print(Array5.transpose(0, 2, 1))  # 行列轉置
    # [[[0  4  8]
    #   [1  5  9]
    #   [2  6 10]
    #   [3  7 11]]

    #  [[12 16 20]
    #   [13 17 21]
    #   [14 18 22]
    #   [15 19 23]]]

    # flatten()函式用來展平陣列，即把高緯度陣列轉換為一維陣列，返回一個新的一維陣列
    Array6 = np.arange(6).reshape(2, 3)
    print(Array6)
    # [[0 1 2]
    #  [3 4 5]]
    Array7 = Array6.flatten()
    print(Array7)  # [0 1 2 3 4 5]
    print(Array6)
    # [[0 1 2]
    #  [3 4 5]]


# 陣列的相關計算------------------------------------------------------------------------------------------
def statistical():
    """ 
    sum()           按指定軸返回陣列元素的和

    mean()          按指定軸返回陣列元素的均值

    max()           按指定軸返回陣列元素的最大值

    min()           按指定軸返回陣列元素的最小值

    std()           按指定軸返回陣列元素的標準差

    argmin()        按指定軸返回陣列元素最小元素對應的索引構成的陣列

    argmax()        按指定軸返回陣列元素最大元素對應的索引構成的陣列

    cumsum()        按指定軸返回陣列元素的累積的和

    cumprod()       按指定軸返回陣列元素的累積的積

    """

    Array = np.arange(6).reshape((2, 3))
    print(Array.sum())  # 求所有元素的和 15
    print(Array.sum(axis=0))  # 按0軸方向求和，即按行求和，並組成新陣列返回  [3 5 7]
    print(Array.sum(axis=1))  # 按1軸方向求和，即按列求和，並組成新陣列返回  [ 3 12]
    print(Array.max())  # 5
    print(Array.max(axis=0))  # [3 4 5]
    print(Array.max(axis=1))  # [2 5]
    print(Array.cumsum(axis=0))  # 按0軸方向累積求和，即當前行是前面所有元素的和
    # [[0 1 2]
    #  [3 5 7]]

    print(Array.cumsum(axis=1))  # 按1軸方向累積求和，即當前列是前面所有元素的和
    # [[0  1  3]
    #  [3  7 12]]


# 選擇要驗證的函式-----------------------------------------------------------------------------------------
def main():
    # arrayTest()
    # createAnArray()
    # basicOperation()
    # theIndexSection()
    # formChange()
    # statistical()


if __name__ == "__main__":
    main()

 

相關參考：Python語言程式設計（上海交通大學出版社 趙璐主編）<<----傳送門