機器學習基礎 --- numpy的基本使用

1、numpy的簡介

　　numpy是Python的一種開源的數值計算擴展庫。這種工具可用來存儲和處理大型矩陣，比Python自身的嵌套列表（nested list structure)結構要高效的多（該結構也能夠用來表示矩陣（matrix））。

　　NumPy（Numeric Python）提供了許多高級的數值編程工具，如：矩陣數據類型、矢量處理，以及精密的運算庫。專爲進行嚴格的數字處理而產生。

　　Numpy中包含了大量的矩陣運算，因此讀者最好具備一點兒線性代數的基礎。

2、numpy基本使用

1. 導入numpy庫並使用numpy的array方法配合Python中的list生成矩陣

import numpy as np

vetor = np.array([1,2,3,4])     # 一維
matrix = np.array([
    [1,1,1],
    [2,2,2],
    [3,3,3]
])   # 二維
print(vetor)
print(matrix)

　　輸出：

[1 2 3 4]
[[1 1 1]
 [2 2 2]
 [3 3 3]]

 

2. 獲取矩陣的組成

print(vetor.shape)
print(matrix.shape)

　　輸出：

(4,)
(3, 3)

 

3. 數據類型

numbers = np.array([1,3,5,7])   # 全爲int型
print(numbers)
numbers.dtype

　　輸出：

[1 3 5 7]
dtype('int64')

numbers = np.array([1,3,5,7.0])  # 有一個爲float型，全爲float型
print(numbers)
numbers.dtype

示例2

[1. 3. 5. 7.]
dtype('float64')

輸出2

numbers = np.array([1,3,5,'7'])  # 有一個爲字符串，全爲字符串
print(numbers)
numbers.dtype

示例3

['1' '3' '5' '7']
dtype('<U21')

輸出3

 

4. 操做矩陣的某個值，某些值

vetor = np.array([1,2,3,4])
matrix = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(vetor[2])    # 打印vetor的第2個元素
print(vetor[:3])   # 打印vetor的第0到第二個（不包括第三個）元素
print(matrix[2,2]) # 打印matrix第2行，第2列的元素
print(matrix[:, 1]) # 打印每一行的第1列元素

　　輸出：

3
[1 2 3]
9
[2 5 8]

 

5. 迭代判斷矩陣中的全部值是否等於某個值

import numpy as np
vector = np.array([1,3,5,7])
vector == 5

　　輸出：

array([False, False,  True, False])

matrix = np.array([
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9]
])
matrix == 5

示例2

array([[False, False, False],
       [False,  True, False],
       [False, False, False]])

輸出2

vector = np.array([1,3,4,5,7])
equal_three_and_five = (vector == 3) & (vector == 5)  # 迭代判斷vector中的全部值是否即等於3又等於5
print(equal_three_and_five)

示例3

[False False False False False]

輸出3

vector = np.array([1,3,4,5,7])
equal_three_or_five = (vector == 3) | (vector == 5) # 迭代判斷vector中的全部值是否即等於3或者等於5
print(equal_three_or_five)

示例4

[False  True False  True False]

輸出4

matrix = np.array([
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9]
])
equal_ten = (matrix == 5)   # 比較的結果可視爲一個索引
print(equal_ten)
print(matrix[equal_ten])

進階使用1

[[False False False]
 [False  True False]
 [False False False]]
[5]

進階輸出1

matrix = np.array([
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9]
])
equal_ten = (matrix[:, 1] == 5)   # 迭代判斷matrix的第1列的值是否等於5
print(equal_ten)
print(matrix[equal_ten, :])     

進階使用2

[False  True False]
[[2 5 8]]

進階輸出2

vector = np.array([1,3,4,5,7])
equal_three_or_five = (vector == 3) | (vector == 5) # 迭代判斷vector中的全部值是否即等於3或者等於5
vector[equal_three_or_five] = 10    # 將等於3或者等於5的值替換成10
print(vector)

進階使用3

[ 1 10  4 10  7]

進階輸出3

 

6.類型轉換

vector = np.array(['1', '3', '5', '7'])
print(vector.dtype)
print(vector)
vector = vector.astype(int)   #使用astype方法作類型轉換
print(vector.dtype)
print(vector)

　　輸出：

<U1
['1' '3' '5' '7']
int64
[1 3 5 7]

 

7.常規計算

vector = np.array([1,3,4,5,7])
print(vector.min())     #求最大值
print(vector.max())    #求最小組

　　輸出：

1
7

# 示例2
matrix = np.array([
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9]
])
print(matrix.min(axis=1))   # 按行求最小值，axis=1表示按行
print(matrix.max(axis=0))   # 按列求最大值，axis=0表示按列
print(matrix.max())    # 全部值求最大值

# 輸出2
[1 2 3]
[3 6 9]
9

