python 数据处理基础之 numpy 与线性代数

发表于 分类于 ， 阅读次数： ：

1 向量

向量是线性代数的基础，但注意，一维数组不是向量！行向量、列向量都是特殊矩阵，也就是说，行向量、列向量都是二维数组。

比如, 下面代码生成一个长度为15的一维数组。

1
a = numpy.arange(0, 15)

通过 reshape 方法，我们将之转为行向量与列向量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
a = np.arange(0, 6)
print(f"一维数组：{a}")

# 将向量转为行向量
b = np.reshape(a, (1, -1))
print(f"转为行向量：{b}")

# 将向量转为行向量
c = np.reshape(a, (-1, 1))
print(f"转为列向量：{c}")

# output==>
# ---------------------------------------------------------
# 一维数组：[ 0  1  2  3  4  5 ]
# 转为行向量：[[ 0  1  2  3  4  5]]
# 转为列向量：[[ 0]
#  [ 1]
#  [ 2]
#  [ 3]
#  [ 4]
#  [ 5]]

2 矩阵运算

因为 ndarray 运算功能的强大，使得它可以运用于矩阵的运算。更多关于矩阵运算及应用的知识，我们将在后面python 与线性代数的相关学习里提及，这里说些简单的介绍性的。

2.1 矩阵的转置 T

ndarray 有个内置的 T 属性，可以直接返回一个矩阵的转置。

维度的对换！将 34 -> 43

矩阵的转置 T
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
matrix = np.arange(12).reshape(3, 4) # 快速建立一个 3*4 的矩阵
log(matrix)
log(matrix.T)

==>  matrix
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
----------

==>  matrix.T
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

2.2 矩阵的点积

这个也是很简单，直接 np.dot(matrix1, matrix2)

比如这样算一个矩阵的内积，就是矩阵与自己转置的点积 np.dot(matrix.T, matrix)

2.3 轴对换

轴对换主要两个方法：

1
2
ndarray.transpose(tuple)
ndarray.swapaxes()

transpose 参数给出新的轴排序；而 swapaxes，给出要替换的轴位置。

transpose 参数给出新的轴排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
arr = np.arange(24).reshape((2,3,4)) # 创建一个 2*3*4 的 3 维数组
transposeArr = arr.transpose((1,0,2))

==> 原数组
[[[ 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((1,0,2) 之后）
[[[ 0  1  2  3]
[12 13 14 15]]

[[ 4  5  6  7]
[16 17 18 19]]

[[ 8  9 10 11]
[20 21 22 23]]]

上面这个例子怎么理解呢，首先我们要理解“轴”的概念。对于2*3*4的数组，其中 2、3、4 就是它的轴，我们可以解决为此数据有 3 个轴，transpose((1,0,2))中的参数决定了轴的重排序，就是 1、0、2，也就是第 0 轴与第 1 轴换了下位置。所以得出的新数组就应该是3*2*4的数组。

swapaxes表示哪两个轴交换位置，像上面的transpose，其实就是第 0、1 轴交换位置。所以也可以用arr.swapaxes(0, 1)，和transpose((1,0,2))效果是一样的。

1
2
3
# 下面 2 种交换轴方法是一样的
arr.swapaxes(0, 1)
np.swapaxes(arr, 0, 1)

3 linalg 模块

NumPy 库的linalg 模块提供了许多用于线性代数计算的函数