scipy基本模块及其使用

# 一、常量模块(constants)

以下是 scipy.constants 模块中主要常量的分类表格：

# 1.1 数学常数

常量名	描述	值 (近似)
`pi`	圆周率 π	3.141592653589793
`golden`	黄金比例 (φ)	1.618033988749895
`e`	自然对数的底 (e)	2.718281828459045

# 1.2 通用物理常数

常量名	描述	值 (单位)
`c`	真空光速	299792458.0 m/s
`h`	普朗克常数	6.62607015e-34 J·s
`hbar`	约化普朗克常数 (h/2π)	1.054571817e-34 J·s
`G`	万有引力常数	6.67430e-11 m³/(kg·s²)
`g`	标准重力加速度	9.80665 m/s²

# 1.3 电磁学常数

常量名	描述	值 (单位)
`mu_0`	真空磁导率	1.25663706212e-6 N/A²
`epsilon_0`	真空电容率	8.8541878128e-12 F/m
`e` (或 `elementary_charge`)	元电荷	1.602176634e-19 C

# 1.4 原子与核物理常数

常量名	描述	值 (单位)
`m_e`	电子质量	9.1093837015e-31 kg
`m_p`	质子质量	1.67262192369e-27 kg
`m_n`	中子质量	1.67492749804e-27 kg
`Rydberg`	里德伯常数	10973731.568160 1/m
`alpha`	精细结构常数	0.0072973525693

# 1.5 化学相关常数

常量名	描述	值 (单位)
`N_A`	阿伏伽德罗常数	6.02214076e23 1/mol
`R`	通用气体常数	8.314462618 J/(mol·K)
`atomic_mass`	原子质量单位 (u)	1.66053906660e-27 kg

# 1.6 常用单位换算因子

常量名	描述	换算关系
`inch`	英寸 → 米	0.0254 m
`foot`	英尺 → 米	0.3048 m
`mile`	英里 → 米	1609.344 m
`lb`	磅 → 千克	0.45359237 kg
`eV`	电子伏特 → 焦耳	1.602176634e-19 J
`atm`	标准大气压 → 帕斯卡	101325.0 Pa

# 1.7 温度相关

常量名	描述	值
`zero_Celsius`	0°C 对应的开尔文温度	273.15 K
`degree_Fahrenheit`	1°F 对应的开尔文间隔	0.555555... K

# 查找所有常量的方法

from scipy import constants

# 列出所有常量
print(dir(constants))

# 搜索包含关键词的常量（例如 'mass'）
print(constants.find('mass'))

# 二、优化器(optimize)

scipy的优化器是数学建模的工具，它的核心目标是寻找函数的最小值（或最大值）、拟合模型、求解方程或系统，适用于传统数学问题而非深度学习(注意和pytorch这些的优化器函数区分开来)

# 2.1 无约束优化

用途:实现查找给定区间内函数的最小值
实现：

minimize_scalar() #单变量函数
minimize()        #多变量函数

查找方法：

单变量：

brent: 使用Brent方法（结合抛物线插值和黄金分割法）

bounded: 在有界区间内搜索

golden: 黄金分割法

多变量

Nelder-Mead: 单纯形法，不需要梯度

BFGS: 拟牛顿法，需要梯度

CG: 共轭梯度法

L-BFGS-B: 有限内存BFGS，适用于大规模问题

TNC: 截断牛顿法

实现实例：

from scipy.optimize import minimize

def rosen(x):
    """Rosenbrock函数"""
    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)

x0 = [1.3, 0.7, 0.8, 1.9, 1.2] #x0 是多维优化问题（如 minimize）的 初始猜测值（initial guess）。优化算法需要一个起点开始搜索最小值。
res = minimize(rosen, x0, method='BFGS', options={'disp': True}) #res 是 minimize 或 minimize_scalar 函数的返回结果，它是一个 OptimizeResult 对象 
print(res.x)

其中res的解有如下内容

# res 包含的重要属性：
res.x       # 最优解（最小值点）
res.fun     # 最优解处的函数值
res.nfev    # 函数评估次数
res.nit     # 迭代次数
res.success # 是否成功收敛
res.message # 状态描述（如收敛信息）
res.jac     # 最优解处的梯度（一阶导数）
res.hess    # 最优解处的Hessian矩阵（二阶导数，如果可用）

