numpy中二维矩阵与一维数组的点乘和乘法

第一次写博客，多多关照。

import numpy as np
#当二维矩阵为p*p维

#创建2*2的二维矩阵
a_22 = np.array([[1,2],[3,4]]) #(2,2)
print("a_22：", a_22)
print("a_22的形状：", a_22.shape)
print("a_22的维度：", a_22.ndim) #2

print("-"*180)

#创建一维数组
b_2 = np.array([1,2]) #(2,)
print("b_2：", b_2)
print("b_2的形状：", b_2.shape)
print("b_2的维度：", b_2.ndim) #1

print("-"*180)

#二维矩阵与一维数组点乘/一维数组与二维矩阵点乘：a_22 · b_2/b_2 · a_22
print("a_22点乘b_2的结果：", np.dot(a_22,b_2))  #[ 5 11] #5=1*1+2*2,11=3*1+4*2，此时b_2被看成了2×1的矩阵
print("a_22点乘b_2.T的结果：", np.dot(a_22,b_2.T)) #[ 5 11]
print("b_2点乘a_22的结果：", np.dot(b_2,a_22))  #[ 7 10] 7=1*1+2*3,10=1*2+2*4，此时b_2被看成了1×2的矩阵
print("b_2.T点乘a_22的结果：", np.dot(b_2.T,a_22)) #[ 7 10]
                                                                # #从结果来看，一维数组的转置不影响点乘的结果，但是二维矩阵和一维数组的位置会影响点乘的结果
                                                                #当一维数组在右边时，不论是否转置，会默认变成p行1列的矩阵，即p*1
                                                                #当一维数组在左边时，不论是否转置，会默认变成1行p列的矩阵，即1*p
                                                                #不管b进行.T运算与否，b被看成什么样子完全由乘法的顺序和a的形状决定
print("-"*180)

##二维矩阵与一维数组相乘/一维数组与二维矩阵相乘：a_22 * b_2/b_2 * a_22
print("a_22乘b_2的结果：\n", a_22 * b_2)
print("a_22乘b_2.T的结果：\n", a_22 * b_2.T)
print("b_2乘a_22的结果：\n", b_2 * a_22)
print("b_2.T乘a_22的结果：\n", b_2.T * a_22)  #从结果来看，一维数组的转置不影响相乘的结果，且二维矩阵和一维数组的位置不会影响相乘的结果
                                             #相乘的结果的形状为2维方阵的形状，即p*p

print("以上都是二维矩阵为p*p类型的，即为方阵类型的与一维数组的点乘和相乘的结果" + "="*180)
print("\n\n\n")

#当二维矩阵为m*n维
#创建2*3的二维矩阵
a_23 = np.array([[1,2,3],[4,5,6]]) #(2,3)
print("a_23：", a_23)
print("a_23的形状：", a_23.shape)
print("a_23的维度：", a_23.ndim) #2

print("-"*180)

#创建一维数组
b_3 = np.array([1,2,3]) #(3,)
print("b_3：", b_3)
print("b_3的形状：", b_3.shape)
print("b_3的维度：", b_3.ndim)

print("-"*180)

#二维矩阵与一维数组点乘/一维数组与二维矩阵点乘：a_23 · b_3(√)/b_3 · a_23(报错)
print("a_23点乘b_3的结果：", np.dot(a_23,b_3))
print("a_23点乘b_3.T的结果：", np.dot(a_23,b_3.T))
#print("b_3点乘a_23的结果：", np.dot(b_3,a_23)) #报错
#print("b_3.T点乘a_23的结果：", np.dot(b_3.T,a_23)) #报错
                                                        #从结果来看，一维数组的转置不影响点乘的结果，但是二维矩阵和一维数组的位置会影响点乘的结果
                                                        #当一维数组的shape[0] == 二维矩阵的shape[0]时，只有一维数组在左边才能和二维矩阵点乘
                                                        #当一维数组的shape[0] == 二维矩阵的shape[1]时，只有一维数组在右边才能和二维矩阵点乘

print("-"*180)

#二维矩阵与一维数组相乘/一维数组与二维矩阵相乘：a_23 * b_3/b_3 * a_23
print("a_23乘b_3的结果：\n", a_23 * b_3)
print("a_23乘b_3.T的结果：\n", a_23 * b_3.T)
print("b_3乘a_23的结果：\n", b_3 * a_23)
print("b_3.T乘a_23的结果：\n", b_3.T * a_23)            #从结果来看，一维数组的转置不影响相乘的结果，且二维矩阵和一维数组的位置不会影响相乘的结果
                                                       #但上面有一个前提，前提就是一维数组的shape[0] == 二维矩阵的列数，即一维数组的shape[0] == 二维矩阵的shape[1]
# print("a_23乘b_2的结果：\n", a_23 * b_2) #报错
# print("a_23乘b_2.T的结果：\n", a_23 * b_2.T) #报错
# print("b_2乘a_23的结果：\n", b_2 * a_23) #报错
#print("b_2.T乘a_23的结果：\n", b_2.T * a_23) #报错

print("-"*180)

#创建3*2的二维矩阵
a_32 = np.array([[1,2],[3,4],[5,6]]) #(3,2)
print("a_32：", a_32)
print("a_32的形状：", a_32.shape)
print("a_32的维度：", a_32.ndim) #2

print("-"*180)

#二维矩阵与一维数组相乘/一维数组与二维矩阵相乘：a_32 · b_2/b_2 · a_32
print("a_32乘b_2的结果：\n", a_32 * b_2) #√
print("a_32乘b_2.T的结果：\n", a_32 * b_2.T) #√
print("b_2乘a_32的结果：\n", b_2 * a_32) #√
print("b_2.T乘a_32的结果：\n", b_2.T * a_32) #√

#总结：矩阵相乘时，一维数组的shape[0] == 二维矩阵的列数才能相乘，如果都是二维矩阵，那么要求行列必须对应相等，运用的是广播机制

总结：
    矩阵相乘时，一维数组的shape[0] == 二维矩阵的列数才能相乘，如果都是二维矩阵，那么要求行列必须对应相等，运用的是广播机制。
矩阵点乘时:
1.当一维数组与p*p类型二维矩阵点乘时：
当一维数组在右边时，不论是否转置，会默认变成p行1列的矩阵（右边就必须竖着），即p*1，当一维数组在左边时，不论是否转置，会默认变成1行p列的矩阵，即1*p（左边就必须横着）。
2.当一维数组与m*n类型二维矩阵点乘时：
一维数组的shape[0] == 二维矩阵的shape[0]时，只有一维数组在左边才能和二维矩阵点乘,当一维数组的shape[0] == 二维矩阵的shape[1]时，只有一维数组在右边才能和二维矩阵点乘。

小口诀：离谁近，才能点乘，比如(2,)·(2,3)可以，但是(2,3)·(2,)就不行