1.3 Scipy 的基本数据结构与操作

1.3 Scipy 的基本数据结构与操作

1.3 Scipy 的基本数据结构与操作

Scipy 构建在 NumPy 的基础上，并提供了大量用于科学计算的模块。理解 Scipy 的基本数据结构和操作是有效利用该库的关键。虽然 Scipy 主要使用 NumPy 数组作为其基本数据结构，但它还引入了一些专门的数据结构来优化特定类型的计算。

1.3.1 NumPy 数组回顾

在深入 Scipy 的数据结构之前，我们先回顾一下 NumPy 数组，因为它们是 Scipy 的基石。NumPy 数组（ndarray）是一个多维、同质的数组对象，这意味着数组中的所有元素都必须是相同的数据类型。

NumPy 数组的优势：

• 高效存储： NumPy 数组在内存中以连续块的形式存储数据，这使得访问元素非常快。

• 向量化操作： NumPy 允许对整个数组执行操作，而无需显式循环，这大大提高了计算速度。

• 广播： NumPy 能够自动调整不同形状的数组，以便进行算术运算。

创建 NumPy 数组：

import numpy as np
# 从 Python 列表创建数组
arr1 = np.array([1, 2, 3, 4, 5])
print(arr1) # 输出: [1 2 3 4 5]
# 创建一个二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2)
# 输出:
# [[1 2 3]
#  [4 5 6]]
# 创建一个全零数组
zeros_arr = np.zeros((2, 3))  # 2行3列
print(zeros_arr)
# 输出:
# [[0. 0. 0.]
#  [0. 0. 0.]]
# 创建一个全一数组
ones_arr = np.ones((3, 2))  # 3行2列
print(ones_arr)
# 输出:
# [[1. 1.]
#  [1. 1.]
#  [1. 1.]]
# 创建一个指定范围的数组
range_arr = np.arange(0, 10, 2)  # 从0到10，步长为2
print(range_arr) # 输出: [0 2 4 6 8]
# 创建一个指定数量的等间隔数组
linspace_arr = np.linspace(0, 1, 5)  # 从0到1，生成5个等间隔的数
print(linspace_arr) # 输出: [0.   0.25 0.5  0.75 1.  ]
​

NumPy 数组的基本操作：

# 数组的形状
print(arr2.shape)  # 输出: (2, 3)
# 数组的数据类型
print(arr2.dtype)  # 输出: int64 (或者其他整数类型)
# 数组的索引和切片
print(arr2[0, 1])  # 输出: 2 (第一行，第二列)
print(arr2[:, 0])  # 输出: [1 4] (所有行，第一列)
# 数组的算术运算
arr3 = arr1 + 5
print(arr3) # 输出: [ 6  7  8  9 10]
arr4 = arr1 * 2
print(arr4) # 输出: [ 2  4  6  8 10]
# 数组的聚合函数
print(np.sum(arr1)) # 输出: 15
print(np.mean(arr1)) # 输出: 3.0
print(np.max(arr1)) # 输出: 5
​

1.3.2 Scipy 稀疏矩阵

在科学计算中，经常会遇到大型稀疏矩阵，即大多数元素为零的矩阵。存储和操作这些矩阵的传统 NumPy 数组会浪费大量内存和计算资源。Scipy 的 sparse 模块提供了专门的数据结构来有效地处理稀疏矩阵。

Scipy 稀疏矩阵的优势：

• 内存效率： 仅存储非零元素及其索引，大大减少了内存占用。

• 计算效率： 针对稀疏矩阵的算法进行了优化，可以更快地执行矩阵运算。

常见的 Scipy 稀疏矩阵格式：

• CSR (Compressed Sparse Row): 按行压缩，适合行操作。

• CSC (Compressed Sparse Column): 按列压缩，适合列操作。

• COO (Coordinate List): 存储 (行, 列, 值) 的列表，适合构建稀疏矩阵。

• LIL (List of Lists): 使用列表存储每一行的非零元素，适合增量构建。

• DIA (Diagonal): 存储对角线上的元素，适合对角矩阵。

创建 Scipy 稀疏矩阵：

from scipy.sparse import csr_matrix
# 从 NumPy 数组创建 CSR 矩阵
dense_matrix = np.array([[0, 0, 1, 0, 2],
                         [0, 3, 0, 0, 0],
                         [4, 0, 0, 5, 0]])
