【NumPy】常用姿势积累
【摘要】
文章目录
1.矩阵运算2.arange()生成ndarray数组3.meshgrid4.通过array转为二维数组5.利用 ix_()函数进行数组切片6.数组连接7.数据的存取8.求逆、解方程、特...
NumPy 的前身 Numeric 最早是由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。
如何导入并使用Numpy创建数组以及相关的数组运算、获得数组的尺寸、数组的四则运算与数学函数运算、数组的切片、数组连接和数据的存取、数组形态变换、数组元素的排序与搜索、矩阵及线性代数运算等相关知识。
由于Numpy借鉴了Matlab矩阵开发思路，故Numpy的数组创建、运算、切片、连接及存取、排序与搜索、矩阵及线性代数运算均与Matlab的矩阵操作极为相似。
NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：
- 一个强大的N维数组对象 ndarray
- 广播功能函数
- 整合 C/C++/Fortran 代码的工具
- 线性代数、傅里叶变换、随机数生成等功能
Numpy中，矩阵有两种表示方式：
matrix类时，比如2 x 3矩阵A不能和A自身相乘
array类时，上面的A则可以相乘，默认的乘法是Hadamard乘法（即矩阵之间的逐点乘积，对应的矩阵元素相乘）。
1.矩阵运算
（1）dot是点积，a.dot(b) 与 np.dot(a,b)效果相同。如果是直接A*B则是两个矩阵对应位置的元素分别进行相乘得到新的矩阵。
矩阵积计算不遵循交换律,np.dot(a,b) 和 np.dot(b,a) 得到的结果是不一样的
（2）transpose是矩阵转置
（3）inv是求矩阵的逆
import numpy as np
from numpy.linalg import inv
A = np.matrix([[1, 2], [3, 4], [5, 6]])
print(A)
print("=================")
B = np.matrix(range(1, 7)).reshape(3, 2)
print(B)
print("=================")
# 创建特殊矩阵
ans1 = np.zeros((3, 2))
print(ans1)
print("=================")
ans2 = np.identity(3)
print(ans2)
print("=================")
# 矩阵中向量的提取
m = np.array(range(1, 10)).reshape(3, 3)
print(m)
print("=================")
# 提取行向量
ans3 = m[[0, 2]] # m[[True, False, True]]
print(ans3)
print("=================")
# 提取列向量
ans4 = m[:, [1, 2]] # 或者m[:, [False, True, True]]
print(ans4)
print("=================")
# 矩阵的运算
n = np.array(range(1, 5)).reshape(2, 2)
print(n)
print("=================")
np.transpose(n)
print(n)
print("=================")
add = n + n
print(add)
print("=================")
plus = n - n
print(plus)
print("=================")
# 矩阵的逆矩阵
#ni = inv(n)
#print(ni)
# 矩阵的逆和原矩阵相乘得到单位矩阵
danwei = np.dot(inv(n), n)
print(danwei)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
2.arange()生成ndarray数组
Numpy 中 arange() 主要是用于生成数组，具体用法如下
numpy.arange(start, stop, step, dtype = None)
在给定间隔内返回均匀间隔的值。
值在半开区间 [开始，停止]内生成（换句话说，包括开始但不包括停止的区间）,返回的是 ndarray 。
from numpy import * # 引入numpy
A = arange(5) # 只有结束项
print(A) # 结果 [0 1 2 3 4] 结果不包含结束项
print(type(A)) # 结果 <class 'numpy.ndarray'>
A = arange(1, 5) # 起点为1，步长默认为1
print(A) # 结果 [1 2 3 4]
A = arange(1, 5, 2) # 步长默认为2
print(A) # 结果 [1 3]
A = arange(1, 5.2, 0.6) # 浮点数参数，结果就不一定完全符合了
print(A) # 结果 [1. 1.6 2.2 2.8 3.4 4. 4.6 5.2]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
3.meshgrid
meshgrid适合画3D图，而mgrid适合画2D图。
适用于生成网格型数据，可以接受两个一维数组生成两个二维矩阵，对应两个数组中所有的(x,y)对。
那么生成的第一个二维数组是以xarray为行，共ydimesion行的向量；
而第二个二维数组是以yarray的转置为列，共xdimesion列的向量。
import numpy as np
xnums = np.arange(4)
#print(xnums)# [0 1 2 3]
#print(type(xnums)) # <class 'numpy.ndarray'>
ynums = np.arange(5)
data_list = np.meshgrid(xnums, ynums)
# meshgrid生成网格型数据，接受2个一维数组生成2个
print(data_list)
x, y = data_list
print(x.shape)
print(y.shape)
print(x)
print(y)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
输出结果为：
[array([[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3]]), array([[0, 0, 0, 0],
[1, 1, 1, 1],
[2, 2, 2, 2],
[3, 3, 3, 3],
[4, 4, 4, 4]])]
(5, 4)
(5, 4)
[[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]]
[[0 0 0 0]
[1 1 1 1]
[2 2 2 2]
[3 3 3 3]
[4 4 4 4]]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
4.通过array转为二维数组
L=[[1,2],[3,4]] #定义待转化的嵌套列表L
print(L)
import numpy #导入Numpy包
A=numpy.array(L) #调用Numpy包中提供的函数array()，将L转化为二维数组并赋给A
# 即将数据转为数组的形式
print(A)
# [[1, 2], [3, 4]]
# [[1 2]
[3 4]]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
也可以用其他的嵌套方式再用array函数：
#1.先预定义列表d1，元组d2，嵌套列表d3、d4和嵌套元组d5
d1=[1,2,3,4,0.1,7] #列表
d2=(1,2,3,4,2.3) #元组
d3=[[1,2,3,4],[5,6,7,8]] #嵌套列表，元素为列表
d4=[(1,2,3,4),(5,6,7,8)] #嵌套列表，元素为元组
d5=((1,2,3,4),(5,6,7,8)) #嵌套元组
#2.导入Numpy，并调用其中的array函数，创建数组
import numpy as np
d11=np.array(d1)
d21=np.array(d2)
d31=np.array(d3)
d41=np.array(d4)
d51=np.array(d5)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
5.利用 ix_()函数进行数组切片
# 2.5.2 利用 ix_()函数进行数组切片
import numpy as np
D=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]) #定义数组D
#提取D中行数为1、2，列数为1、3的所有元素
D3=D[np.ix_([1,2],[1,3])]
#提取D中行数为0、1，列数为1、3的所有元素
D4=D[np.ix_(np.arange(2),[1,3])]
#提取以D中第1列小于11得到的逻辑数组作为行索引，列数为1、2的所有元素
D6=D[np.ix_(D[:,1]<11,[1,2])]
#提前以D中第1列小于11得到的逻辑数组作为行索引，列数为2的所有元素
D7=D[np.ix_(D[:,1]<11,[2])]
#提前以第2.5.1节中的TF=[True,False,False,True]逻辑列表为行索引，列数为2的所有元素
TF=[True,False,False,True]
D8=D[np.ix_(TF,[2])]
#提前以第2.5.1节中的TF=[True,False,False,True]逻辑列表为行索引，列数为1、3的所有元素
D9=D[np.ix_(TF,[1,3])]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
6.数组连接
# 2.6 数组连接
import numpy as np
A=np.array([[1,2],[3,4]]) #定义二维数组A
B=np.array([[5,6],[7,8]]) #定义二维数组B
C_s=np.hstack((A,B)) #水平连接要求行数相同
C_v=np.vstack((A,B)) #垂直连接要求列数相同
- 1
- 2
- 3
- 4
- 5
- 6
7.数据的存取
# 2.7 数据存取
import numpy as np
A=np.array([[1,2],[3,4]]) #定义二维数组A
B=np.array([[5,6],[7,8]]) #定义二维数组B
C_s=np.hstack((A,B)) #水平连接
np.save('data',C_s)
import numpy as np
C_s=np.load('data.npy')
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
8.求逆、解方程、特征值
# 2.10.1 创建Numpy矩阵
import numpy as np
# 用mat则不会为矩阵创建副本
mat1 = np.mat("1 2 3; 4 5 6; 7 8 9")
mat2 = np.matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("mat1: \n",mat1)
print("mat2: \n",mat2)
print("-"*40)
import numpy as np
arr1 = np.eye(3)
arr2 = 3*arr1
mat = np.bmat("arr1 arr2; arr1 arr2") # 分块矩阵，bmat嵌套矩阵
print("arr1 :\n",arr1)
print("arr2 :\n",arr2)
print("mat: \n",mat)
print("-"*40)
# 2.10.2 矩阵的属性和基本运算
import numpy as np
mat = np.matrix(np.arange(4).reshape(2, 2))
print("mat:\n",mat)
mT=mat.T # 返回自身的转置
mH=mat.H # 返回自身的共轭转置
mI=mat.I # 返回自身的逆矩阵
print("-"*40)
import numpy as np
mat1 = np.mat("1 2 3; 4 5 6; 7 8 9")
mat2 = mat1*3
mat3=mat1+mat2
mat4=mat1-mat2
mat5=mat1*mat2
mat6=np.multiply(mat1, mat2) #点乘
print("-"*40)
# 2.10.3 线性代数运算
# 1．计算逆矩阵
import numpy as np
mat = np.mat('1 1 1; 1 2 3; 1 3 6')
inverse = np.linalg.inv(mat)
print(inverse)
# mat矩阵和inverse矩阵进行点乘
A=np.dot(mat, inverse)
print("A和A的逆矩阵点乘的结果:\n",A)
print("-"*40)
# 2．求解线性方程组
import numpy as np
A = np.mat("1,-1,1; 2,1,0; 2,1,-1")
b = np.array([4, 3, -1])
x = np.linalg.solve(A, b)#线性方程组Ax=b的解
print("Ax=b的解为：",x)
print("-"*40)
# 3．求解特征值与特征向量
import numpy as np
A = np.matrix([[1, 0, 2], [0, 3, 0], [2, 0, 1]])
# A_value= np.linalg.eigvals(A) # 也可以这样求特征值
A_value, A_vector = np.linalg.eig(A)
print("A矩阵的特征值为：",A_value)
print("A矩阵的特征向量为：\n",A_vector)
print("-"*40)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
结果为：
mat1:
[[1 2 3]
[4 5 6]
[7 8 9]]
mat2:
[[1 2 3]
[4 5 6]
[7 8 9]]
----------------------------------------
arr1 :
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
arr2 :
[[3. 0. 0.]
[0. 3. 0.]
[0. 0. 3.]]
mat:
[[1. 0. 0. 3. 0. 0.]
[0. 1. 0. 0. 3. 0.]
[0. 0. 1. 0. 0. 3.]
[1. 0. 0. 3. 0. 0.]
[0. 1. 0. 0. 3. 0.]
[0. 0. 1. 0. 0. 3.]]
----------------------------------------
mat:
[[0 1]
[2 3]]
----------------------------------------
----------------------------------------
[[ 3. -3. 1.]
[-3. 5. -2.]
[ 1. -2. 1.]]
A和A的逆矩阵点乘的结果:
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
----------------------------------------
Ax=b的解为： [1. 1. 4.]
----------------------------------------
A矩阵的特征值为： [ 3. -1. 3.]
A矩阵的特征向量为：
[[ 0.70710678 -0.70710678 0. ]
[ 0. 0. 1. ]
[ 0.70710678 0.70710678 0. ]]
----------------------------------------
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
9.奇异值分解、计算行列式
# 4．奇异值分解
import numpy as np
A = np.mat("4.0,11.0,14.0; 8.0,7.0,-2.0")
U, Sigma, V = np.linalg.svd(A, full_matrices=False)
# U和V是正交矩阵
print("U:",U)
print("一开始的Sigma：",Sigma)
# Sigma是一维的，其元素为进行奇异值分解的矩阵的非奇异值,可用dig生成对角矩阵
Sigma = np.diag(Sigma)
print("变为对角矩阵Sigma：\n",Sigma)
print("V:",V)
print("-"*40)
# 5．计算矩阵行列式的值
import numpy as np
A = np.mat("3,4; 5,6")
A_value=np.linalg.det(A)
print("A的行列式为：\n",A_value)
print("-"*40)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
结果为：
U: [[ 0.9486833 -0.31622777]
[ 0.31622777 0.9486833 ]]
一开始的Sigma： [18.97366596 9.48683298]
变为对角矩阵Sigma：
[[18.97366596 0. ]
[ 0. 9.48683298]]
V: [[ 0.33333333 0.66666667 0.66666667]
[ 0.66666667 0.33333333 -0.66666667]]
----------------------------------------
A的行列式为：
-2.0000000000000004
----------------------------------------
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
10.argsort函数
import numpy as np
x = np.array([1, 4, 3, -1, 6, 9])
print(x.argsort())
# [3 0 2 1 4 5]
- 1
- 2
- 3
- 4
argsort()函数是将x中的元素从小到大排列，提取其对应的index(索引)，然后输出到y。例如：x[3]=-1最小，所以y[0]=3,x[5]=9最大，所以y[5]=5。
Reference
（1）numpy官方文档
（2）【numpy】np.argsort()函数
文章来源: andyguo.blog.csdn.net，作者：山顶夕景，版权归原作者所有，如需转载，请联系作者。
原文链接：andyguo.blog.csdn.net/article/details/118030991
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）