# 示例3
matrix = np.array([
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9]
])
print(matrix.sum(axis=1))   # 按行求和
print(matrix.sum(axis=0))   # 按列求和
print(matrix.sum())    # 全部值求和

# 輸出3
[12 15 18]
[ 6 15 24]
45

  

8.生成初始矩陣

# 示例1
print(np.arange(15))   # 取0到14組成一個一維矩陣
a = np.arange(15).reshape(3,5)    # 取0到14組成一個3行5列的2維矩陣
print(a)

# 輸出1
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]

# 示例2
a.ndim     # 獲取a的維度
a.dtype.name   #獲取a中數據的類型
a.size     # a中數據的數量

# 示例3
b = np.zeros((3, 4))    # 一個3行4列的矩陣， 由0構成
print(b)

# 輸出3
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

# 示例4
c = np.ones((2,3,4), dtype=np.int32)   # 3維矩陣，2組3行4列的2維矩陣，由1構成
print(c)

# 輸出4
[[[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]

 [[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]]

# 示例5
d = np.arange(10, 30, 5)  #初值爲10，增量爲5，最大不超過30，構成一維矩陣，numpy中arange的用法幾乎和Python中的range同樣
print(d)

# 輸出5
[10 15 20 25]

# 示例6
e = np.random.random((2, 3))   #由0到1之間的隨機數構成一個2行3列的矩陣，np.random中的方法幾乎和Python的random模塊中的方法相同
print(e)

# 輸出6
[[0.26358359 0.86922218 0.12168824]
 [0.58244693 0.30264221 0.795065  ]]

# 示例7
from numpy import pi
f = np.linspace(0, 2*pi, 100)   #由0到2pi中間的100個數構成一個一維矩陣，這些書之間的增量相同
print(f)

# 輸出7
[0.         0.06346652 0.12693304 0.19039955 0.25386607 0.31733259
 0.38079911 0.44426563 0.50773215 0.57119866 0.63466518 0.6981317
 0.76159822 0.82506474 0.88853126 0.95199777 1.01546429 1.07893081
 1.14239733 1.20586385 1.26933037 1.33279688 1.3962634  1.45972992
 1.52319644 1.58666296 1.65012947 1.71359599 1.77706251 1.84052903
 1.90399555 1.96746207 2.03092858 2.0943951  2.15786162 2.22132814
 2.28479466 2.34826118 2.41172769 2.47519421 2.53866073 2.60212725
 2.66559377 2.72906028 2.7925268  2.85599332 2.91945984 2.98292636
 3.04639288 3.10985939 3.17332591 3.23679243 3.30025895 3.36372547
 3.42719199 3.4906585  3.55412502 3.61759154 3.68105806 3.74452458
 3.8079911  3.87145761 3.93492413 3.99839065 4.06185717 4.12532369
 4.1887902  4.25225672 4.31572324 4.37918976 4.44265628 4.5061228
 4.56958931 4.63305583 4.69652235 4.75998887 4.82345539 4.88692191
 4.95038842 5.01385494 5.07732146 5.14078798 5.2042545  5.26772102
 5.33118753 5.39465405 5.45812057 5.52158709 5.58505361 5.64852012
 5.71198664 5.77545316 5.83891968 5.9023862  5.96585272 6.02931923
 6.09278575 6.15625227 6.21971879 6.28318531]

 

9.矩陣的基礎運算

# 示例2
# 矩陣的加減運算
a = np.array([20, 30, 40, 50])
b = np.arange(4)
print(a)
print(b)
c = a - b     # 將a與b對應的位置相減
d = a + b    # 將a與b對應的位置相加
print('----------->')
print(c)
print(d)
c = c -2
print('----------->')
print(c)
print(b ** 2)    # 對b中的每一個元素平方
print(a < 40)   # 迭代判斷a中的元素是否小於40

#輸出1
[20 30 40 50]
[0 1 2 3]
----------->
[20 29 38 47]
[20 31 42 53]
----------->
[18 27 36 45]
[0 1 4 9]
[ True  True False False]

# 示例2
# 矩陣的乘法
A = np.array([
    [1, 1],
    [0, 1]
])
B = np.array([
    [2, 0],
    [3, 4]
])
print(A)
print("=============")
print(B)
print("=============")
print(A*B)    # 矩陣對應位置的元素相乘
print("=============")
print(A.dot(B))   # 矩陣乘積
print("=============")
print(np.dot(A, B))  # 矩陣乘積

# 輸出2
[[1 1]
 [0 1]]
=============
[[2 0]
 [3 4]]
=============
[[2 0]
 [0 4]]
=============
[[5 4]
 [3 4]]
=============
[[5 4]
 [3 4]]

 

10.矩陣的其餘操做

# 示例1
import numpy as np
B = np.arange(3)
print(B) 
print(np.exp(B))    # 分別計算e的0，1，2（即B中的每一個元素）次冪
print(np.sqrt(B))   # 對B求算數平方根


# 輸出1：
[0 1 2]
[1.         2.71828183 7.3890561 ]
[0.         1.         1.41421356]

# 示例2
a = np.random.random((3, 4))
print(a)
b = np.floor(10 * a)    #取整，截除小數點後面的部分
print(b)
print("------------------------------>")
c = b.ravel()     # 二維轉一維，即矩陣轉向量，返回一個新的矩陣，自身結構不改變
print(c)
c.shape = (6, 2)    # 一維轉二維，向量轉爲6×2的矩陣，對本身自身結構
print(c)
print("------------------------------>")
d = c.T
print(c.T)     # 對矩陣進行轉置

# 輸出2：
[[0.07997894 0.66199346 0.66872968 0.09003685]
 [0.80189354 0.02278636 0.82955998 0.3037011 ]
 [0.31794432 0.67269324 0.12022113 0.12148777]]
[[0. 6. 6. 0.]
 [8. 0. 8. 3.]
 [3. 6. 1. 1.]]
------------------------------>
[0. 6. 6. 0. 8. 0. 8. 3. 3. 6. 1. 1.]
[[0. 6.]
 [6. 0.]
 [8. 0.]
 [8. 3.]
 [3. 6.]
 [1. 1.]]
------------------------------>
[[0. 6. 8. 8. 3. 1.]
 [6. 0. 0. 3. 6. 1.]]

# 示例3
import numpy as np
a = np.floor(10 * np.random.random((2, 2)))
b = np.floor(10 * np.random.random((2, 2)))
print(a)
print(b)
print("------------------------------>")
c = np.vstack((a, b))    # 將兩個矩陣按行合併，兩個矩陣的列必須相同
print(c)
print("------------------------------>")
d = np.hstack((a, b))   # 兩個矩陣按列合併，兩個矩陣的行必須相同
print(d)

# 輸出3：
[[8. 7.]
 [0. 0.]]
[[6. 9.]
 [0. 1.]]
------------------------------>
[[8. 7.]
 [0. 0.]
 [6. 9.]
 [0. 1.]]
------------------------------>
[[8. 7. 6. 9.]
 [0. 0. 0. 1.]]

# 示例4
import numpy as np
a = np.floor(10 * np.random.random((2, 12)))
print(a)
print("------------------------------>")
b,c,d = np.hsplit(a, 3)    # 按列切平均分爲3份
print(b)
print(c)
print(d)
print("------------------------------>")
e,f,g = np.vsplit(a.T, 3)   # 按行切平均分爲3份
print(e)
print(f)
print(g)
print("------------------------------>")
h, i, j, k = np.hsplit(a, (3, 6, 8))  # 在第3列前面，第6列前面，第8列後面進行分割，分割爲4個矩陣，np.vsplit()用法相同
print(h)
print(i)
print(j)
print(k)


# 輸出4：
[[3. 1. 7. 4. 1. 1. 5. 8. 3. 9. 5. 6.]
 [2. 7. 6. 3. 7. 1. 6. 3. 5. 7. 9. 0.]]
------------------------------>
[[3. 1. 7. 4.]
 [2. 7. 6. 3.]]
[[1. 1. 5. 8.]
 [7. 1. 6. 3.]]
[[3. 9. 5. 6.]
 [5. 7. 9. 0.]]
------------------------------>
[[3. 2.]
 [1. 7.]
 [7. 6.]
 [4. 3.]]
[[1. 7.]
 [1. 1.]
 [5. 6.]
 [8. 3.]]
[[3. 5.]
 [9. 7.]
 [5. 9.]
 [6. 0.]]
------------------------------>
[[3. 1. 7.]
 [2. 7. 6.]]
[[4. 1. 1.]
 [3. 7. 1.]]
[[5. 8.]
 [6. 3.]]
[[3. 9. 5. 6.]
 [5. 7. 9. 0.]]

 

11.矩陣的複製

# 示例1
a = np.arange(12)
b = a       # 這種方式對b賦值，b和a是同一個對象，改變一個，另外一個也改變，至關於別名
print(b)
print(a)
print(b is a)
print("------------------------------>")
a.shape = (3, 4)
print(a)
print(b)
print(b.shape)
print(id(a))
print(id(b))


輸出1：
[ 0  1  2  3  4  5  6  7  8  9 10 11]
[ 0  1  2  3  4  5  6  7  8  9 10 11]
True
------------------------------>
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
(3, 4)
4426322848
4426322848

# 示例2
# 淺拷貝（不建議使用）
a = np.arange(12)
a.shape = (2, 6)
c = a.view()   # 淺拷貝，c和a是兩個對象，可是是同一份數據
print(a)
print(c)
print(c is a)
print("------------------------------>")
a.shape = (3, 4)   # 改變結構，兩個不相互影響
print(a)
print(c)
print("------------------------------>")
c[0,4] = 10000    # 改變數據，會影響另一個
print(a)
print(c)


# 輸出2：
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
False
------------------------------>
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
------------------------------>
[[    0     1     2     3]
 [10000     5     6     7]
 [    8     9    10    11]]
[[    0     1     2     3 10000     5]
 [    6     7     8     9    10    11]]

# 示例3
# 深拷貝
a = np.arange(12)
a.shape = (2, 6)
d = a.copy()       # 深拷貝，d和a是兩個對象，兩份數據
print(a)
print(d)
print(d is a)
print("------------------------------>")
a.shape = (3, 4)   # 改變結構，兩個不相互影響
print(a)
print(d)
print("------------------------------>")
d[0,4] = 10000    # 改變數據，兩個不相互影響
print(a)
print(d)


# 輸出3：
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
False
------------------------------>
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
------------------------------>
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[    0     1     2     3 10000     5]
 [    6     7     8     9    10    11]]

 

12.numpy的一些經常使用方法：

# 示例1
import numpy as np
data = np.sin(np.arange(20)).reshape(5, 4)
print(data)
ind = data.argmax(axis = 0) # 按列求最大值，獲得行的索引，好比第1列的最大值在第2行，則返回2，依次求出全部列最大值的索引組成一個向量
print(ind)
print(range(data.shape[1]))
data_max = data[ind, range(data.shape[1])]  # 至關於由data[2,0],data[0,1],data[3,2],data[1,3]構成的一個矩陣
print(data_max)


# 輸出1：
[[ 0.          0.84147098  0.90929743  0.14112001]
 [-0.7568025  -0.95892427 -0.2794155   0.6569866 ]
 [ 0.98935825  0.41211849 -0.54402111 -0.99999021]
 [-0.53657292  0.42016704  0.99060736  0.65028784]
 [-0.28790332 -0.96139749 -0.75098725  0.14987721]]
[2 0 3 1]
range(0, 4)
[0.98935825 0.84147098 0.99060736 0.6569866 ]

# 示例2
a = np.arange(0, 10, 2)
print(a)
b = np.tile(a, (4, 3))   # 將a當成一個總體，將其複製爲4行3列構成一個矩陣
print(b)
print('----------------------------------->')
c = np.arange(0, 11, 2)
c.shape = (2, 3)       # 對於二維一樣如此
print(c)
d = np.tile(c, (4, 3)) 
print(d)


# 輸出2：
[0 2 4 6 8]
[[0 2 4 6 8 0 2 4 6 8 0 2 4 6 8]
 [0 2 4 6 8 0 2 4 6 8 0 2 4 6 8]
 [0 2 4 6 8 0 2 4 6 8 0 2 4 6 8]
 [0 2 4 6 8 0 2 4 6 8 0 2 4 6 8]]
----------------------------------->
[[ 0  2  4]
 [ 6  8 10]]
[[ 0  2  4  0  2  4  0  2  4]
 [ 6  8 10  6  8 10  6  8 10]
 [ 0  2  4  0  2  4  0  2  4]
 [ 6  8 10  6  8 10  6  8 10]
 [ 0  2  4  0  2  4  0  2  4]
 [ 6  8 10  6  8 10  6  8 10]
 [ 0  2  4  0  2  4  0  2  4]
 [ 6  8 10  6  8 10  6  8 10]]

# 示例3
a = np.floor(10 * np.random.random((15)))
c = a.copy()
a.shape = (5, 3)
print(a)
print('----------------------------------->')
b = np.sort(a, axis=0)  # axis=0按列進行升序排序， axis=1按行升序排序， 默認按行排序
print(b)
print('----------------------------------->')
a.sort(axis=1)
print(a)
print('----------------------------------->')
j = np.argsort(c)     # 排序，取原來的索引，好比[5 3 6]執行，獲得[1 0 2], 
print(c)
print(j)
print(c[j])


# 輸出3：
[[2. 5. 5.]
 [6. 4. 9.]
 [8. 3. 0.]
 [2. 3. 0.]
 [5. 5. 4.]]
----------------------------------->
[[2. 3. 0.]
 [2. 3. 0.]
 [5. 4. 4.]
 [6. 5. 5.]
 [8. 5. 9.]]
----------------------------------->
[[2. 5. 5.]
 [4. 6. 9.]
 [0. 3. 8.]
 [0. 2. 3.]
 [4. 5. 5.]]
----------------------------------->
[2. 5. 5. 6. 4. 9. 8. 3. 0. 2. 3. 0. 5. 5. 4.]
[ 8 11  0  9  7 10  4 14  1  2 12 13  3  6  5]
[0. 0. 2. 2. 3. 3. 4. 4. 5. 5. 5. 5. 6. 8. 9.]