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]]"""

你可能感兴趣的:(python语法,python,机器学习)