上一篇主要介绍了numpy的索引方法，这一篇介绍一些常用的方法。、
常见计算方法
import numpy as np
matrix = np.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
#一些常见的计算方法：sum(),min(),max(),mean(),std(),sqrt(),exp()
#使用时直接调用就行了，注意axis这个参数，axis = 1表示对行计算，axis = 0对列计算
print("#求和")
print("按行",matrix.sum(axis = 1))
print("按列",matrix.sum(axis = 0))
print('-----------------')
print("#求均值和方差")
print(matrix.mean(axis = 1))
print(matrix.std(axis = 1))
print('-----------------')
print("#求最大最小值")
print(matrix.max(axis = 1))
print(matrix.min(axis = 1))
#求和
按行 [ 30 75 120]
按列 [60 75 90]
-----------------
#求均值和方差
[10. 25. 40.]
[4.0824829 4.0824829 4.0824829]
-----------------
#求最大最小值
[15 30 45]
[ 5 20 35]
指定维度
np.arange（n,m,i）函数生成一个以n开始，m结束，步长为i的array
#指定维度，np.reshape()
array = np.arange(8) #np.arange（n,m,i）函数生成一个以n开始，m结束，步长为i的array
print(array)
print(array.reshape(2,4)) #变为2*4的矩阵了
[0 1 2 3 4 5 6 7]
[[0 1 2 3]
[4 5 6 7]]
指定均分成几块
np.linspace(n,m,i),这个函数生成一个以n开始，m结束，均分为i份的array
# np.linspace(n,m,i),这个函数生成一个以n开始，m结束，均分为i份的array
print(np.linspace(0,9,10))
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
求对数和开方
np.exp() 返回自然对数以常数e为底数的对数
np.sqrt() 就是对数进行开方
# 求对数和开方
print("原数",matrix[:,0])
print("对数",np.exp(matrix[:,0])) #自然对数以常数e为底数的对数
print("开方",np.sqrt(matrix[:,0]))
原数 [ 5 20 35]
对数 [1.48413159e+02 4.85165195e+08 1.58601345e+15]
开方 [2.23606798 4.47213595 5.91607978]
取整方法
np.floor() 向下取整;
np.ceil() 向上取整;
np.trunc() 取整数部分;
np.rint() 四舍五入取整。
# 取整方法: np.floor()向下取整; np.ceil() 向上取整; np.trunc() 取整数部分; np.rint() 四舍五入取整。
array = np.random.normal(5,5,5)
#这个方法从正态分布中抽取随机数，第一个参数是分布的平均值，第二个是标准偏差，第三个是样本大小
print(array)
print("向下取整",np.floor(array))
print("向上取整",np.ceil(array))
print("取整数部分",np.trunc(array))
print("四舍五入取整",np.rint(array))
[ 9.95119225 -2.00380924 5.05684191 2.26461747 -4.45758977]
向下取整 [ 9. -3. 5. 2. -5.]
向上取整 [10. -2. 6. 3. -4.]
取整数部分 [ 9. -2. 5. 2. -4.]
四舍五入取整 [10. -2. 5. 2. -4.]
将矩阵拉平
np.ravel() 其实就是将矩阵按顺序变为一个一维矩阵
#ravel() 方法可以将矩阵拉平
matrix = np.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
print(matrix.ravel())
[ 5 10 15 20 25 30 35 40 45]
矩阵拼接
np.hstack() 横向拼接
np.vstack() 纵向拼接
np.stack() 需要指定axis,而且会增加一个维度
#矩阵拼接
mat1 = np.array([
[5, 10],
[15, 20],
])
mat2 = np.array([
[50, 100],
[150, 200],
])
new_mat1 = np.hstack((mat1,mat2)) #横向拼接
new_mat2 = np.vstack((mat1,mat2)) #纵向拼接
print(new_mat1)
print('---------------')
print(new_mat2)
#np.stack()方法也可拼接矩阵，但是会增加一个维度，同时需要指定axis
new_mat3 = np.stack((mat1,mat2),axis = 1)
print('---------------')
print(new_mat3)
[ 15 20 150 200]]
---------------
[[ 5 10]
[ 15 20]
[ 50 100]
[150 200]]
---------------
[[[ 5 10]
[ 50 100]]
[[ 15 20]
[150 200]]]
矩阵分割
np.hsplit() 横向拼接
np.vsplit() 纵向拼接
np.split() 需要指定axis,默认是0
#切分矩阵
matrix = np.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
print(np.hsplit(matrix,3)) #纵向切分 要注意维度要和你的矩阵一致，不然会报错
print('----------------------------------------------')
print(np.vsplit(matrix,3)) #横向切分
print(np.split(matrix,3,axis = 1)) #也可直接split(),但要指定axis，默认是0
[array([[ 5],
[20],
[35]]), array([[10],
[25],
[40]]), array([[15],
[30],
[45]])]
----------------------------------------------
[array([[ 5, 10, 15]]), array([[20, 25, 30]]), array([[35, 40, 45]])]
Out[75]:
[array([[ 5],
[20],
[35]]), array([[10],
[25],
[40]]), array([[15],
[30],
[45]])]
返回最大最小值索引
np.argmax() 不指定axis时会默认算整个矩阵的最大值索引(不过这个索引是拉平后的，需要是可以先ravel一下)，指定后按行或按列求,对于argmin()也一样。
np.argmin()
# 返回最大最小值索引
matrix = np.array([
[15, 50, 10],
[20, 40, 30],
[35, 5, 45]
])
MAX_index = np.argmax(matrix)
max_index = np.argmax(matrix,axis = 0)
#不指定axis时会默认算整个矩阵的最大值索引(不过这个索引是拉平后的，需要是可以先ravel一下)，指定后按行或按列求。
min_index = np.argmin(matrix,axis = 0)
print(MAX_index)
print(max_index)
print(min_index)
1
[2 0 2]
[0 2 0]
排序
np.sort() 可指定按行或按列排序。
np.argsort() 可得到排序索引。
# 排序
matrix = np.array([
[15, 50, 10],
[20, 40, 30],
[35, 5, 45]
])
sorted_matrix = np.sort(matrix,axis = 1) #可指定按行或按列排序
print(sorted_matrix)
print(np.argsort(matrix)) #可得到排序索引
[[10 15 50]
[20 30 40]
[ 5 35 45]]
[[2 0 1]
[0 2 1]
[1 0 2]]
扩展矩阵
np.tile(matrix,(n,m)) 将matrix复制n*m倍
#复制扩展矩阵
mat = np.array([
[5, 10],
[15, 20],
])
np.tile(mat,(2,2)) #扩展为原数2*2的矩阵
array([[ 5, 10, 5, 10],
[15, 20, 15, 20],
[ 5, 10, 5, 10],
[15, 20, 15, 20]])
矩阵乘法
A * B 如果是array结构，就是各自对应相乘，如果是矩阵结构，就是矩阵乘法。
A.multiply(A,B) 对应各自相乘。
A.dot(B) = np.dot(A,B) 矩阵乘法。
#矩阵乘法
A = np.array( [[1,0],
[0,1]] )
B = np.array( [[3,3],
[3,3]] )
print("------------------当A,B为array时---------------------")
#当A,B为array时
print("*乘\n",A*B) # 此处对应相乘
print("np.multiply\n",np.multiply(A,B)) #对应相乘
# 以下两个方法都是矩阵乘法
print("np.dot\n",A.dot(B))
print(np.dot(A, B))
print("------------------当A,B为matrix时---------------------")
#当A,B为matrix时,以下所有乘法都是矩阵乘法
A = np.mat(A)
B = np.mat(B)
print("*乘\n",A*B) #此处矩阵乘法
print("np.multipl\n",np.multiply(A,B)) #对应相乘
print("np.dot\n",A.dot(B))
print(np.dot(A, B))
------------------当A,B为array时---------------------
*乘
[[3 0]
[0 3]]
np.multiply
[[3 0]
[0 3]]
np.dot
[[3 3]
[3 3]]
[[3 3]
[3 3]]
------------------当A,B为matrix时---------------------
*乘
[[3 3]
[3 3]]
np.multipl
[[3 0]
[0 3]]
np.dot
[[3 3]
[3 3]]
[[3 3]
[3 3]]
至此，numpy的学习暂时告一段落，因为我觉得目前实用的一些基本方法都在这里了，以后遇到一些新方法也会加入进来的。这些方法也不用死记硬背，真正需要用到时可以查文档的。
下一篇开始学习pandas了。
