numpy

• numpy數組對象
• • 創建數組對象
  • 生成隨機數
  • 通過索引訪問數組
  • 變換數組的形態
• numpy矩陣與通用函數
• • 創建numpy矩陣
  • ufunc函數
• 利用numpy進行統計分析
• • 讀/寫文件
  • 使用函數進行簡單的統計分析
  • 常用的統計函數
  • 鸢尾花長度數據統計分析

numpy數組對象

創建數組對象

1. 數組屬性

屬性說明ndim返回int。表示數組的維度shape返回tuple。表示數組的尺寸，對於n行m列的矩陣，形狀為(n,m)size返回int。表示數組的元素總數，等於數組形狀的乘積dtype返回data-type。描述數組中元素的類型itemsize返回int。表示數組的每個元素的大小（以字節為單位）

2. 數組創建
   numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

參數名稱說明object接收array。表示想要創建的數組。無默認dtype接收data-type。表示數組所需的數據類型。如果未給定，則選擇保存對象所需的最小類型。默認為Nonendmin接收int。指定生成數組應該具有的最小維度。默認為None

3. 數組數據類型

類型描述bool用一位存儲的布爾類型（值為True或False）inti由所在平台決定其精度的整數（一般為int32或int64）int8整數，范圍為-128~127int16整數，范圍為-32768~32767int32整數，范圍為-2³¹~2³²-1int64整數，范圍為-2⁶³~2⁶³-1uint8無符號整數，范圍0~255uint16無符號整數，范圍0~65535uint32無符號整數，范圍0~2³²-1uint64無符號整數，范圍0~2⁶⁴-1float16半精度浮點數（16位），其中用1位表示正負號，用5位表示指數，用10位表示尾數float32單精度浮點數（32位），其中用1位表示正負號，用8位表示指數，用23位表示尾數float64或float單精度浮點數（64位），其中用1位表示正負號，用11位表示指數，用52位表示尾數complex64復數，分別用兩個32位浮點數表示實部和虛部complex128或complex復數，分別用兩個64位浮點數表示實部和虛部

• 實例

import numpy as np
arr1 = np.array([1, 2, 3, 4])
print('創建的數組arr1為：', arr1)
arr2 = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]])
print('創建的數組arr2為：\n', arr2)

創建的數組arr1為： [1 2 3 4]
創建的數組arr2為：
[[ 1 2 3 4]
[ 4 5 6 7]
[ 7 8 9 10]]

print('數組維度為：', arr2.shape)
print('數組類型為：', arr2.dtype)
print('數組元素個數為：', arr2.size)
print('數組每個元素大小為：', arr2.itemsize)

數組維度為： (3, 4)
數組類型為： int32
數組元素個數為： 12
數組每個元素大小為： 4

arr2.shape=4,3
print('重新設置shape後的arr2為：\n', arr2)
# 元素的順序沒改變，只改變了每個軸的大小

重新設置shape後的arr2為：
[[ 1 2 3]
[ 4 4 5]
[ 6 7 7]
[ 8 9 10]]

print('使用arange創建的數組為：\n', np.arange(0, 1, 0.1))
print('使用linspace創建的數組為：\n', np.linspace(0, 1, 12))
# 創建的是等比數列
print('使用logspace創建的數組為：\n', np.logspace(0, 2, 20))
# 全部數組為0
print('使用zeros創建的數組為：\n', np.zeros((2, 3)))
# 主對角線全為1
print('使用eye創建的數組為：\n', np.eye(3))
# 主對角線上的元素
print('使用diag創建的數組為：\n', np.diag([1,2,3,4]))
# 全部數組全為1
print('使用ones創建的數組為：\n', np.ones((5,3)))

使用arange創建的數組為：
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
使用linspace創建的數組為：
[0. 0.09090909 0.18181818 0.27272727 0.36363636 0.45454545
0.54545455 0.63636364 0.72727273 0.81818182 0.90909091 1. ]
使用logspace創建的數組為：
[ 1. 1.27427499 1.62377674 2.06913808 2.6366509
3.35981829 4.2813324 5.45559478 6.95192796 8.8586679
11.28837892 14.38449888 18.32980711 23.35721469 29.76351442
37.92690191 48.32930239 61.58482111 78.47599704 100. ]
使用zeros創建的數組為：
[[0. 0. 0.]
[0. 0. 0.]]
使用eye創建的數組為：
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
使用diag創建的數組為：
[[1 0 0 0]
[0 2 0 0]
[0 0 3 0]
[0 0 0 4]]
使用ones創建的數組為：
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]

