目錄：1.掌握NumPy數組對象ndaray
1.1 創建數組對象
1.1.1 數組屬性
1.2 生成隨機數
1.3 通過索引訪問數組
1.4 變換數組的形態
1.掌握NumPy數組對象ndaray
1.1 創建數組對象
1.1.1 數組屬性
數組的屬性及其說明
1.1.2數組創建
NumPy提供的array函數可以創建一維或多維數組，基本使用語法如下：
numpy.array(object,dtype=None,copy=True,order='K',subok=False,ndmin=0)
array函數的主要參數及其說明
創建數組並查看數組屬性：
In[1]: import numpy as np #導入NumPy庫
arr1 = np.array([1, 2, 3, 4]) #創建一維數組
print('創建的數組為：','arr1')
Out[1]: 創建的數組為：[1 2 3 4]
In[2]: #創建二維數組
arr2 = np.array([1, 2, 3, 4],[4, 5, 6, 7],[7, 8, 9, 10])
printf('創建的數組為：\n',arr2)
Out[2]: 創建的數組為：
[[ 1 2 3 4]
[ 4 5 6 7]
[ 7 8 9 10]]
In[3]: printf('數組維度為：',arr2.shape) #查看數組結構
Out[3]: 數組維度為： （3, 4）
In[4]: printf('數組類型為：',arr2.dtype) #查看數組類型
Out[4]: 數組類型為：int32
In[5]: printf('數組元素個數為：',arr2.size) #查看數組元素個數
Out[5]: 數組元素個數為：12
In[6]: printf('每組元素大小為：'，arr2.itemsize) #查看數組每個元素的大小
Out[6]: 數組每個元素大小為：4
重新設置數組的shape屬性：
In[7]: arr2.shape = 4,3 #重新設置shape
print('重新設置shape后的arr2為：'，arr2)
Out[7]: 重新設置shape后的arr2為：[[ 1 2 3]
[ 4 4 5]
[ 6 7 7]
[ 8 9 10]]
使用arange函數創建數組（通過指定開始值、終值和步長來創建一維數組，創建的數組不含終值）：
In[8]: print('使用arrange函數創建的數組為：\n',np.arange(0,1,0.1))
Out[8]: 使用arange函數創建的數組為：
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
使用linspace函數創建數組（通過指定開始值、終值和元素個數來創建一維數組，默認設置包括終值）：
In[9]: print('使用lispace函數來創建的數組為：'，np.linspace(0, 1, 12))
Out[9]: 使用lispace函數創建的數組為：[0. 0.09090909 ... 1.]
使用logspace函數創建等比數列（生成1（10^0）~ 100（10^2）的20個元素的等比數列）：
In[10]: print('使用logspace函數創建的數列為：'，np.logspace(0, 2, 20))
Out[10]: 使用logspace函數創建的數列為：[ 1. 1.27427499 1.62377674 ... 61.58482111 78.47599704 100.]
使用zeros函數創建數組（zeros函數用來創建值全部為0的數組，即創建的數組值全部填充為0）：
In[11]: print('使用zeros函數創建的數組為：'，np.zeros((2,3)))
Out[11]: 使用zeros函數創建的數組為：[[ 0. 0. 0.]
[ 0. 0. 0.]]
使用eye函數創建數組（生成主對角線上的元素為1，其他的元素為0的數值，類似單位矩陣）：
In[12]: print('使用eye函數創建的數組為：'，np.eye(3))
Out[12]: 使用eye函數創建的數組為：[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
使用diag函數創建數組（創建類似對角線的數組，即除對角線以外的其他元素都為0，對角線上的元素可以是0或其他值）：
In[13]: print('使用diag函數創建的數組為：',np.diag([1,2,3,4]))
Out[13]: 使用diag函數創建的數組為：[[1 0 0 0]
[0 2 0 0]
[0 0 3 0]
[0 0 0 4]]
使用ones函數創建數組（用來創建元素全部為1的數組，即創建的數組元素全部填充為1）：
In[14]: print('使用ones函數創建的數組為：'，np.ones((5,3)))
Out[14]: 使用ones函數創建的數組為：[[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]]
1.1.3 數組數據類型
NumPy的基本數據類型及其取值范圍
數據類型轉換
In[15]: print('轉換結果為：'，np.float64(42)) #整型轉換為浮點型
Out[15]: 轉換結果為; 42.0
In[16]: print('轉換結果為：',np.int8(42.0)) #浮點型轉換為整型
Out[16]: 轉換結果為： 42
In[17]: print('轉換結果為：',np.bool(42)) #整型轉換為布爾型
Out[17]: 轉換結果為： True
In[18]: print('轉換結果為：',np.bool(0)) #整型轉換為布爾型
Out[18]: 轉換結果為： False
In[19]: print('轉換結果為：',np.float(True)) #布爾型轉換為浮點型
Out[19]: 轉換結果為：1.0
In[20]: print('轉換結果為：',np.float(False)) #布爾型轉換為浮點型
Out[20]: 轉換結果為：0.0
1.2 生成隨機數
random函數是最常見的生成隨機數的方法：
In[25]: print('生成的隨機數組為：',np.random(100))
Out[25]: 生成的隨機數組為：[ 0.15343184 0.51581585 0.07228451 ... 0.24418316 0.92510545 057507965]
rand函數可以生成服從均勻分布的隨機數：
In[26]: print('生成的隨機數組為：\n',np.random.rand(10,5))
Out[26]: 生成的隨機數組為：[[0.39830491 0.94011394 0.59974923 0.44453894 0.65451838]
[0.72715001 0.07239451 0.03326018 0.13753806 0.44939676]
...
[0.75647074 0.03379595 0.39187843 0.58779075 0.91797808]
[0.1468544 0.82972989 0.58011115 0.45157667 0.32422895]]
注：每次運行代碼后生成的隨機數組都不一樣，此處部分結果已經省略
生成服從正態分布的隨機函數：
In[27]: print('生成的隨機數組為：\n',np.random.randn(10,5))
Out[27]: 生成的隨機數組為：
[[-0.60571968 0.39034908 -1.63315513 0.02783885 -1.84139301]
[-0.38700901 0.10433949 -2.62719644 -0.97863269 -1.18774802]
...
[-1.88050937 -0.97885403 -0.51844771 -0.51844771 -0.79439271 -0.83690031]
[-0.27500487 1.41711262 0.6635967 0.35486644 -0.2670073]]
注：每次運行代碼后生成的隨機數組都不一樣，此處部分結果已經省略
randint函數可以生成給定上下限范圍的隨機數，其格式如下：
numpy.random.randint(low,high=None,size=None,dtype='1')
In[28]: print('生成的隨機數組為：',np.random.randint(2,10,size = [2,5]))
Out[28]: 生成的隨機數組為：[[6 6 6 6 8]
[9 6 6 8 4]]
返回值為最小值不低於2、最大值不高於10的2行5列數組。
random模塊的常用隨機數生成函數
1.3 通過索引訪問數組
1.3.1 一維數組的索引
In[29]: arr = np.arange(10)
print('索引結果為：',arr[5]) #用整數作為下標可以獲取數組中的某個元素
Out[29]: 索引結果為: 5
In[30]: #用范圍作為下標獲取數組的一個切片，包括arr[3],不包括arr[5]
print('索引結果為：',arr[3:5])
Out[30]: 索引結果為：[3,4]
In[31]: print('索引結果為：',arr[ :5]) #省略開始下標，表示從arr[0]開始
Out[31]: 索引結果為：[0 1 2 3 4]
In[32]: #下標可以使用負數，-1表示從數組最后往前數的第一個元素
print('索引結果為：',arr[-1])
Out[32]: 索引結果為：9
In[33]: arr[2:4] = 100,101
print('索引結果為：',arr) #下標還可以用來修改元素的值
Out[33]: 索引結果為：[ 0 1 100 101 4 5 6 7 8 9]
In[34]: #范圍中的第三個參數表示步長，2表示隔一個元素取一個元素
print('索引結果為：',arr[1:-1:2])
Out[34]: 索引結果為：[ 1 101 5 7]
In[35]: print('索引結果為：',arr[5:1:-2]) #步長為負數時，開始下標必須大於結束下標
Out[35]: 索引結果為：[ 5 101]
1.3.2 多維數組的索引
In[36]: a = np.arange(24).reshape((2,3,4))
a
Out[36]: 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[37]: a[0,1,2]
Out[37]: 6
In[38]: a[-1,-2,-3]
Out[38]: 17
In[39]: arr = np.array([1,2,3,4,5],[4,5,6,7,8],[7,8,9,10,11])
print('創建的二維數組為：',arr)
Out[39]: 創建的二維數組為：[[ 1 2 3 4 5]
[ 4 5 6 7 8]
[ 7 8 9 10 11]]
In[40]: arr[0,3:5]
Out[40]: [4 ,5]
In[41]: arr[1:,2:]
Out[41]: [ 6, 7, 8]
[ 7 ,10 ,11]
In[42]: arr[:,2]
Out[42]: [3 ,6 ,9]
In[43]: arr[1:,(0,2,3)]
Out[43]: [[ 4, 6, 7]
[ 7 ,9 ,10]]
In[44]: mask = np.array([1,0,1],dtype = np.bool)
print('索引結果為：',arr[mask,2])
Out[44]: 索引結果為：[3,9]
1.4 變換數組的形態
改變數組形狀：
In[45]: arr = np.arange(12)
Out[45]: [ 0 ,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
In[46]: arr.reshape(3,4)
Out[46]: [[ 0, 1, 2, 3]
[ 4, 5, 6, 7]
[ 8, 9, 10, 11]]
In[47]: print('查看數組維度為：',arr.reshape(3,4).ndim) #查看數組維度
Out[47]: 數組維度為：2
使用ravel函數展平數組：
In[48]: arr = np.arange(12).reshape(3,4)
Out[48]: [[ 0, 1, 2, 3]
[ 4, 5, 6, 7]
[ 8, 9, 10, 11]]
In[49]: arr.ravel()
Out[49]: [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
使用flatten函數展平數組：
In[50]: arr.flatten() #橫向展平
Out[50]: [ 0,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
In[51]: arr.flatten('F') #縱向展平
Out[51]: [ 0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11]
使用hstack函數實現橫向組合：
In[52]: arr1 = np.arange(12).reshape(3,4)
Out[52]: [[0,1,2,3]
[4,5,6,7]
[8,9,10,11]]
In[53]: arr2 = arr1*3
Out[53]: [[0,3,6,9]
[12,15,18,21]
[24,27,30,33]]
In[54]: np.hstack(arr1,arr2)
Out[54]: [[0,1,2,3,0,3,6,9]
[4,5,6,7,12,15,18,21]
[8,9,10,11,24,27,30,33]]
使用vstack函數實現縱向組合：
In[55]: np.vstack((arr1,arr2))
Out[55]: [[0,1,2,3]
[4,5,6,7]
[8,9,10,11]
[0,3,6,9]
[12,15,18,21]
[24,27,30,33]]
使用concatenate函數組合數組：
In[56]: np.concatenate((arr1,arr2),axis = 1) #橫向組合
Out[56]: [[0,1,2,3,0,3,6,9]
[4,5,6,7,12,15,18,21]
[8,9,10,11,24,27,30,33]]
In[57]: np.concatenate((arr1,arr2),axis = 0) #縱向組合
Out[57]: [[0,1,2,3]
[4,5,6,7]
[8,9,10,11]
[0,3,6,9]
[12,15,18,21]
[24,27,30,33]]
使用hsplit函數實現數組橫向分割：
In[58]: arr = np.arange(16).reshape(4,4)
Out[58]: [[0,1,2,3]
[4,5,6,7]
[8,9,10,11]
[12,13,14,15]]
In[59]: np.hsplit(arr1,2)
Out[59]: array([[0,1],
[4,5],
[8,9],
[12,13]]),array([[2,3],
[6,7],
[10,11],
[14,15]])
使用vsplit函數實現數組縱向分割：
In[60]: np.vsplit(arr,2)
Out[60]: array([[0,1,2,3],
[4,5,6,7]]),array([[8,9,10,11],
[12,13,14,15]])
使用split函數分割數組：
In[61]: np.split(arr,2,axis = 1) #橫向分割
Out[61]: array([[0,1],
[4,5],
[8,9],
[12,13]]),array([[2,3],
[6,7],
[10,11],
[14,15]])
In[62]: np.split(arr,2,axis = 0)
Out[62]: array([[0,1,2,3],
[4,5,6,7]]),array([[8,9,10,11],
[12,13,14,15]])
由於寫這時沒有軟件,可能會存在格式不規范等問題