numpy包

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

致谢

感谢上述博主的分享！