# 2.2 全局优化

用途：避免传统优化算法（如 minimize）陷入局部最优解，转而寻找全局最优解。
实现函数：

basinhopping(): 盆地跳跃算法basinhopping(): 盆地跳跃算法

shgo(): 单纯形同伦全局优化

differential_evolution(): 差分进化算法

实例：

from scipy.optimize import basinhopping

def func(x):
    return np.cos(14.5 * x - 0.3) + (x + 0.2) * x

res = basinhopping(func, x0=1.0)
print("全局最小值：x = %.4f, f(x) = %.4f" % (res.x, res.fun))

# 2.3 最小二乘拟合

用途：解决非线性最小二乘问题，常用于曲线拟合。
实现函数：

least_squares(): 解决非线性最小二乘问题

curve_fit(): 使用最小二乘法拟合曲线

实例：

from scipy.optimize import curve_fit
import numpy as np

# 定义模型函数
def func(x, a, b, c):
    return a * np.exp(-b * x) + c

# 生成带噪声的数据
xdata = np.linspace(0, 4, 50)
y = func(xdata, 2.5, 1.3, 0.5)
ydata = y + 0.2 * np.random.normal(size=len(xdata))

# 拟合数据
popt, pcov = curve_fit(func, xdata, ydata)
print("拟合参数：", popt) #返回[a,b,c]
print("协方差矩阵", pcov) #评估可靠性

[a,b,c]-> $f(x)=ae^{-bx}+c$

# 2.4 方程求根

方法：

root_scalar(): 单变量方程求根 #brentq, brenth, ridder, bisect, newton: 特定算法

root(): 多变量方程组求根

实现：

from scipy.optimize import root_scalar

def f(x):
    return x**3 - 1  # 寻找x^3 = 1的解

sol = root_scalar(f, bracket=[0, 2], method='brentq')
print("方程的根：", sol.root)

from scipy.optimize import root

def func(x):
    return [x[0] + 0.5 * (x[0] - x[1])**3 - 1.0,
            0.5 * (x[1] - x[0])**3 + x[1]]

sol = root(func, [0, 0])
print("方程组的解：", sol.x)

# 2.5 线性规划

什么是线性规划：结构化决策框架，其核心是在一个由线性关系定义的几何空间中，寻找最优的"角落"解。比如如下这个问题

想象你是一个工厂经理，需要决定生产两种产品A和B的数量：

生产A每个利润100元，B每个利润150元

但受限于：

原材料X：生产A消耗3kg，B消耗2kg，总共只有120kg

工时：生产A需要2小时，B需要4小时，总共只有160小时

线性规划就是帮你找到在资源限制下能获得最大利润的生产方案

$profit=-100x-150y$

$\begin{bmatrix} 3 & 2 \\ 2 & 4 \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} \le \begin{bmatrix} 120 \\ 160 \end{bmatrix}$

抽象一下就是：
输入: (A, b, c) → 处理: 代数变换 → 输出: x*

其中：

A 是约束矩阵（系统限制的编码）=>不等式左侧系数 A=
$\begin{bmatrix} 3 & 2 \\ 2 & 4 \end{bmatrix}$

b 是资源向量（约束条件的量化）=>不等式右侧系数 b=[120,160]

c 是价值向量（目标函数的权重）=>利润最大化 c=[-100,-150] (线性规划默认求最小值问题) $f(x)=-100x-150y$

x* 是最优决策（系统输出的解决方案）

实现实例:

from scipy.optimize import linprog

# 最小化 c^T x
# 约束条件: A_ub x <= b_ub, A_eq x = b_eq
c = [-1, 4]  # 目标函数系数
A_ub = [[-3, 1], [1, 2]]  # 不等式约束矩阵
b_ub = [6, 4]             # 不等式约束右侧

res = linprog(c, A_ub=A_ub, b_ub=b_ub, bounds=(None, None))
print("最优解：", res.x)
print("最优值：", res.fun)

# 2.6 约束优化

用途：在有等式或不等式约束条件下优化目标函数。
方法：

minimize() 配合约束参数

SLSQP: 序列二次规划算法

trust-constr: 信赖域算法

实现：

from scipy.optimize import minimize

# 目标函数
def objective(x):
    return x[0]*x[3]*(x[0]+x[1]+x[2])+x[2]

