Python學習筆記-資料分析-Numpy02-通用函式
阿新 • • 發佈：2018-12-16
Numpy通用函式
一、陣列形狀— —.T/.reshape()和.resize()**
1、numpy.T ：轉置，例如原shape為(3,4)/(2,3,4)，轉置結果為(4,3)/(4,3,2) → 所以一維陣列轉置後結果不變
# 陣列形狀：.T import numpy as np ar1 = np.arange(1,11) ar2 = np.zeros((2,5)) print(ar1) print(ar2) print('----------上面是原陣列--------------') # 注意：一維陣列在轉置後沒有任何變化。 print(ar1.T) # 二維陣列原來是(2,5)也就是2行5列，轉置後變成5行2列。 print(ar2.T)
執行結果如下：
[ 1 2 3 4 5 6 7 8 9 10]
[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]
----------上面是原陣列--------------
[ 1 2 3 4 5 6 7 8 9 10]
[[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]]
2、numpy.reshape()：為陣列提供新形狀，而不更改其資料，所以元素數量需要一致！
ar3 = np.ones((3,4)) # 注意：在陣列進行形狀變化時，元素的個數一定要保持一致， # 原陣列為一維的有10個元素，現在變成了(2,5)即2行5列，也是10個元素 print(ar1) print(ar1.reshape(2,5)) print('---------------------------------') # 原來的陣列元素是(3,4)也就是3行4列共12個元素，變形後為(6,2)即6行2列共12個元素。 print(ar3) print(ar3.reshape(6,2)) print('---------------------------------') # 可直接在陣列生成的時候改變形狀 print(np.zeros((5,10)).reshape(2,25)) print('---------------------------------') # 可直接在方法內容寫上形狀並生成新的陣列 # 注意：1、引數之間括號不要丟失。2、元素個數要相同。 print(np.reshape(np.arange(16),(4,4)))
執行結果如下：
[ 1 2 3 4 5 6 7 8 9 10] [[ 1 2 3 4 5] [ 6 7 8 9 10]] --------------------------------- [[1. 1. 1. 1.] [1. 1. 1. 1.] [1. 1. 1. 1.]] [[1. 1.] [1. 1.] [1. 1.] [1. 1.] [1. 1.] [1. 1.]] --------------------------------- [[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]] --------------------------------- [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15]]
3、numpy.resize(a, new_shape)：返回具有指定形狀的新陣列，如有必要可重複填充所需數量的元素。
# 生成的陣列只有5個元素，但是resize要12個元素，所以進行了重複填充
ar4 = np.resize(np.arange(5),(3,4))
print(ar4)
print('----------------')
# 生成的陣列有15個元素，但是resize要12個元素，所以將多餘的元素刪除了。
ar5 = np.resize(np.arange(15),(3,4))
print(ar5)
執行結果如下：
[[0 1 2 3]
[4 0 1 2]
[3 4 0 1]]
----------------
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
關於resize的特別說明
s = np.arange(10)
print('這是原陣列：-->','\n',s)
# 如果對陣列s直接用.resize()的話，是不生成陣列的。
#print('這裡沒有生成任何陣列：-->',s.resize(3,4))
# 如果通過np.resize()對s進行操作的話，不僅生成新陣列，而且還修改了原陣列“s”。
print('這裡不僅生成了新的陣列，而且還改變了原陣列',np.resize(s,(3,4)))
# 關於上面這兩句的說明：由於一個是傳址一個傳值，所以放在一個程式碼塊裡直接執行會報錯，故將其中一句註釋掉。
print('-----------------------------')
print('這裡原陣列"s"已經被改變了：-->','\n',s)
執行結果如下：
這是原陣列：-->
[0 1 2 3 4 5 6 7 8 9]
這裡不僅生成了新的陣列，而且還改變了原陣列 [[0 1 2 3]
[4 5 6 7]
[8 9 0 1]]
-----------------------------
這裡原陣列"s"已經被改變了：-->
[0 1 2 3 4 5 6 7 8 9]
二、陣列複製— —直接賦值和copy()
ar6 = np.arange(10)
ar7 = ar6
print(ar7 is ar6)
# 指向記憶體中生成的一個值 → 這裡ar6和ar7指向同一個值，所以ar7改變，ar6一起改變
ar6[2] = 666
print(ar6)
print(ar7)
print('------------------------')
# copy方法生成陣列及其資料的完整拷貝
ar8 = ar6.copy()
print(ar8 is ar6)
ar6[3] = 777
print(ar6,ar8)
# 關於是傳值還是傳址的一些說明
a = np.arange(8)
print('陣列a是這樣的:','\n',a)
# 生成了新的陣列。
print(np.resize(a, (2,5)), type(np.resize(a, (2,5))))
# 沒有生成新的陣列,結果是一個None
print(a.resize(2,4))
執行結果如下：
True
[ 0 1 666 3 4 5 6 7 8 9]
[ 0 1 666 3 4 5 6 7 8 9]
------------------------
False
[ 0 1 666 777 4 5 6 7 8 9] [ 0 1 666 3 4 5 6 7 8 9]
陣列a是這樣的:
[0 1 2 3 4 5 6 7]
[[0 1 2 3 4]
[5 6 7 0 1]] <class 'numpy.ndarray'>
None
三、陣列堆疊— —hstack()、vstack()和stack()
1、hstack()和vstack()
# 陣列堆疊 hstack()：水平（按列順序）堆疊陣列
# a為一維陣列，5個元素
a = np.arange(5)
# b為一維陣列,4個元素
b = np.arange(5,9)
# 對陣列a和b進行水平（按列順序）堆疊陣列
# 注意:((a,b))，這裡形狀可以不一樣
ar1 = np.hstack((a,b))
print('陣列a:', a, a.shape)
print('陣列b:', b, b.shape)
print('陣列ar1：', ar1, ar1.shape)
# a為二維陣列，3行1列
a = np.array([[1],[2],[3]])
# b為二維陣列，3行1列
b = np.array([['a'],['b'],['c']])
# 二維陣列的堆疊
ar2 = np.hstack((a,b))
print('二維陣列a:','\n', a, a.shape)
print('二維陣列b:','\n', b, b.shape)
print('二維陣列ar2:','\n', ar2 ,ar2.shape)
print('----------------------------')
# 陣列堆疊 vstack()：垂直（按列順序）堆疊陣列
a = np.arange(5)
b = np.arange(5,10)
# 對陣列a和b進行垂直（按列順序）堆疊陣列
ar1 = np.vstack((a,b))
print('陣列a:', a, a.shape)
print('陣列b:', b, b.shape)
print('陣列ar1：', ar1, ar1.shape)
a = np.array([[1],[2],[3]])
b = np.array([['a'],['b'],['c'],['d']])
ar2 = np.vstack((a,b)) # 這裡形狀可以不一樣
print('陣列a:','\n', a, a.shape)
print('陣列b:','\n', b, b.shape)
print('陣列ar2:','\n', ar2 ,ar2.shape)
print('----------------------------')
執行結果如下：
陣列a: [0 1 2 3 4] (5,)
陣列b: [5 6 7 8] (4,)
陣列ar1： [0 1 2 3 4 5 6 7 8] (9,)
二維陣列a:
[[1]
[2]
[3]] (3, 1)
二維陣列b:
[['a']
['b']
['c']] (3, 1)
二維陣列ar2:
[['1' 'a']
['2' 'b']
['3' 'c']] (3, 2)
----------------------------
陣列a: [0 1 2 3 4] (5,)
陣列b: [5 6 7 8 9] (5,)
陣列ar1： [[0 1 2 3 4]
[5 6 7 8 9]] (2, 5)
陣列a:
[[1]
[2]
[3]] (3, 1)
陣列b:
[['a']
['b']
['c']
['d']] (4, 1)
陣列ar2:
[['1']
['2']
['3']
['a']
['b']
['c']
['d']] (7, 1)
----------------------------
2、stack()
# a b c分別是3個1維陣列，每個陣列都有5個元素
a = np.arange(1, 7)
b = np.arange(11, 17)
c = np.arange(101, 107)
# 檢視陣列，陣列型別和維度
print(a, '\n', type(a), a.ndim)
print(b, '\n', type(b), b.ndim)
print(c, '\n', type(c), c.ndim)
# 將陣列a、b、c進行堆疊，並增加一個維度。堆疊方式是行。
# 這裡需要注意，axis的引數不是隨便寫的。與陣列中元素的維度有關係，如果元素的維度是1，那麼axis就只能是0和1。
# 當axis=0的時候堆疊方式是以行的形式來進行。即現把陣列a當作第一行，陣列b當作第二行，陣列c當作第三行。
x = np.stack((a,b,c),axis = 0)
print(x,type(x),'\n',x.ndim)
print('_________________________')
# 當axis=1的時候堆疊方式是以列的形式來進行。即現把陣列a當作第一列，陣列b當作第二列，陣列c當作第三列。
y = np.stack((a,b,c),axis = 1)
print(y,type(y),'\n',y.ndim)
print('_________________________')
執行結果如下：
[1 2 3 4 5 6]
<class 'numpy.ndarray'> 1
[11 12 13 14 15 16]
<class 'numpy.ndarray'> 1
[101 102 103 104 105 106]
<class 'numpy.ndarray'> 1
[[ 1 2 3 4 5 6]
[ 11 12 13 14 15 16]
[101 102 103 104 105 106]] <class 'numpy.ndarray'>
2
_________________________
[[ 1 11 101]
[ 2 12 102]
[ 3 13 103]
[ 4 14 104]
[ 5 15 105]
[ 6 16 106]] <class 'numpy.ndarray'>
2
# d e f分別是3個2維陣列，每個陣列都有2個元素，陣列的形狀是2行3列。
d = np.arange(3, 9).reshape((2, 3))
e = np.arange(13, 19).reshape((2, 3))
f = np.arange(103, 109).reshape((2, 3))
# 檢視陣列，陣列型別和維度
print(d, '\n', type(d), d.ndim)
print(e, '\n', type(e), e.ndim)
print(f, '\n', type(f), f.ndim)
# 這裡需要注意，axis的引數不是隨便寫的。與陣列中元素的維度有關係，如果元素的維度是2，那麼axis就只能是0、1、2。
# 當axis=0的時候堆疊方式是以行的形式來進行。即現把陣列a當作第一行，陣列b當作第二行，陣列c當作第三行。
# 注意：下面print語句中的中文說明裡，所寫到的行和列，僅僅是對打印出的圖形而言，不是真正的陣列在空間中的表現。
x = np.stack((d,e,f),axis = 0)
print('當axis=0的時候堆疊方式是以行的形式來進行。即現把陣列d當作第一行，陣列e當作第二行，陣列f當作第三行。')
print(x,type(x),'\n', x.ndim, x.shape)
print('_________________________')
print('當axis=1的時候堆疊方式是以行的方式先拆分元素，然後在按行進行堆疊。可以看出第一個3*3的陣列是由是d,e,f中每個陣列的第一行堆疊而成')
y = np.stack((d,e,f),axis = 1)
print(y,type(y),'\n',y.ndim, y.shape)
print('_________________________')
print('當axis=2的時候堆疊方式是以列的方式先拆分元素，然後在按列進行堆疊。可以看到第一個3*3的陣列是由d,e,f中的第一列向量組合而成')
z = np.stack((d,e,f),axis = 2)
print(z,type(z),'\n',z.ndim, z.shape)
執行結果如下：
[[3 4 5]
[6 7 8]]
<class 'numpy.ndarray'> 2
[[13 14 15]
[16 17 18]]
<class 'numpy.ndarray'> 2
[[103 104 105]
[106 107 108]]
<class 'numpy.ndarray'> 2
當axis=0的時候堆疊方式是以行的形式來進行。即現把陣列d當作第一行，陣列e當作第二行，陣列f當作第三行。
[[[ 3 4 5]
[ 6 7 8]]
[[ 13 14 15]
[ 16 17 18]]
[[103 104 105]
[106 107 108]]] <class 'numpy.ndarray'>
3 (3, 2, 3)
_________________________
當axis=1的時候堆疊方式是以行的方式先拆分元素，然後在按行進行堆疊。可以看出第一個3*3的陣列是由是d,e,f中每個陣列的第一行堆疊而成
[[[ 3 4 5]
[ 13 14 15]
[103 104 105]]
[[ 6 7 8]
[ 16 17 18]
[106 107 108]]] <class 'numpy.ndarray'>
3 (2, 3, 3)
_________________________
當axis=2的時候堆疊方式是以列的方式先拆分元素，然後在按列進行堆疊。可以看到第一個3*3的陣列是由d,e,f中的第一列向量組合而成
[[[ 3 13 103]
[ 4 14 104]
[ 5 15 105]]
[[ 6 16 106]
[ 7 17 107]
[ 8 18 108]]] <class 'numpy.ndarray'>
3 (2, 3, 3)
四、陣列拆分— —hsplit()和vsplit()
# numpy.hsplit()：將陣列水平（逐列）拆分為多個子陣列 → 按列拆分
# 再次強調reshape()的引數一定要和前面生成陣列的個數保持一致。
ar = np.arange(9).reshape(3,3)
# 將陣列ar差分成3個數組
# ar1的輸出結果為列表
ar1 = np.hsplit(ar,3)
print('陣列ar1：','\n',ar1, '\n', '元素的型別：', type(ar1))
print('陣列ar： ', ar)
# 列表中元素為陣列
ar2 = np.hsplit(ar,3)[2]
print('陣列ar中下標為2的元素：','\n',ar2, '\n', '元素的型別：', type(ar2))
print('---------------------------------')
# numpy.vsplit():將陣列垂直（行方向）拆分為多個子陣列 → 按行拆
ar2 = np.vsplit(ar,3)
print(ar2,type(ar2))
執行結果如下：
陣列ar1：
[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]
元素的型別： <class 'list'>
陣列ar： [[0 1 2]
[3 4 5]
[6 7 8]]
陣列ar中下標為2的元素：
[[2]
[5]
[8]]
元素的型別： <class 'numpy.ndarray'>
---------------------------------
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])] <class 'list'>
五、陣列簡單運算
ar = np.arange(6).reshape(2,3)
# 加法
print(ar + 10)
# 乘法
print(ar * 2)
# 除法
print(1 / (ar+1))
# 冪
print(ar ** 0.5)
# 常用函式
# 求平均值
print(ar.mean())
# 求最大值
print(ar.max())
# 求最小值
print(ar.min())
# 求標準差
print(ar.std())
# 求方差
print(ar.var())
# 求和，np.sum() → axis為0，按列求和；axis為1，按行求和
print(ar.sum(), np.sum(ar,axis = 0))
# 排序
print(np.sort(np.array([1,4,3,2,5,6])))
執行結果如下：
[[10 11 12]
[13 14 15]]
[[ 0 2 4]
[ 6 8 10]]
[[1. 0.5 0.33333333]
[0.25 0.2 0.16666667]]
[[0. 1. 1.41421356]
[1.73205081 2. 2.23606798]]
2.5
5
0
1.707825127659933
2.9166666666666665
15 [3 5 7]
[1 2 3 4 5 6]