python numpy数组转置和矩阵乘法

末尾有福利（手动滑稽~）

一.转置

数组转置

1.使用 array.T:

1.对于array对象，若是一维数组（行向量），array.T并不会把行向量转化成列向量，见下：

import numpy as np

A=np.array([0,1,2,3])
print("A: "+str(A))
print("A转置后："+str(A.T))

B=np.array([[0,1,2,3],[4,5,6,7]])
print("B: "+str(B))
print("B转置后："+str(B.T))

输出结果：

A: [0 1 2 3]
A转置后：[0 1 2 3]
B: [[0 1 2 3]
[4 5 6 7]]
B转置后：[[0 4]
[1 5]
[2 6]
[3 7]]

2.对于matrix对象，行向量使用.T可以转化成列向量

import numpy as np
C=np.matrix([0,1,2,3])
print("C: "+str(C))
print("C转置后："+str(C.T))
D=np.array([[0,1,2,3],[4,5,6,7]])
print("D: "+str(D))
print("D转置后："+str(D.T))

输出结果：

C: [[0 1 2 3]]
C转置后：[[0]
[1]
[2]
[3]]
D: [[0 1 2 3]
[4 5 6 7]]
D转置后：[[0 4]
[1 5]
[2 6]
[3 7]]

3.对于高维数组的转置：
首先是理解：对于二维数组，转置意味着行列下标互换，也就是
变成了，同理，对于三维数组，转置的方法也是让下标互换，但是这种互换方法就不止一种了，使用array.T方法的话，默认是这种互换：i,j,kj,k,i(就是向后推一位，最后一位变成第一位),见下：

B=np.array([[[0,1,2,3],
             [4,5,6,7]],
            [[8,9,10,11],
            [12,13,14,15]]])
print("B: "+str(B))
print("B转置后："+str(B.T))

比如上面元素1的下标是(0,0,1)按照如上转置后，下标变成（0,1,0）
输出如下：

B: [[[ 0 1 2 3]
[ 4 5 6 7]]

[[ 8 9 10 11]
[12 13 14 15]]]
B转置后：[[[ 0 8]
[ 4 12]]

[[ 1 9]
[ 5 13]]

[[ 2 10]
[ 6 14]]

[[ 3 11]
[ 7 15]]]

2.使用array.transpose()方法

首先是参数介绍，如果理解了上面高维数组的转置方法，这个就好理解了，在上面的高维数组中用array.T是这种方式：i,j,kj,k,i 。显然，我们还可以i,j,kk,i,j
array.transpose()方法就是帮助我们这样做的：
如果参数这样写：array.transpose((0,1,2))，那么数组不变（因为下标没变，(0,1,2)与(i,j,k)相对应），
如果参数写成（0,2,1）那么对应的是i,j,ki,k,j
以此类推
见下：

import numpy as np
B=np.array([[[0,1,2,3],
             [4,5,6,7]],
            [[8,9,10,11],
            [12,13,14,15]]])
print("B: "+str(B))
print("transpose后："+str(B.transpose((0,2,1))))

比如6的初始下标是（0,1,2）,transpose后下标应该是（0,2,1）
输出如下：

B: [[[ 0 1 2 3]
[ 4 5 6 7]]

[[ 8 9 10 11]
[12 13 14 15]]]
transpose后：[[[ 0 4]
[ 1 5]
[ 2 6]
[ 3 7]]

[[ 8 12]
[ 9 13]
[10 14]
[11 15]]]

再举个四维数组试一下：

import numpy as np
B=np.array([
            [[[0,1,2],
            [3,4,5]],
            [[6,7,8],
            [9,10,11]]],

            [[[12, 13, 14],
              [15, 16, 17]],
             [[18, 19, 20],
              [21, 22, 23]]],
            ])
print("B: "+str(B))
print("transpose后："+str(B.transpose((3,0,2,1))))

比如17初始下标是(1,0,1,2)，transpose后下标应该是（2,1,1,0）
输出如下：

B: [[[[ 0  1  2]
   [ 3  4  5]]

  [[ 6  7  8]
   [ 9 10 11]]]


 [[[12 13 14]
   [15 16 17]]

  [[18 19 20]
   [21 22 23]]]]
transpose后：[[[[ 0  6]
   [ 3  9]]

  [[12 18]
   [15 21]]]


 [[[ 1  7]
   [ 4 10]]

  [[13 19]
   [16 22]]]


 [[[ 2  8]
   [ 5 11]]

  [[14 20]
   [17 23]]]]

当然array.transpose()方法也支持二维的数组：

import numpy as np
B=np.array([[0,1,2,3],[4,5,6,7]])
print("B: "+str(B))
print("B转置后："+str(B.transpose(0,1)))

输出：

B: [[0 1 2 3]
[4 5 6 7]]
B转置后：[[0 1 2 3]
[4 5 6 7]]

也可以对matrix使用transpose()方法，只需要注意matrix最多只能是二维即可，规则和上面的一样。

二.矩阵乘法

矩阵乘法

1.使用运算符 *

• 对于array来说是对应位置相乘（点乘）（下面代码对C或D用转置会报错）