sparse_matrix = csr_matrix(dense_matrix)
print(sparse_matrix)
# 输出:
#   (0, 2)        1
#   (0, 4)        2
#   (1, 1)        3
#   (2, 0)        4
#   (2, 3)        5
# 从 COO 格式创建 CSR 矩阵
row = np.array([0, 0, 1, 2, 2])
col = np.array([2, 4, 1, 0, 3])
data = np.array([1, 2, 3, 4, 5])
coo_matrix = coo_matrix((data, (row, col)), shape=(3, 5))
csr_matrix_from_coo = coo_matrix.tocsr()
print(csr_matrix_from_coo)
# 输出:
#   (0, 2)        1
#   (0, 4)        2
#   (1, 1)        3
#   (2, 0)        4
#   (2, 3)        5
​

Scipy 稀疏矩阵的基本操作：

# 访问非零元素
print(sparse_matrix[0, 2])  # 输出: 1
# 转换为 NumPy 数组
dense_matrix_from_sparse = sparse_matrix.toarray()
print(dense_matrix_from_sparse)
# 输出:
# [[0 0 1 0 2]
#  [0 3 0 0 0]
#  [4 0 0 5 0]]
# 稀疏矩阵的算术运算
sparse_matrix2 = csr_matrix([[0, 1, 0, 0, 0],
                              [0, 0, 0, 2, 0],
                              [0, 0, 0, 0, 3]])
sparse_sum = sparse_matrix + sparse_matrix2
print(sparse_sum)
# 输出:
#   (0, 2)        1
#   (0, 4)        2
#   (1, 1)        3
#   (2, 0)        4
#   (2, 3)        5
#   (0, 1)        1
#   (1, 3)        2
#   (2, 4)        3
# 稀疏矩阵的乘法
result_matrix = sparse_matrix.dot(sparse_matrix2)
print(result_matrix)
# 输出:
#   (0, 4)        6
#   (2, 3)        10
​

选择合适的稀疏矩阵格式：

选择哪种稀疏矩阵格式取决于具体的应用场景。

• 如果需要频繁地进行行操作，则 CSR 格式是最佳选择。

• 如果需要频繁地进行列操作，则 CSC 格式是最佳选择。

• 如果需要增量构建稀疏矩阵，则 LIL 格式是最佳选择。

• 如果需要从坐标列表构建稀疏矩阵，则 COO 格式是最佳选择。

1.3.3 Scipy 其他数据结构

除了 NumPy 数组和稀疏矩阵，Scipy 还提供了一些其他专门的数据结构，用于特定的科学计算任务。

• scipy.spatial.Delaunay： 用于计算 Delaunay 三角剖分，这是一种将一组点划分为三角形的方法。

• scipy.interpolate.interp1d： 用于一维插值，即根据已知数据点估计未知数据点的值。

• scipy.fftpack： 用于快速傅里叶变换 (FFT)，这是一种将信号从时域转换到频域的算法。

这些数据结构通常与其他 Scipy 模块结合使用，以解决各种科学计算问题。

1.3.4 Scipy 的基本操作

Scipy 提供了大量用于科学计算的操作，涵盖了以下几个方面：

• 线性代数： 矩阵分解、求解线性方程组、计算特征值和特征向量。

• 优化： 寻找函数的最小值或最大值、解决约束优化问题。

• 插值： 根据已知数据点估计未知数据点的值。

• 积分： 计算函数的定积分。

• 信号处理： 滤波、频谱分析、信号生成。

• 统计： 概率分布、假设检验、回归分析。

• 图像处理： 图像滤波、图像分割、特征提取。

代码示例：

from scipy import linalg
from scipy import optimize
from scipy import integrate
# 线性代数
A = np.array([[1, 2], [3, 4]])
b = np.array([5, 6])
x = linalg.solve(A, b)
print("Solve linear equations:", x)
# 优化
def f(x):
    return x**2 + 10*np.sin(x)
result = optimize.minimize(f, x0=0)
print("Optimization result:", result.x)
# 积分
def integrand(x):
    return np.exp(-x**2)
result, error = integrate.quad(integrand, 0, np.inf)
print("Integration result:", result)
​

1.3.5 总结

Scipy 建立在 NumPy 的基础上，并扩展了其功能，提供了大量用于科学计算的模块。理解 NumPy 数组和 Scipy 稀疏矩阵是有效利用 Scipy 的关键。Scipy 提供了各种各样的操作，涵盖了线性代数、优化、插值、积分、信号处理、统计和图像处理等领域。通过学习和实践这些基本数据结构和操作，可以更好地利用 Scipy 解决实际的科学计算问题。