python中的二维数组与一维数组，矩阵和一维数组之间的运算

一、python中的二维数组和一维数组之间的运算

1、当二维数组为p×p维

a=np.array([[1,2],[3,4]])
print(a.shape)
a
输出：
(2, 2)
array([[1, 2],
       [3, 4]])

b=np.array([1,2])
print(b.shape)
b
输出：
(2,)
array([1, 2])

a.dot(b)
输出：
array([ 5, 11])

b.dot(a)
输出：
array([ 7, 10])

a.dot(b.T)
输出：
array([ 5, 11])

b.T.dot(a)
输出：
array([ 7, 10])

b*a
输出：
array([[1, 4],
       [3, 8]])

a*b
输出：
array([[1, 4],
       [3, 8]])

a*b.T
输出：
array([[1, 4],
       [3, 8]])

b.T*a
输出：
array([[1, 4],
       [3, 8]])

2、当二维数组为m×n维 

a=np.array([[1,2],[3,4],[5,6]])
print(a.shape)
a
输出：
(3, 2)
matrix([[1, 2],
        [3, 4],
        [5, 6]])

b=np.array([1,2,3])
print(b.shape)
b
输出：
(3,)
array([1, 2, 3])

c=np.array([1,2])
print(c.shape)
c
输出：
(2,)
array([1, 2])

a.dot(b) #报错，此时维度对不上了
a.dot(c)
输出：
matrix([[ 5, 11, 17]]) 
a.dot(c.T)
输出：
matrix([[ 5, 11, 17]])
#5=1*1+2*2，11=3*1+4*2，17=5*1+6*2，不管c进行.T运算与否，此时c都被看成了2×1的矩阵

b.dot(a)
输出：
matrix([[22, 28]])
b.T.dot(a)
输出：
matrix([[22, 28]])
#22=1*1+2*3+3*5,28=1*2+2*4+3*6=28，不管b进行.T运算与否，此时b都被看成了1×3的矩阵
c.dot(a) #报错，此时维度对不上了 

a*b #报错
a*c
输出：
array([[ 1,  4],
       [ 3,  8],
       [ 5, 12]])

总结：

设二维矩阵为p×p维

在用numpy进行科学计算时，一维数组在二维数组的左右都可以通过dot方法与np.dot进行矩阵乘法运算，但是在左右两边的计算结果不一样的，不管转置与否，在右边一维数组被看成p×1维，在左边一维数组被看成1×p维.

在用*进行运算时，是对应元素相乘，不管一维数组转置与否，都是对应行元素相乘。

二、python中的矩阵和一维数组之间的运算

1、当矩阵为方阵(p×p维)

a=np.matrix(np.array([[1,2],[3,4]]))
print(a.shape)
a
输出：
(2, 2)
matrix([[1, 2],
        [3, 4]])

#使用dot
b=np.array([1,2])
print(b.shape)
b
输出：
(2,)
array([1, 2])

a.dot(b)
输出：
matrix([[ 5, 11]]) #5=1*1+2*2,11=3*1+4*2，此时b被看成了2×1的矩阵

np.dot(a,b)
输出：
matrix([[ 5, 11]]) #5=1*1+2*2,11=3*1+4*2，此时b被看成了2×1的矩阵

b.dot(a)
输出：
matrix([[ 7, 10]]) #7=1*1+2*3,10=1*2+2*4，此时b被看成了1×2的矩阵

np.dot(b,a)
输出：
matrix([[ 7, 10]]) #7=1*1+2*3,10=1*2+2*4，此时b被看成了1×2的矩阵

a.dot(b.T)
输出：
matrix([[ 5, 11]]) 

b.T.dot(a)
matrix([[ 7, 10]])
#不管b进行.T运算与否，b被看成什么样子完全由乘法的顺序和a的形状决定

#使用*
b*a
输出：
matrix([[ 7, 10]])

a*b #报错了
a*b.T #报错了

np.matrix(b)
输出：
matrix([[1, 2]])
#如果用*的话，不管b进行.T运算与否，做乘法时，b是被看成了1×2的矩阵

a*np.matrix(b).T
输出：
matrix([[ 5],
        [11]])

 总结：

设矩阵为p×p维

在用numpy进行科学计算时，一维数组在矩阵的左右都可以通过dot方法与np.dot进行矩阵乘法运算，但是在左右两边的计算结果不一样的，不管转置与否，在右边一维数组被看成p×1维，在左边一维数组被看成1×p维.

在用*进行运算时，不管一维数组进行.T运算与否，一维数组与矩阵进行乘法运算时会被看做行向量1×p维，除非将一维数组转换为一维矩阵就可以进行.T运算变为p×1维.

2、当矩阵为普通矩阵(m×n维)

a=np.matrix(np.array([[1,2],[3,4],[5,6]]))
print(a.shape)
a
输出：
(3, 2)
matrix([[1, 2],
        [3, 4],
        [5, 6]])

b=np.array([1,2,3])
print(b.shape)
b
输出：
(3,)
array([1, 2, 3])

c=np.array([1,2])
print(c.shape)
c
输出：
(2,)
array([1, 2])

a.dot(b) #报错，此时维度对不上了
a.dot(c)
输出：
matrix([[ 5, 11, 17]]) 
a.dot(c.T)
输出：
matrix([[ 5, 11, 17]])
#5=1*1+2*2，11=3*1+4*2，17=5*1+6*2，不管c进行.T运算与否，此时c都被看成了2×1的矩阵

b.dot(a)
输出：
matrix([[22, 28]])
b.T.dot(a)
输出：
matrix([[22, 28]])
#22=1*1+2*3+3*5,28=1*2+2*4+3*6=28，不管b进行.T运算与否，此时b都被看成了1×3的矩阵
c.dot(a) #报错，此时维度对不上了 

b*a
输出：
matrix([[22, 28]])
(b.T)*a
输出：
matrix([[22, 28]])

np.matrix(b)
输出：
matrix([[1, 2, 3]])
#不管b进行.T运算与否，此时b都被看成了1×3的矩阵

总结：

设矩阵为m×n维

在用numpy进行科学计算时，若一维数组内有m个数，此时只能在矩阵的左边通过dot方法进行矩阵乘法运算，不管一维数组进行.T运算与否，此时一维数组被看成了1×m维的矩阵.若数组内有n个数，此时只能在矩阵的右边通过dot方法进行矩阵乘法运算，不管一维数组进行.T运算与否，此时数组被看成了n×1维的矩阵.

在用*进行运算时，一维数组与矩阵进行运算时，不管一维数组进行.T运算与否，一维数组都会被看做行向量1×m或1×n维的矩阵.