# 數組類型轉換
print('整型轉化為浮點型，轉換結果為：', np.float64(42))
print('浮點型轉化為整型，轉換結果為：', np.int8(42.0))
print('整型轉化為布爾型，轉換結果為：', np.bool(42))
print('整型轉化為布爾型，轉換結果為：', np.float64(0))
print('布爾型轉化為浮點型，轉換結果為：', np.float(True))
print('布爾型轉化為浮點型，轉換結果為：', np.float(False))

整型轉化為浮點型，轉換結果為： 42.0
浮點型轉化為整型，轉換結果為： 42
整型轉化為布爾型，轉換結果為： True
整型轉化為布爾型，轉換結果為： 0.0
布爾型轉化為浮點型，轉換結果為： 1.0
布爾型轉化為浮點型，轉換結果為： 0.0

# 創建數據類型
df=np.dtype([("name",np.str_,40),("numitems",np.int64),("price",np.float64)])
print('數據類型為：', df)

數據類型為： [('name', '<U40'), ('numitems', '<i8'), ('price', '<f8')]

# 查看數據類型
print('數據類型為：', df["name"])
print('數據類型為：', np.dtype(df["name"]))
# 自定義數組數據
itemz=np.array([("tomatoes",42,4.14),("cabbages",13,1.72)],dtype=df)
print('自定義數據為：',itemz)

數據類型為： <U40
數據類型為： <U40
自定義數據為： [('tomatoes', 42, 4.14) ('cabbages', 13, 1.72)]

生成隨機數

random模塊常用隨機數生成函數

函數說明seed確定隨機數生成器的種子permutaion返回一個序列的隨機排列或返回一個隨機排列的范圍shuffle對一個序列進行隨機排列binomial產生二項分布的隨機數normal產生正態分布的隨機數beta產生beta分布的隨機數chisquare產生卡方分布的隨機數gamma產生gamma分布的隨機數uniform產生在[0,1]中均勻分布的隨機數

print('生成的隨機數組為：',np.random.random(10))
print('生成均勻分布的隨機數組為：\n',np.random.rand(2,3))
print('生成服從正態分布的隨機數組為：\n',np.random.randn(2,3))
print('生成給定上下限的隨機數組為：\n',np.random.randint(2,10,size=[2,5]))

生成的隨機數組為： [0.05478456 0.31793173 0.63195643 0.96141967 0.00333223 0.72768221
0.30489522 0.90413895 0.15791078 0.99559445]
生成均勻分布的隨機數組為：
[[0.66725553 0.44391885 0.95413037]
[0.77064322 0.53726875 0.26902613]]
生成服從正態分布的隨機數組為：
[[ 0.95840647 -0.51848368 0.68529844]
[-0.61515571 0.37733786 0.43860996]]
生成給定上下限的隨機數組為：
[[5 5 7 9 4]
[2 3 5 9 4]]

通過索引訪問數組

1. 一維數組的索引–與list索引方法一致

arr=np.arange(10)
print('整數作索引，索引結果為：',arr[5])
print('范圍作索引，不包括arr[5]，索引結果為：',arr[3:5])
print('省略開始索引作索引，索引結果為：',arr[:5])
print('負數作索引，索引結果為：',arr[-1])
arr[2:4]=100,101
print('下標用來修改元素，數組結果為：',arr)
print('步長作索引，索引結果為：',arr[1:-1:2])
print('步長負數作索引，開始下標必需大於結束下標，索引結果為：',arr[5:1:-2])

整數作索引，索引結果為： 5
范圍作索引，不包括arr[5]，索引結果為： [3 4]
省略開始索引作索引，索引結果為： [0 1 2 3 4]
負數作索引，索引結果為： 9
下標用來修改元素，數組結果為： [ 0 1 100 101 4 5 6 7 8 9]
步長作索引，索引結果為： [ 1 101 5 7]
步長負數作索引，開始下標必需大於結束下標，索引結果為： [ 5 101]