import numpy as np

A=np.array([0,1,2,3])
B=np.array([2,3,4,5])
print("A*B: "+str(A*B))

C=np.array([[0,1,2,3],[4,5,6,7]])
D=np.array([[2,3,4,5],[6,7,8,9]])
print("C*D: "+str(C*D))

输出结果：

A*B: [ 0 3 8 15]
C*D: [[ 0 3 8 15]
[24 35 48 63]]

• 对于matrix对象，实施的是矩阵乘法：(下面代码不用转置会报错)

import numpy as np

A=np.matrix([0,1,2,3])
B=np.matrix([2,3,4,5]).T
print("A*B.T: "+str(A*B))

C=np.matrix([[0,1,2,3],[4,5,6,7]])
D=np.matrix([[2,3,4,5],[6,7,8,9]]).T
print("C*D.T: "+str(C*D))

输出结果：

A*B.T: [[26]]
C*D.T: [[ 26 50]
[ 82 170]]

2.使用numpy.multiply()方法

• 对于array来说是对应位置相乘（点乘）（下面代码对C或D用转置会报错）

import numpy as np

A=np.array([0,1,2,3])
B=np.array([2,3,4,5])
print("A*B: "+str(np.multiply(A,B)))

C=np.array([[0,1,2,3],[4,5,6,7]])
D=np.array([[2,3,4,5],[6,7,8,9]])
print("C*D: "+str(np.multiply(C,D)))

输出结果：

A*B: [ 0 3 8 15]
C*D: [[ 0 3 8 15]
[24 35 48 63]]

• 对于matrix来说也是对应位置相乘（点乘）（下面代码对C或D用转置会报错）

import numpy as np

A=np.matrix([0,1,2,3])
B=np.matrix([2,3,4,5])
print("A*B: "+str(np.multiply(A,B)))

C=np.matrix([[0,1,2,3],[4,5,6,7]])
D=np.matrix([[2,3,4,5],[6,7,8,9]])
print("C*D: "+str(np.multiply(C,D)))

输出结果：

A*B: [[ 0 3 8 15]]
C*D: [[ 0 3 8 15]
[24 35 48 63]]

3.使用numpy.dot()方法

• 对于array来说是矩阵乘法（下面代码不用转置会报错（一维的不用转置，转了也没用的，原因前面有））

numpy.dot(A,B)等价于A.dot(B)

import numpy as np

A=np.array([0,1,2,3])
B=np.array([2,3,4,5])
print("A*B: "+str(np.dot(A,B)))

C=np.array([[0,1,2,3],[4,5,6,7]])
D=np.array([[2,3,4,5],[6,7,8,9]]).T
print("C*D: "+str(np.dot(C,D)))

输出结果:

A*B: 26
C*D: [[ 26 50]
[ 82 170]]

另外array这里有点小问题，我手动变成列向量，去和行向量相乘，发现会报错，没用得到理想的4x4矩阵

• 对于matrix来说是矩阵乘法（下面代码不用转置会报错（一维的也要转置））

import numpy as np

A=np.matrix([0,1,2,3])
B=np.matrix([2,3,4,5]).T
print("A*B: "+str(np.dot(A,B)))

C=np.matrix([[0,1,2,3],[4,5,6,7]])
D=np.matrix([[2,3,4,5],[6,7,8,9]]).T
print("C*D: "+str(np.dot(C,D)))

输出结果（注意与上面对比，一维的相乘结果还是列表形式）

A*B: [[26]]
C*D: [[ 26 50]
[ 82 170]]

三.一维数组的特例

列向量*行向量:

import numpy as np

A=np.array([0,1,2,3])
B=np.array([[1],[2],[3],[4]])
print("A*B: "+str(B*A))  #A*B的结果一样

输出结果：

A*B: [[ 0 1 2 3]
[ 0 2 4 6]
[ 0 3 6 9]
[ 0 4 8 12]]

这里看似不符合之前的*规则，但是我觉得可以这样理解:
编译器在处理B*A时，把B变成

B:
1 1 1 1
2 2 2 2
3 3 3 3
4 4 4 4

然后把A变成:

A:
0 1 2 3
0 1 2 3
0 1 2 3
0 1 2 3

然后再去点乘得到结果

A*B: [[ 0 1 2 3]
[ 0 2 4 6]
[ 0 3 6 9]
[ 0 4 8 12]]

减法也类似：

import numpy as np

A=np.array([0,1,2,3])
B=np.array([[1],[2],[3],[4]])
print("A-B: "+str(A-B))

输出结果：

A-B: [[-1 0 1 2]
[-2 -1 0 1]
[-3 -2 -1 0]
[-4 -3 -2 -1]]

import numpy as np

A=np.array([0,1,2,3])
B=np.array([[1],[2],[3],[4]])
print("B-A: "+str(B-A))

输出结果：

B-A: [[ 1 0 -1 -2]
[ 2 1 0 -1]
[ 3 2 1 0]
[ 4 3 2 1]]

我的公众号，扫码关注可留言获取想要的计算机资料，公众号定时更新分析技术文章，谢谢关注0.0

1