Python之Numpy库（5）

1、矩阵常用操作

a = np.arange(3)
print(a)
print(np.exp(a)) #e的a次幂
print(np.sqrt(a)) #对a开平方根

#运行结果：
[0 1 2]
[1.         2.71828183 7.3890561 ]
[0.         1.         1.41421356]

上述代码中，np.exp()表示数学中e的多少次幂，sqrt()表示开平方根。

接下来，试试其他的一些操作：

a = np.floor(10*np.random.random((3, 4)))
print(a)

#运行结果：
[[8. 2. 4. 2.]
 [5. 7. 0. 3.]
 [3. 0. 2. 8.]]

其中，floor()表示向下取整。我们再做一些其他的操作：

print(a.ravel())

#运行结果：
8. 2. 4. 2. 5. 7. 0. 3. 3. 0. 2. 8.]

a.ravel()表示将矩阵拉回成一个向量。

接下来，我们把这个向量再转换成一个6行2列的矩阵：

a.shape = (6, 2)
print(a)

#运行结果：
[[8. 2.]
 [4. 2.]
 [5. 7.]
 [0. 3.]
 [3. 0.]
 [2. 8.]]

嗯，效果不错~

接下来，进行行和列的相互置换：

print(a.T)

#运行结果：
[[8. 4. 5. 0. 3. 2.]
 [2. 2. 7. 3. 0. 8.]]

可以看到，使用a.T方法后，之前的第1列变为了第1行，第2列变为了第2行。

需要注意的是，我们在使用reshape()方法指定维度的时候，可以传入负数。比如1个向量中元素为20，我们希望将其分为4行5列的矩阵，可以进行如下操作：

a = np.arange(20)
a = a.reshape(4, -1)
print(a)

#运行结果：
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]

我们只要声明分为4行，行数写作-1，由电脑来计算每行几列。

需要注意的是，行和列的乘积要等于元素个数，不然系统报错。

 

2、矩阵的拼接操作

首先，我们先获得2个矩阵：

a = np.floor(10*np.random.random((2, 2)))
b = np.floor(10*np.random.random((2, 2)))
print(a)
print('-----')
print(b)

#运行结果：
[[1. 0.]
 [2. 4.]]
-----
[[7. 7.]
 [4. 7.]]

这里需要注意的是，不可以写成：

a, b = np.floor(10*np.random.random((2, 2)))

否则，a和b变成了这个矩阵的第1行和第2行。

有点绕远了，我们接着说矩阵的拼接……

print(np.hstack((a, b)))

#运行结果：
[[1. 0. 7. 7.]
 [2. 4. 4. 7.]]

可以看到，通过hstack()函数进行叠加，将a和b两个矩阵横着拼起来了。

可以横着拼，也肯定可以竖着拼：

print(np.vstack((a, b)))

#运行结果：
[[1. 0.]
 [2. 4.]
 [7. 7.]
 [4. 7.]]

可以看到，通过vstack()函数，将a和b两个矩阵竖着拼起来了。

 

3、矩阵的拆分

话说，有和必有分。可以拼接，也肯定可以拆分的，对不对？

首先，我们先获取一个2行12列的矩阵：

a = np.floor(10*np.random.random((2, 12)))
print(a)

#运行结果：
[[0. 1. 5. 2. 2. 7. 3. 4. 7. 6. 2. 7.]
 [4. 7. 5. 6. 2. 5. 9. 3. 7. 3. 3. 1.]]

然后，我们按照行进行拆分：

print(np.hsplit(a, 3))

#运行结果：
[array([[0., 1., 5., 2.],
       [4., 7., 5., 6.]]), array([[2., 7., 3., 4.],
       [2., 5., 9., 3.]]), array([[7., 6., 2., 7.],
       [7., 3., 3., 1.]])]

我们通过hsplit()函数，成功将a矩阵平均拆分成了3个矩阵，得到的是三个2行4列的矩阵。

那么，我们可不可以在指定的位置进行拆分呢？答案是可以的：

print(np.hsplit(a, (3, 4)))

#运行结果：
[array([[0., 1., 5.],
       [4., 7., 5.]]), array([[2.],
       [6.]]), array([[2., 7., 3., 4., 7., 6., 2., 7.],
       [2., 5., 9., 3., 7., 3., 3., 1.]])]

其中，3和4代表的意思是，在最初a矩阵的2行中，在每一行索引为3的位置进行一次拆分，然后在索引为4的地方再拆分一次。

有横着拆分，也必然有竖着拆分。首先我们获取一个12*2的矩阵：

a = np.floor(10*np.random.random((12, 2)))

#运行结果：
[[6. 0.]
 [9. 9.]
 [3. 8.]
 [9. 0.]
 [2. 4.]
 [8. 0.]
 [1. 4.]
 [4. 6.]
 [3. 2.]
 [8. 9.]
 [3. 7.]
 [1. 3.]]

接下来，我们对这个矩阵进行拆分：

print(np.vsplit(a, 3))

#运行结果：
[array([[6., 0.],
       [9., 9.],
       [3., 8.],
       [9., 0.]]), array([[2., 4.],
       [8., 0.],
       [1., 4.],
       [4., 6.]]), array([[3., 2.],
       [8., 9.],
       [3., 7.],
       [1., 3.]])]

可以看出来，我们对这个矩阵平均拆成了3份。