2. 多維數組的索引–每一個維度都有一個索引，各個維度的索引之間用逗號隔開

arr=np.array([[1,2,3,4,5],[4,5,6,7,8],[7,8,9,10,11]])
print('創建的二維數組為：\n',arr)
print('索引第0行中第3列和4列的元素，索引結果為：\n',arr[0,3:5])
print('索引第2和3行中第3~5列的元素，索引結果為：\n',arr[1:,2:])
print('索引第2列的元素，索引結果為：',arr[:,2])
print('從兩個序列的對應位置取出兩個整數來組成下標，索引結果為：',arr[[(0,1,2),(1,2,3)]])
print('索引第2、3行中第0、2、3列的元素，索引結果為：\n',arr[1:,(0,2,3)])
mask=np.array([1,0,1],dtype=np.bool)
print('mask是一個布爾數組，索引第1、3行中第2列的元素，索引結果為：',arr[mask,2])

創建的二維數組為：
[[ 1 2 3 4 5]
[ 4 5 6 7 8]
[ 7 8 9 10 11]]
索引第0行中第3列和4列的元素，索引結果為：
[4 5]
索引第2和3行中第3~5列的元素，索引結果為：
[[ 6 7 8]
[ 9 10 11]]
索引第2列的元素，索引結果為： [3 6 9]
從兩個序列的對應位置取出兩個整數來組成下標，索引結果為： [ 2 6 10]
索引第2、3行中第0、2、3列的元素，索引結果為：
[[ 4 6 7]
[ 7 9 10]]
mask是一個布爾數組，索引第1、3行中第2列的元素，索引結果為： [3 9]

變換數組的形態

• 改變數組形狀實例

arr=np.arange(12)
print('創建的一維數組為：\n',arr)
print('新的一維數組為：\n',arr.reshape(3,4))
print('新的一維數組為：',arr.reshape(3,4).ndim)

創建的一維數組為：
[ 0 1 2 3 4 5 6 7 8 9 10 11]
新的一維數組為：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
新的一維數組為： 2

• 展平數組實例

# 使用ravel函數展平數組
arr=np.arange(12).reshape(3,4)
print('創建的二維數組為：\n',arr)
print('ravel函數數組展平後：',arr.ravel())

創建的二維數組為：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
ravel函數數組展平後： [ 0 1 2 3 4 5 6 7 8 9 10 11]

# 使用flatten函數展平數組
print('flatten函數數組橫向展平為：',arr.flatten())
print('flatten函數數組縱向展平為：',arr.flatten('F'))

flatten函數數組橫向展平為： [ 0 1 2 3 4 5 6 7 8 9 10 11]
flatten函數數組縱向展平為： [ 0 4 8 1 5 9 2 6 10 3 7 11]

• 組合數組實例

# 使用hstack函數數組橫向組合
arr1 = np.arange(12).reshape(3,4)
print('創建的數組1為：\n',arr1)
arr2=arr1*3
print('創建的數組2為：\n',arr2)
print('hstack函數橫向組合數組：\n',np.hstack((arr1,arr2)))

創建的數組1為：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
創建的數組2為：
[[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]
橫向組合：
[[ 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函數數組縱向組合
print('vstack函數縱向組合數組：\n',np.vstack((arr1,arr2)))

vstack縱向組合：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]

print('concatenate函數橫向組合數組：\n',np.concatenate((arr1,arr2),axis=1))
print('concatenate函數縱向組合數組：\n',np.concatenate((arr1,arr2),axis=0))

concatenate函數橫向組合數組：
[[ 0 1 2 3 0 3 6 9]
[ 4 5 6 7 12 15 18 21]
[ 8 9 10 11 24 27 30 33]]
concatenate函數縱向組合數組：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]

• 分割數組實例

arr=np.arange(16).reshape(4,4)
print('創建的二維數組為：',arr)
print('hsplit函數橫向分割數組：\n',np.hsplit(arr,2))
print('vsplit函數縱向分割數組：\n',np.vsplit(arr,2))

創建的二維數組為： [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
hsplit函數橫向分割數組：
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
vsplit函數縱向分割數組：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]

print('split函數橫向分割數組：\n',np.split(arr,2,axis=1))
print('split函數縱向分割數組：\n',np.split(arr,2,axis=0))

split函數橫向分割數組：
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
split函數縱向分割數組：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]

