Numpy的矩阵操作

# 导入 numpy
import numpy as np

mat() 函数与 array() 函数的区别

• mat()函数中数据可以为字符串以分号（;）分割或者为列表形式以逗号（，）分割，而array()函数中数据只能为后者形式
• 两者的类型不同，用mat函数转换为矩阵后才能进行一些线性代数的操作

a1 = np.mat('1, 3; 2, 4') 
a2 = np.mat([[1, 3], [2, 4]])
print(a1)
print('a1的类型：', type(a))
print('a2：', a2)

[[1 3]
 [2 4]]
a1的类型： <class 'numpy.matrix'>
a2： [[1 3]
 [2 4]]

b = np.array([[1, 2], [1, 3]])
print(b)
print('b的类型：', type(b))

[[1 2]
 [1 3]]
b的类型： <class 'numpy.ndarray'>

创建常用矩阵

随机矩阵

array1 = np.random.rand(4, 4)
print(array1)
print(type(array1))

# 将 ndarray 类型转为 matrix 类型
matrix1 = np.mat(array1)
print(matrix1)
print(type(matrix1))

[[0.108369   0.67194745 0.70255467 0.73207351]
 [0.87105564 0.37146943 0.97825763 0.98789354]
 [0.34650917 0.64605897 0.65585639 0.99987454]
 [0.54715213 0.17730709 0.90696935 0.12732245]]
<class 'numpy.ndarray'>
[[0.108369   0.67194745 0.70255467 0.73207351]
 [0.87105564 0.37146943 0.97825763 0.98789354]
 [0.34650917 0.64605897 0.65585639 0.99987454]
 [0.54715213 0.17730709 0.90696935 0.12732245]]
<class 'numpy.matrix'>

# 可以直接使用 np.mat()
data1 = np.mat(np.random.rand(2, 2))
print(data1)
print(type(data1))

[[0.68738148 0.1223296 ]
 [0.4243208  0.23562135]]
<class 'numpy.matrix'>

# 生成一个 3*3 的 0-10 之间的随机整数矩阵
data2 = np.mat(np.random.randint(10, size = (3, 3)))
print(data2)

[[0 3 2]
 [7 0 5]
 [7 8 5]]

# 生成一个 3*3 的 2-8 之间的随机整数矩阵
data3 = np.mat(np.random.randint(2, 8, size=(3,3)))
print(data3)

[[3 3 7]
 [5 4 3]
 [7 2 5]]

0 矩阵

zeroMat = np.mat(np.zeros((3, 3))) # 注意 zeros 的参数是一个元组
print(zeroMat)

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

zeroArray = np.zeros(3) # 生成一个一维的全 0 数组
print(zeroArray)
print(type(zeroArray))

[0. 0. 0.]
<class 'numpy.ndarray'>

1 矩阵

onesMat = np.mat(np.ones((3, 4)))
print(onesMat)

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

onesArr = np.ones(4) # 生成一个全为 1 的数组
print(onesArr)
print(type(onesArr))

[1. 1. 1. 1.]
<class 'numpy.ndarray'>

对角矩阵

data4 = np.mat(np.eye(2, 3, dtype=int))
print(data4)

[[1 0 0]
 [0 1 0]]

# 生成一个对角线为 1, 2, 3 的对角矩阵
array_1 = [1, 2, 3]
array_2 = np.mat(np.diag(array_1))
print(array_2)

[[1 0 0]
 [0 2 0]
 [0 0 3]]

full, 自定义形状

• numpy.full(shape,fill_value=num)用于创建一个自定义形状的数组,可以自己指定一个值,用它填满整个数组。
• fill_value 用来填充的值，可以是数字，也可以是字符串

np_full = np.full(shape=(2, 3, 4), fill_value=5)
print(np_full)

[[[5 5 5 5]
  [5 5 5 5]
  [5 5 5 5]]

 [[5 5 5 5]
  [5 5 5 5]
  [5 5 5 5]]]

np_full2 = np.full(shape=(2, 3, 4), fill_value='ai')
print(np_full2)
print(type(np_full2))

[[['ai' 'ai' 'ai' 'ai']
  ['ai' 'ai' 'ai' 'ai']
  ['ai' 'ai' 'ai' 'ai']]

 [['ai' 'ai' 'ai' 'ai']
  ['ai' 'ai' 'ai' 'ai']
  ['ai' 'ai' 'ai' 'ai']]]
<class 'numpy.ndarray'>

常见矩阵操作

矩阵相乘 *

mat1 = np.mat([1, 2, 3])
mat2 = np.mat([[1], [2], [3]])
result = mat1*mat2    # 矩阵相乘
print(result)

mat3 = np.mat([[1, 2], [2, 3], [3, 4]])
result2 = mat1 * mat3
print(result2)

list1 = result2.tolist() # 将matrix 变换为 list, 可以通过下标获得值
print(list1)
print(list1[0][0])

arr1 = np.array(result2) # 将matrix 变换为 ndarray, 可以通过下标获得值
print(arr1)
print(arr1[0][0])

