python语法之array类型的加减乘

array类型的加减法：

python numpy中的矩阵、向量的加减乘除_Amy_mm的博客-CSDN博客_numpy矩阵减向量

当numpy数据类型的矩阵相加减时，遵守的规则：

1.如果矩阵是相同维度的，就直接相对应位置相加减，比如a-c。

2.如果矩阵维度不相同，但如果这两个矩阵满足以下两个条件中的一个：

a. 一个是行向量一个是列向量，行向量：1m，列向量：n1，那么python会把行向量自动扩充自n*m，每一行都是行向量的复制；
把每一个列向量扩充自nm，增加的每一列都是列向量的复制，如a-b。

b.一个多维矩阵，一个一维矩阵，将一维向量扩充至多维向量的维度，然后相加减，如a-b。如果一维向量的行或者列不等于多维向量的行或者列，则会报错。

import numpy as np

a = np.array([1,2,3,4]) #(4,)

b = np.array([2,3,4,5]).reshape(4,1) #(4, 1)

c = np.array([2,3,4,5]) #(4,)

d = np.array([1,2,3,4,5,6,7,8,9,10,11,12]).reshape(3,4) #(3,4)

print(a-b)
"""[[-1  0  1  2]
 [-2 -1  0  1]
 [-3 -2 -1  0]
 [-4 -3 -2 -1]]"""

print(a-c)
#[-1 -1 -1 -1]

print(a-d)
"""[[ 0  0  0  0]
 [-4 -4 -4 -4]
 [-8 -8 -8 -8]]"""

array类型的乘法

numpy中向量和矩阵相关乘法总结_fate252的博客-CSDN博客_numpy 向量乘法

乘法的三种实现：

**对位乘积：**两个矩阵shape相同，各元素对应相乘，结果是一个相同shape的矩阵

**矩阵乘法：**数学上的矩阵乘法，结果是一个矩阵

**向量内积：**对应元素相乘，再相加，结果是一个数值

乘法符号：（1,2,3）效果一样

1. a@b

2. numpy.dot(a,b)

3. numpy.matmul(a,b)

4. numpy.multiply(a,b)

5. a*b

对于1,2,3而言，分四种情况：

(a) 两个都是一维数组，且都是行向量，进行向量内积运算，得到一个数值

a = np.array([1,2,3,4]) #(4,)
c = np.array([2,3,4,5]) #(4,)

#-----------------------------------------------------------------------------------------
print(a@c) #40 向量内积得到一个数值
print(np.dot(a,c)) #40 向量内积得到一个数值
print(np.matmul(a,c)) #40 向量内积得到一个数值

(b)当一个是多维数组，一个是一维数组时，若一维数组在前面，则匹配矩阵乘法

a = np.array([1,2,3,4]) #(4,)
d = np.array([1,2,3,4,5,6,7,8,9,10,11,12]).reshape(3,4) #(3,4)
"""[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]"""


#---------------------------------------------------------------------------------------------------
print(a@d.T) #[ 30  70 110]
print(np.dot(a,d.T)) #[ 30  70 110]
print(np.matmul(a,d.T)) #[ 30  70 110]
#会返回矩阵，因为这里的a是1*4，而d.T是4*3


#----------------------------------------------------------------------------------------------------
print(a@d)
np.dot(a,d)
np.matmul(a,d)
#会报错，因为这里的a是1*4，而d是3*4

a = np.array([1,2,3,4]) #(4,)

b = np.array([2,3,4,5]).reshape(4,1) #(4, 1)这里的b不是一维是二维
# [[2]
#  [3]
#  [4]
#  [5]]

#----------------------------------------------------------------------------------------
"""[1,2,3] 矩阵乘 [[4]
                [5]
                [6]]得到一个矩阵[40]"""
print(a@b) #[40]，得到一个矩阵
print(np.dot(a,b)) #[40]，得到一个矩阵
print(np.matmul(a,b)) #[40]，得到一个矩阵

#-------------------------------------------------------------------------------------------
print(b@a)
print(np.dot(b,a))
print(np.matmul(b,a))
#会报错
"""
颠倒顺序后肯定会报错
"""

©当一个是多维数组，一个是一维数组时，若多维数组在前面,则匹配内积分配律,一维数组(矩阵)将依次与多维数组的每一行向量进行内积运算

a = np.array([1,2,3,4]) #(4,)
d = np.array([1,2,3,4,5,6,7,8,9,10,11,12]).reshape(3,4) #(3,4)
"""[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]"""

#---------------------------------------------------------------------------------
print(d@a) #[ 30  70 110]
print(np.dot(d,a)) #[ 30  70 110]
print(np.matmul(d,a)) #[ 30  70 110]

(d)当两个都是多维数组时，进行矩阵乘法

d = np.array([1,2,3,4,5,6,7,8,9,10,11,12]).reshape(3,4)
"""[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]"""

e = np.array ([2,2,2,2,2,2,2,2,2,2,2,2]).reshape(3,4)
"""
[[2 2 2 2]
 [2 2 2 2]
 [2 2 2 2]]
 """


#-----------------------------------------------------------------------------------------------
print(d@e.T)
print(np.dot(d, e.T))
print(np.matmul(d, e.T))
"""
[[20 20 20]
 [52 52 52]
 [84 84 84]]"""


#-----------------------------------------------------------------------------------------------
print(d@e)
print(np.dot(d, e))
print(np.matmul(d, e))
#都报错，因为前一个矩阵的列不等于后一个矩阵的行

对于4,5而言，分三种情况：（不管哪个情况都是对位乘法）

(a) 两个都是一维数组，且都是行向量，进行对位乘积运算，得到一个行向量

a = np.array([1,2,3,4]) #(4,)
c = np.array([2,3,4,5]) #(4,)


#-----------------------------------------------------------------------------------------
print(a*c) #[ 2  6 12 20]
print(np.multiply(a,c)) #[ 2  6 12 20]

(b)当一个是多维数组，一个是一维数组时，不管哪个在前面，都匹配内积分配律,一维数组(矩阵)将依次与多维数组的每一行向量进行内积运算

a = np.array([1,2,3,4]) #(4,)
d = np.array([1,2,3,4,5,6,7,8,9,10,11,12]).reshape(3,4) #(3,4)
"""[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]"""



#---------------------------------------------------------------------------------
print(d * a)
print(a * d)

print(np.multiply(a, d))
print(np.multiply(d,a))
"""
[[ 1  4  9 16]
 [ 5 12 21 32]
 [ 9 20 33 48]]
 """

©当两个都是多维数组时，进行对位乘法

d = np.array([1,2,3,4,5,6,7,8,9,10,11,12]).reshape(3,4)
"""[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]"""

e = np.array ([2,2,2,2,2,2,2,2,2,2,2,2]).reshape(3,4)
"""
[[2 2 2 2]
 [2 2 2 2]
 [2 2 2 2]]
 """


#-----------------------------------------------------------------------------------------------
print(d * e)
print(np.multiply(d, e))
"""[[ 2  4  6  8]
 [10 12 14 16]
 [18 20 22 24]]"""