numpy矩陣與通用函數

創建numpy矩陣

矩陣特有屬性及說明

屬性說明T返回自身的轉置H返回自身的共轭轉置I返回自身的逆矩陣A返回自身數據的二維數組的一個視圖

• 創建矩陣實例

# 使用mat函數與matrix函數創建矩陣
import numpy as pd
matr1=np.mat("1 2 3;4 5 6;7 8 9")
print('mat創建的矩陣為：\n',matr1)
matr2=np.mat([[1,2,3],[4,5,6],[7,8,9]])
print('matrix創建的矩陣為：\n',matr2)

mat創建的矩陣為：
[[1 2 3]
[4 5 6]
[7 8 9]]
matrix創建的矩陣為：
[[1 2 3]
[4 5 6]
[7 8 9]]

arr1=np.eye(3)
print('創建的數組1為：\n',arr1)
arr2=3*arr1
print('創建的數組2為：\n',arr2)
print('bmat創建的矩陣為：\n',np.bmat("arr1 arr2;arr1 arr2"))

創建的數組1為：
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
創建的數組2為：
[[3. 0. 0.]
[0. 3. 0.]
[0. 0. 3.]]
bmat創建的矩陣為：
[[1. 0. 0. 3. 0. 0.]
[0. 1. 0. 0. 3. 0.]
[0. 0. 1. 0. 0. 3.]
[1. 0. 0. 3. 0. 0.]
[0. 1. 0. 0. 3. 0.]
[0. 0. 1. 0. 0. 3.]]

• 矩陣運算實例

# 矩陣運算
matr1=np.mat("1 2 3;4 5 6;7 8 9")
print('創建的矩陣為：\n',matr1)
matr2=matr1*3
print('創建的矩陣為：\n',matr2)
print('矩陣相加的結果為：\n',matr1+matr2)
print('矩陣相減的結果為：\n',matr1-matr2)
print('矩陣相乘的結果為：\n',matr1*matr2)
print('矩陣對應元素相乘的結果為：\n',np.multiply(matr1,matr2))

創建的矩陣為：
[[1 2 3]
[4 5 6]
[7 8 9]]
創建的矩陣為：
[[ 3 6 9]
[12 15 18]
[21 24 27]]
矩陣相加的結果為：
[[ 4 8 12]
[16 20 24]
[28 32 36]]
矩陣相減的結果為：
[[ -2 -4 -6]
[ -8 -10 -12]
[-14 -16 -18]]
矩陣相乘的結果為：
[[ 90 108 126]
[198 243 288]
[306 378 450]]
矩陣對應元素相乘的結果為：
[[ 3 12 27]
[ 48 75 108]
[147 192 243]]

# 查看矩陣屬性
print('矩陣轉置結果為：\n',matr1.T)
print('矩陣共轭轉置結果為：\n',matr1.H)
try:
print(matr1.I)
except:
print("奇異矩陣，逆矩陣不存在！")
print('矩陣的二維數組結果為（返回矩陣視圖）：\n',matr1.A)

矩陣轉置結果為：
[[1 4 7]
[2 5 8]
[3 6 9]]
矩陣共轭轉置結果為：
[[1 4 7]
[2 5 8]
[3 6 9]]
奇異矩陣，逆矩陣不存在！
矩陣的二維數組結果為（返回矩陣視圖）：
[[1 2 3]
[4 5 6]
[7 8 9]]

ufunc函數

ufunc函數：通用函數，能夠對數組中的所有元素進行操作的函數，針對數組進行操作；當對一個數組進行重復運算時，使用ufunc函數比使用math庫中的函數效率要高得多。

• 常用ufunc函數：四則運算、比較運算和邏輯運算。
• ufunc函數的廣播機制

