Python 矩阵和 NumPy 数组
- Python中的矩阵：Python没有内置的矩阵类型，但可以使用列表的列表来表示矩阵。例如，
A = [[1, 4, 5], [-5, 8, 9]]可以视为一个2行3列的矩阵。 - NumPy数组简介：NumPy是一个科学计算包，提供了功能强大的多维数组对象。NumPy数组，即
ndarray，是处理矩阵和大型多维数组的优选方式。 - 创建和操作NumPy数组：可以使用多种方法创建NumPy数组，例如通过列表转换或使用
np.zeros、np.ones等函数。NumPy数组支持多种操作，包括矩阵加法、乘法、转置，以及更复杂的数学运算。
矩阵是一种二维数据结构，其中的数字被排列成行和列。例如：
这个矩阵是一个3x4（发音为“三乘四”）矩阵，因为它有3行和4列。
Python 矩阵
Python 没有内置的矩阵类型。但是，我们可以将列表的列表视为矩阵。例如：
A = [[1, 4, 5],
[-5, 8, 9]]
我们可以将这个列表的列表视为一个有2行3列的矩阵。
在继续阅读本文之前，请确保您已了解 Python 列表。
让我们看看如何处理嵌套列表。
A = [[1, 4, 5, 12],
[-5, 8, 9, 0],
[-6, 7, 11, 19]]
print("A =", A)
print("A[1] =", A[1]) # 第2行
print("A[1][2] =", A[1][2]) # 第2行的第3个元素
print("A[0][-1] =", A[0][-1]) # 第1行的最后一个元素
column = []; # 空列表
for row in A:
column.append(row[2])
print("第3列 =", column)
运行程序时，输出将是：
A = [[1, 4, 5, 12], [-5, 8, 9, 0], [-6, 7, 11, 19]]
A[1] = [-5, 8, 9, 0]
A[1][2] = 9
A[0][-1] = 12
第3列 = [5, 9, 11]
以下是使用嵌套列表进行 Python 矩阵相关操作的几个示例。
使用嵌套列表作为矩阵对于简单的计算任务来说是可行的，但是，使用 Python 中的 NumPy 包进行矩阵操作是一种更好的方式。
NumPy 数组
NumPy 是一个用于科学计算的包，它支持功能强大的 N 维数组对象。在使用 NumPy 之前，你需要先安装它。获取更多信息：
- 访问：如何安装 NumPy？
- 如果你使用的是 Windows，下载并安装 Python 的 anaconda 发行版。它包含了 NumPy 和其他一些与数据科学和机器学习相关的包。
安装 NumPy 后，你可以导入并使用它。
NumPy 提供了多维数字数组（实际上是一个对象）。让我们看一个例子：
import numpy as np
a = np.array([1, 2, 3])
print(a) # 输出：[1, 2, 3]
print(type(a)) # 输出：<class 'numpy.ndarray'>
如你所见，NumPy 的数组类称为 ndarray。
如何创建 NumPy 数组？
有几种创建 NumPy 数组的方法。
1. 整数、浮点数和复数的数组
import numpy as np
A = np.array([[1, 2, 3], [3, 4, 5]])
print(A)
A = np.array([[1.1, 2, 3], [3, 4, 5]]) # 浮点数数组
print(A)
A = np.array([[1, 2, 3], [3, 4, 5]], dtype = complex) # 复数数组
print(A)
运行程序时，输出将是：
[[1 2 3]
[3 4 5]]
[[1.1 2. 3. ]
[3. 4. 5. ]]
[[1.+0.j 2.+0.j 3.+0.j]
[3.+0.j 4.+0.j 5.+0.j]]
2. 零和一的数组
import numpy as np
zeors_array = np.zeros( (2, 3) )
print(zeors_array)
'''
输出：
[[0. 0. 0.]
[0. 0. 0.]]
'''
ones_array = np.ones( (1, 5), dtype=np.int32 ) # 指定 dtype
print(ones_array) # 输出：[[1 1 1 1 1]]
这里，我们指定了 dtype 为 32 位（4 字节）。因此，这个数组可以取 -2^31 到 2^31-1 的值。
3. 使用 arange() 和 shape()
import numpy as np
A = np.arange(4)
print('A =', A)
B = np.arange(12).reshape(2, 6)
print('B =', B)
'''
输出：
A = [0 1 2 3]
B = [[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]
'''
了解更多关于创建 NumPy 数组的方法。
矩阵操作
上面，我们给出了三个示例：两个矩阵的加法、两个矩阵的乘法和一个矩阵的转置。我们之前使用嵌套列表来编写这些程序。让我们看看我们如何使用 NumPy 数组完成同样的任务。
两个矩阵的加法
我们使用 + 运算符来添加两个 NumPy 矩阵的对应元素。
import numpy as np
A = np.array([[2, 4], [5, -6]])
B = np.array([[9, -3], [3, 6]])
C = A + B # 元素逐个相加
print(C)
'''
输出：
[[11 1]
[ 8 0]]
'''
两个矩阵的乘法
要乘两个矩阵，我们使用 dot() 方法。了解更多关于 numpy.dot 的工作原理。
注意： * 用于数组乘法（两个数组对应元素的乘法）而不是矩阵乘法。
import numpy as np
A = np.array([[3, 6, 7], [5, -3, 0]])
B = np.array([[1, 1], [2, 1], [3, -3]])
C = A.dot(B)
print(C)
'''
输出：
[[ 36 -12]
[ -1 2]]
'''
一个矩阵的转置
我们使用 numpy.transpose 来计算矩阵的转置。
import numpy as np
A = np.array([[1, 1], [2, 1], [3, -3]])
print(A.transpose())
输出：
[[ 1 2 3]
[ 1 1 -3]]
访问矩阵元素、行和列
访问矩阵元素
类似于列表，我们可以使用索引访问矩阵元素。让我们从一维NumPy数组开始。
import numpy as np
A = np.array([2, 4, 6, 8, 10])
print("A[0] =", A[0]) # 第一个元素
print("A[2] =", A[2]) # 第三个元素
print("A[-1] =", A[-1]) # 最后一个元素
当你运行程序时，输出将是：
A[0] = 2
A[2] = 6
A[-1] = 10
现在，让我们看看如何访问二维数组（基本上是矩阵）的元素。
import numpy as np
A = np.array([[1, 4, 5, 12],
[-5, 8, 9, 0],
[-6, 7, 11, 19]])
# 第一行的第一个元素
print("A[0][0] =", A[0][0])
# 第二行的第三个元素
print("A[1][2] =", A[1][2])
# 最后一行的最后一个元素
print("A[-1][-1] =", A[-1][-1])
当我们运行程序时，输出将是：
A[0][0] = 1
A[1][2] = 9
A[-1][-1] = 19
访问矩阵的行
import numpy as np
A = np.array([[1, 4, 5, 12],
[-5, 8, 9, 0],
[-6, 7, 11, 19]])
print("A[0] =", A[0]) # 第一行
print("A[2] =", A[2]) # 第三行
print("A[-1] =", A[-1]) # 最后一行（在这个案例中是第三行）
当我们运行程序时，输出将是：
A[0] = [1, 4, 5, 12]
A[2] = [-6, 7, 11, 19]
A[-1] = [-6, 7, 11, 19]
访问矩阵的列
import numpy as np
A = np.array([[1, 4, 5, 12],
[-5, 8, 9, 0],
[-6, 7, 11, 19]])
print("A[:,0] =", A[:,0]) # 第一列
print("A[:,3] =", A[:,3]) # 第四列
print("A[:,-1] =", A[:,-1]) # 最后一列（在这个案例中是第四列）
当我们运行程序时，输出将是：
A[:,0] = [1, -5, -6]
A[:,3] = [12, 0, 19]
A[:,-1] = [12, 0, 19]
如果你不知道上面的代码是如何工作的，请阅读本文的矩阵切片部分。
矩阵切片
一维NumPy数组的切片类似于列表。如果你不了解列表的切片是如何工作的，请访问理解Python的切片符号。
让我们看一个例子：
import numpy as np
letters = np.array([1, 3, 5, 7, 9, 7, 5])
# 第三个到第五个元素
print(letters[2:5]) # 输出：[5, 7, 9]
# 第一个到第四个元素
print(letters[:-5]) # 输出：[1, 3]
# 第六个到最后 一个元素
print(letters[5:]) # 输出：[7, 5]
# 第一个到最后一个元素
print(letters[:]) # 输出：[1,
3, 5, 7, 9, 7, 5]
# 反转列表
print(letters[::-1]) # 输出：[5, 7, 9, 7, 5, 3, 1]
现在，让我们看看如何切割矩阵。
import numpy as np
A = np.array([[1, 4, 5, 12, 14],
[-5, 8, 9, 0, 17],
[-6, 7, 11, 19, 21]])
print(A[:2, :4]) # 两行，四列
''' 输出：
[[1, 4, 5, 12]
[-5, 8, 9, 0]]
'''
print(A[:1,]) # 第一行，所有列
''' 输出：
[[1, 4, 5, 12, 14]]
'''
print(A[:,2]) # 所有行，第二列
''' 输出：
[5, 9, 11]
'''
print(A[:, 2:5]) # 所有行，第三列到第五列
'''输出：
[[5, 12, 14]
[9, 0, 17]
[11, 19, 21]]
'''
正如你所看到的，使用NumPy（而不是嵌套列表）使得处理矩阵变得更加容易，而且我们甚至还只是触及了基础。如果你试图使用Python进行数据科学/分析，我们建议你详细探索NumPy包。
你可能会觉得有用的NumPy资源：