一、Matrix和Array

Matrix名为矩阵，Array名为阵列，它们都可以作为矩阵运算的结构，功能上Matrix是Array的子集，Matrix运算符相较于Array简单。

二、Matrix和Array的相互转换

import numpy as np
a = [1, 2, 3]
b = [2, 3, 4]
c = [[1], [2], [3]]
 
print(type(a),type(b),type(c))  # list
print(np.mat(a))  # [[1 2 3]]
print(type(np.mat(a)))  # matrix:注意是二维
print(np.array(a))  # [1 2 3]
print(type(np.array(a)))  # ndarray
print(type(np.mat(np.array(a)))) #matrix
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.

<class 'list'> <class 'list'> <class 'list'>

[[1 2 3]]

<class 'numpy.matrix'>

[1 2 3]

<class 'numpy.ndarray'>

<class 'numpy.matrix'>

三、矩阵乘法--multiply()、dot()、 matmul()、' * '、'@'辨析

注意：所有的一维向单独看时，都当成是列向量（竖着放的），虽然打印的时候是横着放！！！

元素相乘:multply()
矩阵相乘:dot()、matmul()、’@’
’ * ': 在数组操作中，作为元素相乘；在矩阵操作中作为矩阵相乘

在数组Array上操作

import numpy as np
a1 = np.array([[1,2,3],[4,5,6]])
b1 = np.array([1,2,3])
a2 = np.array([1,2,3])
b2 = np.array([1,2,3])
 
print(' * 在数组操作中，作为元素相乘{}'.format(a1 * b1)) # 对应元素相乘
""" [[ 1  4  9]
 [ 4 10 18]] """
print(' @ 在数组操作中，作为矩阵相乘{}'.format(a1 @ b1)) #　矩阵相乘
""" [14 32] """
 
 
print(' * 在数组操作中，作为元素相乘{}'.format(a2 * b2)) # 对应元素相乘
a2 * b2 #　对应元素相乘
""" [1 4 9] """
print(' @ 在数组操作中，作为矩阵相乘{}'.format(a2 @ b2)) #　矩阵相乘
 
""" 14 """
print(' multiply 在数组操作中，作为元素相乘{},{}'.format(np.multiply(a1, b1), np.multiply(a2, b2))) # 对应元素相乘
 # 对应元素相乘
""" (array([[ 1,  4,  9],
        [ 4, 10, 18]]), array([1, 4, 9])) """
print(' dot在数组操作中，作为矩阵相乘{},{}'.format(np.dot(a1, b1), np.dot(a2, b2) )) #　矩阵相乘
 
""" (array([14, 32]), 14) """
print(' matmul在数组操作中，作为矩阵相乘{},{}'.format(np.matmul(a1, b1), np.matmul(a2, b2) )) #　矩阵相乘
 
""" (array([14, 32]), 14) """
""" (array([14, 32]), 14) """
  • 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.

* 在数组操作中，作为元素相乘[[ 1  4  9]

[ 4 10 18]]

@ 在数组操作中，作为矩阵相乘[14 32]

* 在数组操作中，作为元素相乘[1 4 9]

@ 在数组操作中，作为矩阵相乘14

multiply 在数组操作中，作为元素相乘[[ 1  4  9]

[ 4 10 18]],[1 4 9]

dot在数组操作中，作为矩阵相乘[14 32],14

matmul在数组操作中，作为矩阵相乘[14 32],14

在矩阵上操作

import numpy as np
a3 = np.matrix([[1,2,3],[4,5,6]])
b3_1 = np.matrix([1,2,3])
b3 = np.matrix([[1],[2],[3]])
 

print('  * 在矩阵上操作中{}'.format(a3 * b3 )) #　矩阵相乘
""" a3 * b3  
[[14]
 [32]] """
print(' @ 在矩阵上操作中{}'.format(a3 @ b3 )) #　矩阵相乘
""" a3 @ b3 # 矩阵相乘
[[14]
 [32]] """

print(' multiply 在矩阵上操作中,对应元素相乘{}'.format(np.multiply(a3,b3_1) )) #对应元素相乘
""" np.multiply(a3,b3_1) # 对应元素相乘
matrix([[ 1,  4,  9],
        [ 4, 10, 18]]) """
 
print(' dot 在矩阵上操作中,对矩阵相乘{}'.format(np.dot(a3, b3)  )) #矩阵相乘
""" np.dot(a3, b3) # 矩阵相乘
matrix([[14],
        [32]]) """
print(' matmul 在矩阵上操作中,对矩阵相乘{}'.format(np.dot(a3, b3)  )) #矩阵相乘
  • 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.


 * 在矩阵上操作中[[14]

[32]]

@ 在矩阵上操作中[[14]

[32]]

multiply 在矩阵上操作中,对应元素相乘[[ 1  4  9]

[ 4 10 18]]

dot 在矩阵上操作中,对矩阵相乘[[14]

[32]]

matmul 在矩阵上操作中,对矩阵相乘[[14]

[32]]

四、矩阵的转置和逆

关键点：注意矩阵是否可逆

import numpy as np
a = [1, 2, 3]
b = [2, 3, 4]
c = [[5], [4], [9]]

# 转置
print('Matrix转置{}'.format(np.mat(a).T))
print('Array的转置{}'.format(np.array(a).T))
 
print('Matrix转置{}'.format(np.mat(c).T))
print('Array的转置{}'.format(np.array(c).T))
 
# Matrix的逆为：
A = [[1, 2], [3, 4]]
print('Matrix的逆为{}'.format(np.mat(A).I))
# Array的逆为：
print('Array的逆为{}'.format(np.linalg.inv(A)) )
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.

Matrix转置[[1]

[2]

[3]]

Array的转置[1 2 3]

Matrix转置[[5 4 9]]

Array的转置[[5 4 9]]

Matrix的逆为[[-2.   1. ]

[ 1.5 -0.5]]

Array的逆为[[-2.   1. ]

[ 1.5 -0.5]]

五、关于shape和一维向量

例如：a,b的shape为 (3, )，计算 a*b

关键就在这一步的转换，此处有两个向量相乘，那么：

谁在左边，就在左边添加维度1：,a 在左，那么 a 的 shape 运算时为 （1，3）
谁在右边，就在右边添加维度1：,b 在右，那么 b 的 shape 运算时为 （3，1）

a = np.array([[1, 2, 3], [4, 5, 6]])  # (2, 3)
b = np.array([1, 2, 3]) # (3,)
print(a.dot(b))  # [14 32]            （2，3）* （3，1） -> (2,1)
print(np.matmul(a, b))  # [14 32]     （2，3）* （3，1） -> (2,1)
 
# 如果是 b.dot(a)
# b 在左， （1， 3） * （2， 3）  报错
# 如果把 a 换成 （3，2），就可以运算
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.