# 一維數組的廣播機制
arr1=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print('創建的數組1為：\n',arr1)
print('數組1的shape為：\n',arr1.shape)
arr2=np.array([1,2,3])
print('創建的數組2為：\n',arr2)
print('數組2的shape為：\n',arr2.shape)
print('數組相加的結果為：\n',arr1+arr2)

創建的數組1為：
[[0 0 0]
[1 1 1]
[2 2 2]
[3 3 3]]
數組1的shape為：
(4, 3)
創建的數組2為：
[1 2 3]
數組2的shape為：
(3,)
數組相加的結果為：
[[1 2 3]
[2 3 4]
[3 4 5]
[4 5 6]]

# 二維數組的廣播機制
arr1=np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
print('創建的數組1為：\n',arr1)
print('數組1的shape為：\n',arr1.shape)
arr2=np.array([1,2,3,4]).reshape((4,1))
print('創建的數組2為：\n',arr2)
print('數組2的shape為：\n',arr2.shape)
print('數組相加的結果為：\n',arr1+arr2)

創建的數組1為：
[[0 0 0]
[1 1 1]
[2 2 2]
[3 3 3]]
數組1的shape為：
(4, 3)
創建的數組2為：
[[1]
[2]
[3]
[4]]
數組2的shape為：
(4, 1)
數組相加的結果為：
[[1 1 1]
[3 3 3]
[5 5 5]
[7 7 7]]

利用numpy進行統計分析

讀/寫文件

1. save以二進制的格式保存數據，load函數從二進制的文件中讀取數據。
   np.save(file,arr,allow_pickle=True,fix_imports=True)

• 實例

# 二進制存儲
import numpy as np
arr=np.arange(100).reshape(10,10)
np.save("./save_arr",arr)
print('保存的數組為：\n',arr)

保存的數組為：
[[ 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 27 28 29]
[30 31 32 33 34 35 36 37 38 39]
[40 41 42 43 44 45 46 47 48 49]
[50 51 52 53 54 55 56 57 58 59]
[60 61 62 63 64 65 66 67 68 69]
[70 71 72 73 74 75 76 77 78 79]
[80 81 82 83 84 85 86 87 88 89]
[90 91 92 93 94 95 96 97 98 99]]

# 多個數組存儲
arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.arange(0,1.0,0.1)
np.savez('./savez_arr',arr1,arr2)
print('保存的數組1為：\n',arr1)
print('保存的數組2為：',arr2)