[[14]]
[[14 20]]
[[14, 20]]
14
[[14 20]]
14

矩阵点乘 multiply

对应元素相乘

mat4 = np.mat([2, 3])
mat5 = np.mat([3, 4])
result3 = np.multiply(mat4, mat5)
print(result3)

[[ 6 12]]

矩阵求逆变换 .I

mat6 = np.mat(np.eye(3, 3)*0.5)
print(mat6)
mat7 = mat6.I
print('矩阵的逆：')
print(mat7)

[[0.5 0.  0. ]
 [0.  0.5 0. ]
 [0.  0.  0.5]]
矩阵的逆：
[[2. 0. 0.]
 [0. 2. 0.]
 [0. 0. 2.]]

矩阵求转置 .T

mat8 = np.mat([[1, 1], [0, 0]])
mat9 = mat8.T
print('原矩阵：')
print(mat8)
print('矩阵的转置：')
print(mat9)

原矩阵：
[[1 1]
 [0 0]]
矩阵的转置：
[[1 0]
 [1 0]]

计算行列式 np.linalg.det

Y = np.reshape(np.arange(20), (5, 2, 2))
print(Y)
print('行列式的值为：')
detVal = np.linalg.det(Y[0])
print(detVal)

[[[ 0  1]
  [ 2  3]]

 [[ 4  5]
  [ 6  7]]

 [[ 8  9]
  [10 11]]

 [[12 13]
  [14 15]]

 [[16 17]
  [18 19]]]
行列式的值为：
-2.0

求矩阵的特征值和特征向量 np.linalg.eig

Z = [
    [-1, 1, 0],
    [-4, 3, 0],
    [1, 0, 2]
]
print('Z=', Z)
# 求特征值 和 特征向量
eigenValue, featureVector = np.linalg.eig(Z)
print('特征值为：', eigenValue)
print('特征向量为：', featureVector)

Z= [[-1, 1, 0], [-4, 3, 0], [1, 0, 2]]
特征值为： [2. 1. 1.]
特征向量为： [[ 0.          0.40824829  0.40824829]
 [ 0.          0.81649658  0.81649658]
 [ 1.         -0.40824829 -0.40824829]]

求矩阵对应列（行）的最大值、最小值、和

mat10 = np.mat([[1, 2], [3, 4], [5, 6]])
print(mat10)

# 列和，这里得到的是 1*2 的矩阵
sum_Col = mat10.sum(axis=0)
print('列和：')
print(sum_Col)

# 行和， 这里得到的是 3*1 的矩阵
sum_row = mat10.sum(axis=1)
print('行和：')
print(sum_row)

# 计算第一行所有列的和
sum_firstRow = np.sum(mat10[0, :])
print('第一行让所有列的和：')
print(sum_firstRow)

[[1 2]
 [3 4]
 [5 6]]
列和：
[[ 9 12]]
行和：
[[ 3]
 [ 7]
 [11]]
第一行让所有列的和：
3

计算最大、最小值、索引

mat11 = np.mat([[1, 2], [3, 4], [5, 6]])

# 计算 mat11 中所有元素的最大值
max1 = mat11.max()
print('最大值为：', max1)
# 计算 mat11 第二列最大值，得到一个1*1的矩阵
max2 = np.max(mat11[:, 1])
print('第二列最大值：', max2)
# 计算 mat11 第二行最大值
max3 = np.max(mat11[1, :])
print('第二行最大值：', max3)
# 计算所有行的最大值
max4 = np.max(mat11, 1)
print('所有行的最大值：')
print(max4)
# 计算所有列的最大值
max5 = np.max(mat11, 0)
print('所有列的最大值：')
print(max5)

最大值为： 6
第二列最大值： 6
第二行最大值： 4
所有行的最大值：
[[2]
 [4]
 [6]]
所有列的最大值：
[[5 6]]

矩阵的分隔与合并（切片， vstack, hstack）

矩阵的分隔

矩阵的分隔，同列表和数组的分割一致。

diagArr = [1, 2, 3]
mat12 = np.mat(np.diag(diagArr))
print(mat12)
mat13 = mat12[1:, 1:]
print('分隔后:')
print(mat13)

[[1 0 0]
 [0 2 0]
 [0 0 3]]
分隔后:
[[2 0]
 [0 3]]

矩阵的合并 （vstack, hstack）

mat14 = np.ones((3, 3))
print(mat14)
mat15 = np.eye(3)
print(mat15)
# 按行合并，增加扩展列数
mat15_1 = np.hstack((mat14, mat15))
print('按行合并：')
print(mat15_1)
# 按列合并，增加行数
mat15_2 = np.vstack((mat14, mat15))
print('按列合并：')
print(mat15_2)