# 约束条件
def constraint1(x):
    return x[0]*x[1]*x[2]*x[3]-25.0

def constraint2(x):
    return sum(x**2)-40.0

# 初始猜测
x0 = [1,5,5,1]

# 设置约束
con1 = {'type': 'ineq', 'fun': constraint1}
con2 = {'type': 'eq', 'fun': constraint2}
cons = [con1,con2]

# 优化
sol = minimize(objective,x0,method='SLSQP',constraints=cons)
print("最优解：", sol.x)

# 三、稀疏矩阵(sparse)

专门针对那些绝大多数元素为零的矩阵数据结构

# 3.1 处理稀疏矩阵

方法:

CSC - 压缩稀疏列（Compressed Sparse Column），按列压缩。
CSR - 压缩稀疏行（Compressed Sparse Row），按行压缩。

实现:

import numpy as np
from scipy.sparse import csr_matrix

arr = np.array([0, 0, 0, 0, 0, 1, 1, 0, 2])

print(csr_matrix(arr))

输出:

  (0, 5)        1
  (0, 6)        1
  (0, 8)        2

print(csr_matrix(arr).data) #输出不为零的元素[1,1,2]
print(csr_matrix(arr).count_nonzero()) #输出非0元素总数3

mat = csr_matrix(arr)
mat.eliminate_zeros()
print(mat) #删除矩阵中的0元素

mat = csr_matrix(arr)
mat.sum_duplicates()
print(mat) #删除重复项

newarr = csr_matrix(arr).tocsc() #将csr转为csc

# 3.2图结构(sparse.csgraph)

如何查看连接组件(连接组件是指图中所有互相连通的节点的集合)

connected_components()

import numpy as np
from scipy.sparse.csgraph import connected_components
from scipy.sparse import csr_matrix

arr = np.array([
  [0, 1, 2],
  [1, 0, 0],
  [2, 0, 0]
])

newarr = csr_matrix(arr)

print(connected_components(newarr))

输出:

(1, array([0, 0, 0], dtype=int32)) #1代表一个连接组件，[0,0,0]代表每个元素属于哪个连接组件

Dijkstra 算法调用(用于计算一个节点到其他所有节点的最短路径)

import numpy as np
from scipy.sparse.csgraph import dijkstra
from scipy.sparse import csr_matrix

arr = np.array([
  [0, 1, 2],
  [1, 0, 0],
  [2, 0, 0]
])

newarr = csr_matrix(arr)

print(dijkstra(newarr, return_predecessors=True, indices=0))

其中dijkstra的参数：

return_predecessors: 布尔值，设置 True，遍历所有路径，如果不想遍历所有路径可以设置为 False。
indices: 元素的索引，返回该元素的所有路径。
limit: 路径的最大权重。

Floyd Warshall -- 弗洛伊德算法(解决任意两点间的最短路径)

import numpy as np
from scipy.sparse.csgraph import floyd_warshall
from scipy.sparse import csr_matrix

arr = np.array([
  [0, 1, 2],
  [1, 0, 0],
  [2, 0, 0]
])

newarr = csr_matrix(arr)

print(floyd_warshall(newarr, return_predecessors=True))

Bellman Ford -- 贝尔曼-福特算法(任意两点间的最短路径)

import numpy as np
from scipy.sparse.csgraph import bellman_ford
from scipy.sparse import csr_matrix

arr = np.array([
  [0, -1, 2],
  [1, 0, 0],
  [2, 0, 0]
])

newarr = csr_matrix(arr)

print(bellman_ford(newarr, return_predecessors=True, indices=0))

import numpy as np
from scipy.sparse.csgraph import depth_first_order
from scipy.sparse import csr_matrix

arr = np.array([
  [0, 1, 0, 1],
  [1, 1, 1, 1],
  [2, 1, 1, 0],
  [0, 1, 0, 1]
])

newarr = csr_matrix(arr)

print(depth_first_order(newarr, 1)) #传入邻接矩阵和起始遍历元素

import numpy as np
from scipy.sparse.csgraph import breadth_first_order
from scipy.sparse import csr_matrix

arr = np.array([
  [0, 1, 0, 1],
  [1, 1, 1, 1],
  [2, 1, 1, 0],
  [0, 1, 0, 1]
])

newarr = csr_matrix(arr)

print(breadth_first_order(newarr, 1))