保存的數組1為：
[[1 2 3]
[4 5 6]]
保存的數組2為： [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

# 二進制文件讀取
loaded_data = np.load("./save_arr.npy")
print('讀取的數組為：\n',loaded_data)

讀取的數組為：
[[ 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 27 28 29]
[30 31 32 33 34 35 36 37 38 39]
[40 41 42 43 44 45 46 47 48 49]
[50 51 52 53 54 55 56 57 58 59]
[60 61 62 63 64 65 66 67 68 69]
[70 71 72 73 74 75 76 77 78 79]
[80 81 82 83 84 85 86 87 88 89]
[90 91 92 93 94 95 96 97 98 99]]

# 讀取含有多個數組的文件
loaded_data1=np.load('./savez_arr.npz')
print('讀取的數組1為：\n',loaded_data1['arr_0'])
print('讀取的數組2為：\n',loaded_data1['arr_1'])

2. savetxt函數將數組寫道以某種分隔符隔開的文本文件中。
   np.savetxt(fname,X,fmt='%.18e',delimiter=' ',newline='\n',header='',footer='',comments='# '
   第一個參數時文件名fname，第二個參數X為數組數據，第四個參數為數據分隔符felimiter。
   loadtxt函數執行的數相反的操作，即把文件加載到一個二維數組中。

讀取的數組1為：
[[1 2 3]
[4 5 6]]
讀取的數組2為：
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

arr=np.arange(0,12,0.5).reshape(4,-1)
print('創建的數組為：',arr)

創建的數組為： [[ 0. 0.5 1. 1.5 2. 2.5]
[ 3. 3.5 4. 4.5 5. 5.5]
[ 6. 6.5 7. 7.5 8. 8.5]
[ 9. 9.5 10. 10.5 11. 11.5]]

# fmt ="%d"表示保存為整數
np.savetxt("./arr.txt",arr,fmt="%d",delimiter=",")
# 讀入的時候也需要指定逗號分割
loaded_data=np.loadtxt("./arr.txt",delimiter=",")
print("讀取的數組為：",loaded_data)

讀取的數組為： [[ 0. 0. 1. 1. 2. 2.]
[ 3. 3. 4. 4. 5. 5.]
[ 6. 6. 7. 7. 8. 8.]
[ 9. 9. 10. 10. 11. 11.]]

# 使用genfromtxt函數讀取數組
loaded_data=np.genfromtxt("./arr.txt",delimiter=",")
print('讀取的數組為：',loaded_data)

讀取的數組為： [[ 0. 0. 1. 1. 2. 2.]
[ 3. 3. 4. 4. 5. 5.]
[ 6. 6. 7. 7. 8. 8.]
[ 9. 9. 10. 10. 11. 11.]]

使用函數進行簡單的統計分析

1. 排序–sort、argsort、lexsort

• sort實例

np.random.seed(42)
arr=np.random.randint(1,10,size=10)
print('創建的數組為：',arr)
# 直接排序
arr.sort()
print('排序後數組為：',arr)
arr=np.random.randint(1,10,size=(3,3))
print('創建的數組為：\n',arr)
arr.sort(axis=1)
print('沿著橫軸排序後數組為：\n',arr)
arr.sort(axis=0)
print('沿著縱軸排序後數組為：\n',arr)

創建的數組為： [7 4 8 5 7 3 7 8 5 4]
排序後數組為： [3 4 4 5 5 7 7 7 8 8]
創建的數組為：
[[8 8 3]
[6 5 2]
[8 6 2]]
沿著橫軸排序後數組為：
[[3 8 8]
[2 5 6]
[2 6 8]]
沿著縱軸排序後數組為：
[[2 5 6]
[2 6 8]
[3 8 8]]

• argsort實例

arr=np.array([2,3,6,8,0,7])
print('創建的數組為：',arr)
print('排序後數組為：',arr.argsort())
# 返回值為重新排序值的下標

創建的數組為： [2 3 6 8 0 7]
排序後數組為： [4 0 1 2 5 3]

• lexsort實例

a=np.array([3,2,6,4,5])
b=np.array([50,30,40,20,10])
c=np.array([400,300,600,100,200])
# lexsort只接收一個參數，即abc
# 多個鍵值排序時是按照最後一個傳入數據計算的
d=np.lexsort((a,b,c))
print('排序後的數組為：',list(zip(a[d],b[d],c[d])))

排序後的數組為： [(4, 20, 100), (5, 10, 200), (2, 30, 300), (3, 50, 400), (6, 40, 600)]

2. 去重與重復數據

• unique去重實例

names=np.array(['小明','小花','小黃','小明','小花','小蘭','小白'])
print('創建的數組names為：',names)
print('去重後數組names為：',np.unique(names))
# 跟unique等價的python代碼實現過程
print('python代碼去重後的數組為：',sorted(set(names)))
ints=np.array([1,2,3,4,4,5,6,6,7,7,7,8,9,10])
print('創建的數組ints為：',ints)
print('去重後數組ints為：',np.unique(ints))

創建的數組names為： ['小明' '小花' '小黃' '小明' '小花' '小蘭' '小白']
去重後數組names為： ['小蘭' '小明' '小白' '小花' '小黃']
python代碼去重後的數組為： ['小蘭', '小明', '小白', '小花', '小黃']
創建的數組ints為： [ 1 2 3 4 4 5 6 6 7 7 7 8 9 10]
去重後數組ints為： [ 1 2 3 4 5 6 7 8 9 10]

• tile函數實現數據重復

arr=np.arange(5)
print('創建的數組為：',arr)
print('重復後數組為：',np.tile(arr,3))

創建的數組為： [0 1 2 3 4]
重復後數組為： [0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]

• repeat函數實現數據重復

np.random.seed(42)
arr=np.random.randint(0,10,size=(3,3))
print('創建的數組為：',arr)
print('按行進行元素重復，重復後數組為：\n',arr.repeat(2,axis=0))
print('按列進行元素重復，重復後數組為：\n',arr.repeat(2,axis=1))

創建的數組為： [[6 3 7]
[4 6 9]
[2 6 7]]
按行進行元素重復，重復後數組為：
[[6 3 7]
[6 3 7]
[4 6 9]
[4 6 9]
[2 6 7]
[2 6 7]]
按列進行元素重復，重復後數組為：
[[6 6 3 3 7 7]
[4 4 6 6 9 9]
[2 2 6 6 7 7]]

常用的統計函數

arr=np.arange(20).reshape(4,5)
print('創建的數組為：\n',arr)
print('數組的和為：',np.sum(arr))
print('縱軸數組的和為：',arr.sum(axis=0))
print('橫軸數組的和為：',arr.sum(axis=1))
print('數組的均值為：',np.mean(arr))
print('縱軸數組的均值為：',arr.mean(axis=0))
print('橫軸數組的均值為：',arr.mean(axis=1))
print('數組的標准差為：',np.std(arr))
print('數組的方差為：',np.var(arr))
print('數組的最小值為：',np.min(arr))
print('數組的最大值為：',np.max(arr))
print('數組的最小元素索引為：',np.argmin(arr))
print('數組的最大元素索引為：',np.argmax(arr))

創建的數組為：
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
數組的和為： 190
縱軸數組的和為： [30 34 38 42 46]
橫軸數組的和為： [10 35 60 85]
數組的均值為： 9.5
縱軸數組的均值為： [ 7.5 8.5 9.5 10.5 11.5]
橫軸數組的均值為： [ 2. 7. 12. 17.]
數組的標准差為： 5.766281297335398
數組的方差為： 33.25
數組的最小值為： 0
數組的最大值為： 19
數組的最小元素索引為： 0
數組的最大元素索引為： 19

# cumsum和cumprod函數的使用
arr=np.arange(2,10)
print('創建的數組為：',arr)
print('數組元素的累計和為：',np.cumsum(arr))
print('數組元素的累計積為：',np.cumprod(arr))

創建的數組為： [2 3 4 5 6 7 8 9]
數組元素的累計和為： [ 2 5 9 14 20 27 35 44]
數組元素的累計積為： [ 2 6 24 120 720 5040 40320 362880]

鸢尾花長度數據統計分析

# 鸢尾花統計分析
iris_sepal_length=np.loadtxt('E:/anaconda/data/iris_sepal_length.csv',delimiter=',')
print('花萼長度表為：',iris_sepal_length)
iris_sepal_length.sort()
print('排序後的花萼長度表為：',iris_sepal_length)

花萼長度表為： [5.1 4.9 4.7 4.6 5. 5.4 4.6 5. 4.4 4.9 5.4 4.8 4.8 4.3 5.8 5.7 5.4 5.1
5.7 5.1 5.4 5.1 4.6 5.1 4.8 5. 5. 5.2 5.2 4.7 4.8 5.4 5.2 5.5 4.9 5.
5.5 4.9 4.4 5.1 5. 4.5 4.4 5. 5.1 4.8 5.1 4.6 5.3 5. 7. 6.4 6.9 5.5
6.5 5.7 6.3 4.9 6.6 5.2 5. 5.9 6. 6.1 5.6 6.7 5.6 5.8 6.2 5.6 5.9 6.1
6.3 6.1 6.4 6.6 6.8 6.7 6. 5.7 5.5 5.5 5.8 6. 5.4 6. 6.7 6.3 5.6 5.5
5.5 6.1 5.8 5. 5.6 5.7 5.7 6.2 5.1 5.7 6.3 5.8 7.1 6.3 6.5 7.6 4.9 7.3
6.7 7.2 6.5 6.4 6.8 5.7 5.8 6.4 6.5 7.7 7.7 6. 6.9 5.6 7.7 6.3 6.7 7.2
6.2 6.1 6.4 7.2 7.4 7.9 6.4 6.3 6.1 7.7 6.3 6.4 6. 6.9 6.7 6.9 5.8 6.8
6.7 6.7 6.3 6.5 6.2 5.9]
排序後的花萼長度表為： [4.3 4.4 4.4 4.4 4.5 4.6 4.6 4.6 4.6 4.7 4.7 4.8 4.8 4.8 4.8 4.8 4.9 4.9
4.9 4.9 4.9 4.9 5. 5. 5. 5. 5. 5. 5. 5. 5. 5. 5.1 5.1 5.1 5.1
5.1 5.1 5.1 5.1 5.1 5.2 5.2 5.2 5.2 5.3 5.4 5.4 5.4 5.4 5.4 5.4 5.5 5.5
5.5 5.5 5.5 5.5 5.5 5.6 5.6 5.6 5.6 5.6 5.6 5.7 5.7 5.7 5.7 5.7 5.7 5.7
5.7 5.8 5.8 5.8 5.8 5.8 5.8 5.8 5.9 5.9 5.9 6. 6. 6. 6. 6. 6. 6.1
6.1 6.1 6.1 6.1 6.1 6.2 6.2 6.2 6.2 6.3 6.3 6.3 6.3 6.3 6.3 6.3 6.3 6.3
6.4 6.4 6.4 6.4 6.4 6.4 6.4 6.5 6.5 6.5 6.5 6.5 6.6 6.6 6.7 6.7 6.7 6.7
6.7 6.7 6.7 6.7 6.8 6.8 6.8 6.9 6.9 6.9 6.9 7. 7.1 7.2 7.2 7.2 7.3 7.4
7.6 7.7 7.7 7.7 7.7 7.9]

print('去重後的花萼長度表為：',np.unique(iris_sepal_length))
print('花萼長度表總和為：',np.sum(iris_sepal_length))
print('花萼長度表的累計和為：',np.cumsum(iris_sepal_length))
print('花萼長度表的均值為：',np.mean(iris_sepal_length))
print('花萼長度表的標准差為：',np.std(iris_sepal_length))
print('花萼長度表的方差為：',np.var(iris_sepal_length))
print('花萼長度表的最小值為：',np.min(iris_sepal_length))
print('花萼長度表的最大值為：',np.max(iris_sepal_length))

去重後的花萼長度表為： [4.3 4.4 4.5 4.6 4.7 4.8 4.9 5. 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 5.9 6.
6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 7. 7.1 7.2 7.3 7.4 7.6 7.7 7.9]
花萼長度表總和為： 876.5
花萼長度表的累計和為： [ 4.3 8.7 13.1 17.5 22. 26.6 31.2 35.8 40.4 45.1 49.8 54.6
59.4 64.2 69. 73.8 78.7 83.6 88.5 93.4 98.3 103.2 108.2 113.2
118.2 123.2 128.2 133.2 138.2 143.2 148.2 153.2 158.3 163.4 168.5 173.6
178.7 183.8 188.9 194. 199.1 204.3 209.5 214.7 219.9 225.2 230.6 236.
241.4 246.8 252.2 257.6 263.1 268.6 274.1 279.6 285.1 290.6 296.1 301.7
307.3 312.9 318.5 324.1 329.7 335.4 341.1 346.8 352.5 358.2 363.9 369.6
375.3 381.1 386.9 392.7 398.5 404.3 410.1 415.9 421.8 427.7 433.6 439.6
445.6 451.6 457.6 463.6 469.6 475.7 481.8 487.9 494. 500.1 506.2 512.4
518.6 524.8 531. 537.3 543.6 549.9 556.2 562.5 568.8 575.1 581.4 587.7
594.1 600.5 606.9 613.3 619.7 626.1 632.5 639. 645.5 652. 658.5 665.
671.6 678.2 684.9 691.6 698.3 705. 711.7 718.4 725.1 731.8 738.6 745.4
752.2 759.1 766. 772.9 779.8 786.8 793.9 801.1 808.3 815.5 822.8 830.2
837.8 845.5 853.2 860.9 868.6 876.5]
花萼長度表的均值為： 5.843333333333334
花萼長度表的標准差為： 0.8253012917851409
花萼長度表的方差為： 0.6811222222222223
花萼長度表的最小值為： 4.3
花萼長度表的最大值為： 7.9