[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
按行合并：
[[1. 1. 1. 1. 0. 0.]
 [1. 1. 1. 0. 1. 0.]
 [1. 1. 1. 0. 0. 1.]]
按列合并：
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]
 [1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

数组叠加合并 column_stack, row_stack

arr1 = [1, 2, 3, 4]
arr2 = [5, 6, 7, 8]
matCol = np.column_stack((arr1, arr2))
print(matCol)
matRow = np.row_stack((arr1, arr2))
print(matRow)

[[1 5]
 [2 6]
 [3 7]
 [4 8]]
[[1 2 3 4]
 [5 6 7 8]]

数组均分 np.array_split

arr = np.arange(20)
print(arr)

split1 = np.array_split(arr, 2)
print('平均分为2个：')
print(split1)
for i in range(len(split1)):
    print(split1[i].tolist())

split2 = np.array_split(arr, 5)
print('平均分为5个：')
print(split2)
for i in range(len(split2)):
    print(split2[i].tolist())

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
平均分为2个：
[array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
平均分为5个：
[array([0, 1, 2, 3]), array([4, 5, 6, 7]), array([ 8,  9, 10, 11]), array([12, 13, 14, 15]), array([16, 17, 18, 19])]
[0, 1, 2, 3]
[4, 5, 6, 7]
[8, 9, 10, 11]
[12, 13, 14, 15]
[16, 17, 18, 19]

矩阵、列表、数组的转换

列表的特点

列表可以修改，并且列表中元素可以使不同类型的数据，如下：

li = [12, 'hello', a]

numpy 数组的特点

numpy中数组，同一个数组中所有元素必须为同一个类型，有几个常见的属性：

• ndim 维度
• shape 形状
• size 总个数
• dtype 类型

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)
print('矩阵的维度：', arr.ndim)
print('矩阵的形状：', arr.shape)
print('矩阵的总个数：', arr.size)
print('矩阵的类型：', arr.dtype)

[[1 2 3]
 [4 5 6]]
矩阵的维度： 2
矩阵的形状： (2, 3)
矩阵的总个数： 6
矩阵的类型： int32

numpy 矩阵的特点

umpy中的矩阵也有与数组常见的几个属性

转换关系

# 列表
li = [[1, 2, 3], [4, 5, 6]]
# 列表 => 数组
arr = np.array(li)
# 列表 => 矩阵
mat = np.mat(arr)
# 矩阵 => 数组
arr2 = np.array(mat)
# 矩阵 => 列表
li2 = mat.tolist()
# 数组 => 列表
li3 = arr.tolist()
print(type(li))
print(type(arr))
print(type(mat))
print(type(arr2))
print(type(li2))
print(type(li3))

1
<class 'list'>
<class 'numpy.ndarray'>
<class 'numpy.matrix'>
<class 'numpy.ndarray'>
<class 'list'>
<class 'list'>

matrix.getA()

getA()是numpy的一个函数，作用是将矩阵转成一个ndarray，getA()函数和mat()函数的功能相反，是将一个矩阵转化为数组。
如果不转，矩阵的每个元素将无法取出，会造成越界的问题，其具体解释如下：

X = np.matrix(np.arange(12).reshape(3, 4))
print(X)
print(type(X))
print(X.getA())
print(type(X.getA()))
print(X[0, 0]) # 获取matrix类型的一个值，只能使用 [x, y]的形式，而不能使用[x][y]
print(X[0][0])
print(X.getA()[0][0]) # 转换为 ndarray 类型后，就可以直接获取值，通过[x][y]

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
<class 'numpy.matrix'>
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
<class 'numpy.ndarray'>
0
[[0 1 2 3]]
0

矩阵的切片

行操作

a = [[1,2],[3,4],[5,6],[7, 8]]
a = np.mat(a)
# 打印整个矩阵
print('整个矩阵：')
print(a[0:])
print('从第二行开始打印：')
print(a[1:])
print('从第二行到第三行：')
print(a[1:3])

整个矩阵：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
从第二行开始打印：
[[3 4]
 [5 6]
 [7 8]]
从第二行到第三行：
[[3 4]
 [5 6]]

列操作

a = [[1,2],[3,4],[5,6],[7, 8]]
a = np.mat(a)
print('打印第一列：')
print(a[:, 0])
print('打印第二行到第三行的第二列：')
print(a[1:3, 1])

打印第一列：
[[1]
 [3]
 [5]
 [7]]
打印第二行到第三行的第二列：
[[4]
 [6]]

数据类型的转换 astype dtype

arr = np.array([1, 2, 3, 4, 5])
print(arr)
# 查看数据类型
print('数组的数据类型为：', arr.dtype)
# int32 => int64
arr2 = arr.astype('int64')
print('int32=>int64：', arr2.dtype)
# int32 => float
arr3 = arr.astype('float')
print('int32=>float64', arr3.dtype)

[1 2 3 4 5]
数组的数据类型为： int32
int32=>int64： int64
数组的数据类型为： int32
int32=>float64 float64

字符串转换为数值类型

strArr = np.array(['1.2','2.3','3.2141'])
print(strArr)
numArr = strArr.astype('float')
print('string => float：', numArr)

['1.2' '2.3' '3.2141']
string => float： [1.2    2.3    3.2141]