文章目录

• 一、前言
• 二、编译环境
• 三、Numpy基础
• （一）创建numpy.array的方法
•   1.np.array()
•   2.np.zeros()、np.ones()、np.full()
•   3.np.eye()
•   4.np.arange()、np.linspace()
•   5.np.random()

•   1.基本属性
•   2.数据访问
•   3.reshape
•   4.合并操作
•   5.分割操作

•   1.Universal Functions
•   2.矩阵运算
•   3.矩阵的逆

一、前言

  本文基于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]

• 点赞 2
• 收藏
• 分享
• 文章举报