机器学习基础 --- numpy的基本使用

一、numpy的简介

　　numpy是Python的一种开源的数值计算扩展库。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix））。

　　NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。

　　Numpy中包含了大量的矩阵运算，所以读者最好具有一点儿线性代数的基础。

二、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,''])  # 有一个为字符串，全为字符串
print(numbers)
numbers.dtype

示例3

['' '' '' '']
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(['', '', '', ''])
print(vector.dtype)
print(vector)
vector = vector.astype(int)   #使用astype方法做类型转换
print(vector.dtype)
print(vector)

　　输出：

<U1
['' '' '' '']
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.]