numpy
矩阵
导入库
from numpy import * # 导入numpy的库函数
import numpy as np # 使用numpy的函数时以np.开头。
创建矩阵
数组创建矩阵
from numpy import *
a1 = array([1, 2, 3]) # a1 = np.array([1,2,3], dtype=int)
a1 = mat(a1) # mat转化为矩阵
常见矩阵
data1 = mat(zeros((3, 3))) # 创建一个3*3的零矩阵
b1 = np.zeros((2, 3)) # 完整的形式为：zeros(shape,dtype=)
data2 = mat(ones((2, 4))) # 创建一个2*4的1矩阵，默认是浮点型的数据
data7 = mat(ones((2, 4), dtype = int)) # 创建一个2*4的1的int类型矩阵
data3 = mat(random.rand(2, 2)) # 创建的是一个二维数组，需要将其转换成矩阵
data4 = mat(random.randint(10, size=(3, 3))) # 生成一个3*3的0-10之间的随机整数矩阵
data5 = mat(random.randint(2, 8, size=(2, 5)) # 产生一个2-8之间的随机整数矩阵
data6 = mat(eye(2, 2, dtype = int)) # 产生一个2*2的对角矩阵
a1 = [1, 2, 3]
a2 = mat(diag(a1)) # 生成一个对角线为1、2、3的对角矩阵
常见矩阵运算
乘法
a1 = mat([1,2]) # 1*2的矩阵，行矩阵
a2 = mat([[1],[2]]) # 2*1的矩阵，列矩阵
a3 = a1*a2 # 1*2的矩阵乘以2*1的矩阵，得到1*1的矩阵
np.dot(a, b) # 计算点积
vdot(a, b) # 专门计算矢量的点积，和dot()的区别在于对complex数据类型的处理不一样；
innner(a, b) # 用来计算内积
outer(a, b) # 计算外积
点乘
a1 = mat([1, 1])
a2 = mat([2, 2])
a3 = multiply(a1, a2) # 矩阵对应元素相乘
a4 = mat([2, 2])
a5 = a4 * 2 # 矩阵点乘
求逆
a1 = mat(eye(2, 2) * 0.5)
a2 = a1.I # .I表示矩阵的逆
转置
a1 = mat([[1, 1], [0, 0]])
a2 = a1.T # .T表示矩阵转置
求行列和
a1 = mat([[1, 1], [2, 3], [4, 2]])
a2 = a1.sum(axis = 0) # 列和，这里得到的是1*2的矩阵
a3 = a1.sum(axis = 1) # 行和，这里得到的是3*1的矩阵
a4 = sum(a1[1, :]) # 计算第一行所有列的和，这里得到的是一个数值
最大最小值
a1 = mat([[1, 1], [2, 3], [4, 2]])
a1.max() # 计算a1矩阵中所有元素的最大值,这里得到的结果是一个数值
a2 = max(a1[:, 1]) # 计算第二列的最大值，这里得到的是一个1*1的矩阵
a1[1, :].max() # 计算第二行的最大值，这里得到的是一个一个数值
np.max(a1, 0) # 计算所有列的最大值，这里使用的是numpy中的max函数
np.max(a1, 1) # 计算所有行的最大值，这里得到是一个矩阵
np.argmax(a1, 0) # 计算所有列的最大值对应在该列中的索引
np.argmax(a1[1, :]) # 计算第二行中最大值对应在改行的索引
分割合并
# 分割
a = mat(ones((3, 3)))
b = a[1:, 1:] # 分割出第二行以后的行和第二列以后的列的所有元素
# 合并
a = mat(ones((2, 2)))
b = mat(eye(2))
c = vstack((a, b)) # 按列合并，即增加行数
d = hstack((a, b)) # 按行合并，即行数不变，扩展列数
类型转换
l1 = [[1], 'hello', 3] # 列表中元素可以使不同类型的数据
a = array([[2], [1]]) # numpy中同一个数组中所有元素必须为同一个类型
dimension = a.ndim
m, n = a.shape
number = a.size # 元素总个数
str = a.dtype # 元素的类型
a1 = [[1, 2], [3, 2], [5, 2]] # 列表
a2 = array(a1) # 将列表转换成二维数组
a3 = array(a1) # 将列表转化成矩阵
a4 = array(a3) # 将矩阵转换成数组
a5 = a3.tolist() # 将矩阵转换成列表
a6 = a2.tolist() # 将数组转换成列表
a1 = [1, 2, 3]
a2 = array(a1)
a3 = mat(a1)
a4 = a2.tolist() # 这里得到的是[1,2,3]
a5 = a3.tolist() # 这里得到的是[[1,2,3]]
a6 = (a4 == a5) # a6=False
a7 = (a4 is a5[0]) # a7=True,a5[0]=[1,2,3]
dataMat = mat([1])
val = dataMat[0, 0] # 这个时候获取的就是矩阵的元素的数值，而不再是矩阵的类型
其他
from numpy import * # 导入numpy的库函数
# 将Python的列表转换成NumPy的矩阵
list = [1, 2, 3]
mat(list)
# 矩阵相乘
m1 = mat([1, 2, 3]) # 1行3列
m2 = mat([4, 5, 6])
m1 * m2.T # 注意左列与右行相等 m2.T为转置操作
multiply(m1, m2) # 执行点乘操作，要使用函数，特别注意
# 排序
m = mat([[2, 5, 1], [4, 6, 2]]) # 创建2行3列矩阵
m.sort() # 对每一行进行排序
m.shape # 获得矩阵的行列数
m.shape[0] # 获得矩阵的行数
m.shape[1] # 获得矩阵的列数
# 索引取值
m[1, :] # 取得第一行的所有元素
m[1, 0:1] # 第一行第0个元素，注意左闭右开
m[1, 0:3]
m[1, 0:2]
数组
定义数组
from numpy import *
# 数组定义
a1 = array([1, 1, 1]) # 定义一个数组
a2 = array([2, 2, 2])
# 定义多维数组
a3 = array([[1, 2, 3], [4, 5, 6]])
a3[0] # 取出第一行的数据
a3[0, 0] # 第一行第一个数据
a3[0][0] # 也可用这种方式
# 指定数组类型
c = array( [ [1,2], [3,4] ], dtype=complex )
常见函数
import numpy as np
a = np.zeros((2, 2)) # 创建一个全0的数组，或者不加.np直接 zeros((2, 2))
b = np.ones((1, 2)) # 创建一个全1的数组，或者不加.np直接 ones((1, 2))
c = np.full((2, 2), 7) # 创建一个全为7的2*2的数组
d = np.eye(2) # 创建一个对角矩阵，对角线全为1
e = np.random.random((2, 2)) # 创建一个2*2的矩阵，元素值随机浮点数
f = enpty((2, 3)) # 内容随机的的2*3的数组
g = arange(10, 30, 5) # 返回一个首项为10，公差为5的数列，尾项不超过30
数组特征信息
X.flags # 数组的存储情况信息。
X.shape # 结果是一个tuple，返回本数组的行数、列数、……
X.ndim # 数组的维数，结果是一个数
X.size # 数组中元素的总个数
X.itemsize # 数组中的每个元素的所占内存空间大小，，单位是字节
X.dtype # 数据类型
X.data # 包含实际数组元素的缓冲区，不建议使用
X.T # 如果X是矩阵，发挥的是X的转置矩阵
X.trace() # 计算X的迹
np.linalg.det(a) # 返回的是矩阵a的行列式
np.linalg.norm(a, ord=None) # 计算矩阵a的范数
np.linalg.eig(a) # 矩阵a的特征值和特征向量
np.linalg.cond(a, p=None) # 矩阵a的条件数
np.linalg.inv(a) # 矩阵a的逆矩阵
数组运算
from numpy import *
# 数组定义
a1 = array([1, 1, 1]) # 定义一个数组
a2 = array([2, 2, 2])
a1 + a2 # 对应元素相加，也可以是add(a1, a2)
a1 - a2 # 对应元素相减
a1 * 2 # 对应元素乘一个数->rray([2, 2, 2])
# 乘方
a1 = array([1, 2, 3])
a1 ** 3 # 表示对数组中的每个数做平方->array([1, 8, 27])
# 定义多维数组
a3 = array([[1, 2, 3], [4, 5, 6]])
a3[0] # 取出第一行的数据
a3[0, 0] # 第一行第一个数据
a3[0][0] # 也可用这种方式
# 指定数组类型
c = array( [ [1,2], [3,4] ], dtype=complex )
# 矩阵点乘
a1 = array([1, 2, 3])
a2 = array([4, 5, 6])
a3 = dot(a1, a2)
# 计算列和行和，累计和
a1 = array([
[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
a2 = a1.sum(axis=0) # 计算列和
a3 = a1.sum(axis=1) # 计算行和
a4 = a1.cumsum(axis=1) # 计算每行累积和,axis=0计算每列累积和
>>>a4 = array([[ 0, 1, 3, 6],
[ 4, 9, 15, 22],
[ 8, 17, 27, 38]])
# 通用函数
b1 = array([0, 1, 2])
b2 = exp(b1)
b3 = sqrt(b1)
b4 = sin(b1)
索引
from numpy import *
a = arange(10) ** 3
a = arange(10) ** 3 # a = array([0,1,8,27,64,125,216,343,512,729])
a[2] # = 8
a[2:5] # = array([8,27,64])
a[:6:2] = -1000 # = array([-1000,1,-1000,27, -1000,125, 216,343,512,729])
a[::-1] # = array([729,512,343,216,125,-1000,27,-1000,1,-1000]) 反向排序
# 省略点(…)代表许多产生一个完整的索引元组必要的分号
# b[i]中括号中的表达式被当作i和一系列
# :来代表剩下的轴
# x[1,2,…] 等同于 x[1,2,:,:,:],
# x[…,3] 等同于 x[:,:,:,:,3]
# x[4,…,5,:] 等同 x[4,:,:,5,:].
组合
a = array([[ 1., 1.],
[ 5., 8.]])
b = array([[ 3., 3.],
[ 6., 0.]])
c1 = vstack((a,b)) # 合并行
c2 = hstack((a,b)) # 合并列
矩阵和数组的区别
matrix是array的分支，matrix和array在很多时候都是通用的，官方建议大家如果两个可以通用，那就选择array，因为array更灵活，速度更快。
matrix的优势就是相对简单的运算符号，比如两个矩阵相乘，就是用符号*，但是array相乘不能这么用，得用方法.dot()
array的优势就是不仅仅表示二维，还能表示3、4、5…维，而且在大部分Python程序里，array也是更常用的。
在python中，可以使用numpy中array创建一个narray对象，我们可以使用dot(a,b)或者@进行普通矩阵乘法，或者使用multipy(a,b)或者*进行数量积操作。
在python创建一个numpy.array([1,2,3])他是一个行向量，shape = (3,)具体来说退化成一个数组，他是可以看做一个行向量或者列向量，具体要看他是在矩阵乘法的左边还是右边，下面进行测试
参考文献
https://blog.csdn.net/qq_31409555/article/details/51436180
https://blog.csdn.net/taxueguilai1992/article/details/46581861
https://blog.csdn.net/alxe_made/article/details/80492649
https://blog.csdn.net/alxe_made/article/details/80492649
致谢
感谢上述博主的分享！