文章目录
一、前言
本文基于liuyubobobo老师机器学习视频做成的个人总结博客，仅供分享，欢迎大家一起探讨与交流。
建议大家在学习时，自己多敲代码去实践，在不断尝试中 掌握相应的方法。
二、编译环境
IDE：Jupyter Notebook
库 ： Numpy
三、Numpy基础
（一）创建numpy.array的方法
1.np.array()
import numpy as np
np.arr1 = np.array([1,2,3,4]) #创建一维数组
output:array([1,2,3,4])
np.arr2 = np.array([[1,2,3], #创建二维数组,同理可创建多维数组
[4,5,6]])
output:array([[1, 2, 3],
[4, 5, 6]])
np.arr3 = np.array([i for i in range(10)]) #也可利用列表初始化
output:array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
说明：在numpy.array中，只能有一种数据类型，不能修改为其他类型，例如：整型数组内不能存入字符，这点不同于array.array方法;另外当我们在整型数组中存入浮点类型时，会自动隐式类型转换，具体细节可通过help(np.array)查看官方文档
2.np.zeros()、np.ones()、np.full()
arr1 = np.zeros(shape=(2,3),dtype='float64')
output:array([[0., 0., 0.],
[0., 0., 0.]])
'''创建全0数组或矩阵
第一个参数：大小/形状
第二个参数：存入的参数类型(默认为浮点类型)'''
arr2 = np.ones(shape=(2,3),dtype='float64')
output:array([[1., 1., 1.],
[1., 1., 1.]])
'''创建全1数组或矩阵
第一个参数：大小/形状
第二个参数：存入的参数类型(默认为浮点类型)'''
arr3 = np.full(shape=(2,3),fill_value=666;dtype='float64')
output:array([[666., 666., 666.],
[666., 666., 666.]])
'''创建数值全为"fill_value"的数组或矩阵
第一个参数:生成数组的大小/形状
第二个参数:数值
第三个参数:存入的参数类型(默认为整数类型)'''
3.np.eye()
arr1 = np.eye(N=3,M=2,k=1,dtype='float')
output:array([[0., 1.],
[0., 0.],
[0., 0.]])
arr2 = np.eye(N=3,M=3,k=0,dtype='float')
output:array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
'''第一个参数：行数
第二个参数：列数
第三个参数：默认情况下输出的是对角线全“1”，其余全
“0”的方阵，如果k为正整数，则在右上方第k条对角线全
“1”其余全“0”，k为负整数则在左下方第k条对角线全“1”
其余全“0”。
第四个参数：参数类型,默认为浮点类型'''
4.np.arange()、np.linspace()
arr1 = np.arange(0,10,1)
output:array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
'''在[0，10）生成一个步长为1的数组
第一个参数：起始位置(默认为0)
第二个参数：终结位置
第三个参数：步长(默认为1)
注意：范围是左闭右开区间
'''
arr2 = np.linspace(0,5,6)
output:array([0., 1., 2., 3., 4., 5.])
'''在[0，5]生成等步长的6个值
第一个参数：起始位置
第二个参数：终止位置
第三个参数：生成值得数量
说明：该函数内还有其他参数，在此不一一说明，如有兴趣
可通过help()进行查看'''
5.np.random()
arr1 = np.random.randint(0,10,size=10) #生成含有10个在[0,10)内元素的向量
output:array([0, 8, 0, 3, 5, 1, 9, 1, 7, 9])
arr2 = np.random.randint(0,10,size=(2,3)) #size参数也可为元组，此时生成一个二维的矩阵
output:array([[1, 4, 6],
[2, 2, 3]])
arr3 = np.random.random(size=(2,3)) #生成0——1之间的浮点数
output：array([[0.70043712, 0.84418664, 0.67651434],
[0.72785806, 0.95145796, 0.0127032 ]])
arr4 = np.random.normal(loc=0,scale=1,size=(2,3))
output:array([[-0.57172145, -0.10949727, 0.01902826],
[-0.94376106, 0.64057315, -0.78644317]])
'''生成符合均值为0方差为1分布的随机浮点数
第一个参数：均值
第二个参数：方差
第三个参数：生成的数组大小/形状'''
说明：可通过np.random.seed()的方式加入随机种子，保证每次生成的随机数相同
（二）numpy.array的基本操作
1.基本属性
'''初始化数组/矩阵'''
x1 = np.arange(0,20,2)
output：array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
x2 = np.arange(15).reshape(3,5)
output：array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
x1.ndim #数组的维度
output:1
x2.ndim
output:2
x1.shape #返回数组形状
output:(10,)
x2.shape
output:(3, 5)
x1.size #返回数组元素个数
output:10
x2.size
output:15
2.数据访问
'''初始化数组/矩阵'''
x1 = np.arange(0,20,2)
output：array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
x2 = np.arange(15).reshape(3,5)
output：array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
x1[0:5] #访问从[0，5）下标的数
output:array([0, 2, 4, 6, 8])
x1[:5] #访问从头到第五个元素的数
output:array([0, 2, 4, 6, 8])
x1[5:] #访问从第五个到最后一个元素的数
output:array([10, 12, 14, 16, 18])
x1[::2] #从头访问到尾，每次步长为2
output:array([ 0, 4, 8, 12, 16])
x1[::-2] #步长为负数则从尾开始访问
output:array([18, 14, 10, 6, 2])
x2[:2,:3] #对于多维数组操作类似，此例表示取出前两行的前三列的数
output:array([[0, 1, 2],
[5, 6, 7]])
x2[0,:] #取出第0行的数据
output:array([0, 1, 2, 3, 4])
x2[:,0] #取出第0列的数据
output:array([ 0, 5, 10])
说明：如果通过此方式将访问的对象赋值给另一个数组时，改变其值，同样会造成原数组值的改变，反之亦然。要想使该数据和原来数组数据无关，则需要采用copy()方法，例：X2 = x2[0 , : ].copy()。
3.reshape
'''初始化数组/矩阵'''
x1 = np.arange(0,20,2)
output：array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
x1.reshape(2,5) #将其变成2维矩阵，但此时不会改变x1原来的形状
output:array([[ 0, 2, 4, 6, 8],
[10, 12, 14, 16, 18]])
x1.reshape(1,10) #此时将一维向量修改为二维的矩阵
output:array([[ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18]])
x1.reshape(5,-1) #传入-1，系统会自动进行计算该维度有多少值
output:array([[ 0, 2],
[ 4, 6],
[ 8, 10],
[12, 14],
[16, 18]])
4.合并操作
'''初始化数组/矩阵'''
x = np.array([1,2,3])
y = np.array([3,2,1])
z = np.array([2,3,1])
A = np.arange(1,7).reshape(2,3)
outputA:array([[1, 2, 3],
[4, 5, 6]])
np.concatenate([x,y]) #拼接
output:array([1, 2, 3, 3, 2, 1])
np.concatenate([x,y,z]) #可以不仅仅只拼接两个向量
output:array([1, 2, 3, 3, 2, 1, 2, 3, 1])
np.concatenate([A,A],axis=1) #沿着第1个维度方向拼接,默认axis=0(即第0个维度),且不能处理两个维度不相同的矩阵
output:array([[1, 2, 3, 1, 2, 3],
[4, 5, 6, 4, 5, 6]])
np.vstack([A,x]) #同样也可以利用vstack处理不同维度拼接的问题，此时会自动在垂直方向进行拼接
output:array([[1, 2, 3],
[4, 5, 6],
[1, 2, 3]])
np.hstack([A,x[:2].reshape(2,1)])
output:array([[1, 2, 3, 1],
[4, 5, 6, 2]])
'''注意：传入的数据不能非法
例如：np.hstack([A,x[:2]]),此时传入的向量，在该维
度下大小不一致，导致无法进行运算'''
5.分割操作
'''初始化数组/矩阵'''
x = np.arange(10)
output:array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
A = np.arange(16).reshape(4,4)
output:array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
x1,x2,x3 = np.split(x,[3,7])
'''第一个参数:要分割的对象
第二个参数:分割点'''
output1:[0 1 2]
output2:[3 4 5 6]
output3:[7 8 9]
A1,A2 = np.split(A,[2],axis=1) #在第1个维度分割,默认在第0个维度分割
output1:[[ 0 1]
[ 4 5]
[ 8 9]
[12 13]]
output2:[[ 2 3]
[ 6 7]
[10 11]
[14 15]]
upper,lower = np.vsplit(A,[2]) #在垂直方向分割
output_upper:[[0 1 2 3]
[4 5 6 7]]
output_lower:[[ 8 9 10 11]
[12 13 14 15]]
left,right = np.hsplit(A,[2]) #在水平方向分割
output_left:[[ 0 1]
[ 4 5]
[ 8 9]
[12 13]]
output_right:[[ 2 3]
[ 6 7]
[10 11]
[14 15]]
（三）numpy.array中的运算
1.Universal Functions
'''初始化数组/矩阵'''
X = np.arange(1,16).reshape(3,5)
output:array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15]])
X+1 #加法
output:array([[ 2, 3, 4, 5, 6],
[ 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16]])
X-1 #减法
output:array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
X*2 #乘法
output:array([[ 2, 4, 6, 8, 10],
[12, 14, 16, 18, 20],
[22, 24, 26, 28, 30]])
X / 2 #除法
output:array([[0.5, 1. , 1.5, 2. , 2.5],
[3. , 3.5, 4. , 4.5, 5. ],
[5.5, 6. , 6.5, 7. , 7.5]])
X // 2 #整除
output:array([[0, 1, 1, 2, 2],
[3, 3, 4, 4, 5],
[5, 6, 6, 7, 7]], dtype=int32)
X % 2 #求余
output:array([[1, 0, 1, 0, 1],
[0, 1, 0, 1, 0],
[1, 0, 1, 0, 1]], dtype=int32)
1 / X #取倒数
output:array([[1. , 0.5 , 0.33333333, 0.25 , 0.2 ],
[0.16666667, 0.14285714, 0.125 , 0.11111111, 0.1 ],
[0.09090909, 0.08333333, 0.07692308, 0.07142857, 0.06666667]])
np.abs(X) #求绝对值
output:array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15]])
np.sin(X) #取正弦函数值,同样的有np.cos(),np.tan()
output:array([[ 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]])
np.exp(X) #取e的X次方
output:array([[2.71828183e+00, 7.38905610e+00, 2.00855369e+01, 5.45981500e+01,1.48413159e+02],
[4.03428793e+02, 1.09663316e+03, 2.98095799e+03, 8.10308393e+03,2.20264658e+04],
[5.98741417e+04, 1.62754791e+05, 4.42413392e+05, 1.20260428e+06,3.26901737e+06]])
np.power(3,X) #取3的X次方
output:array([[ 3, 9, 27, 81, 243],
[ 729, 2187, 6561, 19683, 59049],
[ 177147, 531441, 1594323, 4782969, 14348907]], dtype=int32)
np.log2(X) #取以2为底X的log值,默认取以e为底的对数值
output:array([[0. , 1. , 1.5849625 , 2. , 2.32192809],
[2.5849625 , 2.80735492, 3. , 3.169925 , 3.32192809],
[3.45943162, 3.5849625 , 3.70043972, 3.80735492, 3.9068906 ]])
2.矩阵运算
'''初始化数组/矩阵'''
A = np.arange(4).reshape(2,2)
B = np.full((2,2),1)
outputA:[[0 1]
[2 3]]
outputB:[[1 1]
[1 1]]
A+B #矩阵之间的加法（对应元素相加） 同类型的还有A-B A*B等
output:array([[1, 2],
[3, 4]])
A.dot(B) #数学定义上的矩阵乘法
output:array([[1, 1],
[5, 5]])
A.T #求转置矩阵
output:array([[0, 2],
[1, 3]])
3.矩阵的逆
'''初始化数组/矩阵'''
A = np.arange(4).reshape(2,2)
outputA:[[0 1]
[2 3]]
A2 = np.arange(15).reshape(3,5)
outputA2:array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
np.linalg.inv(A) #求A矩阵的逆矩阵
output：array([[-1.5, 0.5],
[ 1. , 0. ]])
pinvX = np.linalg.pinv(A2) #对于非方阵，可以对其求伪逆矩阵
output:array([[-2.26666667e-01, -6.66666667e-02, 9.33333333e-02],
[-1.23333333e-01, -3.33333333e-02, 5.66666667e-02],
[-2.00000000e-02, -1.02282287e-17, 2.00000000e-02],
[ 8.33333333e-02, 3.33333333e-02, -1.66666667e-02],
[ 1.86666667e-01, 6.66666667e-02, -5.33333333e-02]])
（四）聚合操作
'''为了便于理解，以例子的方式进行讲解'''
L = np.arange(15).reshape(5,3)
output:array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11],
[12, 13, 14]])
sum1 = np.sum(L) #求和
sum2 = np.sum(L,axis=0) #沿着第0个维度进行和运算
output1:105
output2:[30 35 40]
min_L = np.min(L) #求最小值
max_L = np.max(L) #求最大值
output1:0
output2:14
np.prod(L) #对L中每个元素进行相乘
output:0
np.mean(L) #求平均值
output:7.0
np.median(L) #求中位数
output:7.0
for percent in [0,25,50,100]:
print(np.percentile(L,q=percent))
output:0.0
3.5
7.0
14.0
'''第一个参数:传入的数组，
第二个参数:百分之多少的数小于等于该值'''
np.val(L) #求方差
output:18.666666666666668
np.std(L) #求标准差
output:4.320493798938574
（五）索引
'''为了便于理解，以例子的方式进行讲解'''
L = np.random.randint(15,size=(10,)) #注意，若此时size为（10，1），则该数组为二维
output:array([8, 1, 9, 5, 4, 9, 8, 8, 4, 8])
max_X = np.max(L)
max_argX = np.argmax(L) #返回最大值的索引,对最小值同理
output1:9
output2:2
L1 = np.sort(L)
L2 = np.argsort(L) #返回排序值的索引
output1:[1 4 4 5 8 8 8 8 9 9]
output2:[1 4 8 3 0 6 7 9 2 5]
