SciPy-1-12-中文文档-六-
SciPy 1.12 中文文档（六）
scipy.interpolate.RectBivariateSpline
class scipy.interpolate.RectBivariateSpline(x, y, z, bbox=[None, None, None, None], kx=3, ky=3, s=0)
在矩形网格上的双变量样条逼近。
可用于平滑和插值数据。
参数：
x,y类似数组
严格升序坐标的 1-D 数组。评估超出数据范围的点将被外推。
z类似数组
形状为(x.size,y.size)的 2-D 数据数组。
bbox类似数组，可选
长度为 4 的序列，指定矩形逼近域的边界，这意味着每个维度的起始和结束样条节点由这些值设定。默认情况下，bbox=[min(x), max(x), min(y), max(y)]。
kx, ky整数，可选
双变量样条的度数。默认值为 3。
s浮点数，可选
正面的平滑因子定义为估计条件：sum((z[i]-f(x[i], y[i]))**2, axis=0) <= s，其中 f 是样条函数。默认值为s=0，适用于插值。
另请参见
双变量样条
双变量样条的基类。
单变量样条
用于拟合给定数据点的平滑单变量样条。
平滑双变量样条
通过给定点的平滑双变量样条
LSQ 矩形双变量样条
使用加权最小二乘拟合的双变量样条
矩形球面双变量样条
在球面上矩形网格上的双变量样条
球面平滑双变量样条
球面坐标中的平滑双变量样条
LSQ 球面双变量样条
使用加权最小二乘拟合的球面坐标中的双变量样条
bisplrep
用于找到表面的双变量 B 样条表示的函数
bisplev
评估双变量 B 样条及其导数的函数
注意事项
如果输入数据的各个维度具有不兼容的单位，并且相差很大，插值可能会产生数值伪影。在插值之前考虑对数据进行重新缩放。
方法
__call__(x, y[, dx, dy, grid]) |
在给定位置评估样条或其导数。 |
|---|---|
ev(xi, yi[, dx, dy]) |
在指定点评估样条。 |
get_coeffs() |
返回样条系数。 |
get_knots() |
返回一个元组(tx,ty)，其中 tx,ty 分别包含样条相对于 x 和 y 变量的结点位置。 |
get_residual() |
返回样条逼近的加权残差平方和：sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0) |
integral(xa, xb, ya, yb) |
计算样条在区域 [xa,xb] x [ya,yb] 上的积分。 |
partial_derivative(dx, dy) |
构造表示此样条的偏导数的新样条。 |
scipy.interpolate.RectSphereBivariateSpline
class scipy.interpolate.RectSphereBivariateSpline(u, v, r, s=0.0, pole_continuity=False, pole_values=None, pole_exact=False, pole_flat=False)
在球面上的矩形网格上的双变量样条逼近。
可用于平滑数据。
新版本 0.11.0 中的功能。
参数：
uarray_like
严格升序的极角坐标系一维数组。坐标必须以弧度给出，并位于开区间(0, pi)内。
varray_like
严格升序的经度坐标系一维数组。坐标必须以弧度给出。第一个元素 (v[0]) 必须位于区间 [-pi, pi) 内。最后一个元素 (v[-1]) 必须满足 v[-1] <= v[0] + 2*pi。
rarray_like
形状为 (u.size, v.size) 的二维数据数组。
sfloat, optional
为估计条件定义的正平滑因子 (s=0 用于插值)。
pole_continuitybool or (bool, bool), optional
极点 u=0 (pole_continuity[0]) 和 u=pi (pole_continuity[1]) 处的连续性顺序。当为 True 或 False 时，极点的连续性顺序为 1 或 0。默认为 False。
pole_valuesfloat or (float, float), optional
极点 u=0 和 u=pi 处的数据值。可以是整个参数或每个单独的元素。默认为 None。
pole_exactbool or (bool, bool), optional
极点 u=0 和 u=pi 处的数据值精确性。如果为 True，则该值被视为正确的函数值，并将被精确拟合。如果为 False，则该值将被视为与其他数据值一样的数据值。默认为 False。
pole_flatbool or (bool, bool), optional
对于 u=0 和 u=pi 处的极点，指定近似是否具有消失导数。默认为 False。
另请参阅
用于双变量样条的基类。
用于拟合给定数据点的平滑单变量样条。
平滑拟合给定点的双变量样条
使用加权最小二乘拟合的双变量样条
在球面坐标中的平滑双变量样条
LSQSphereBivariateSpline
在球坐标系中使用加权最小二乘拟合的二元样条
RectBivariateSpline
一个在矩形网格上的二元样条。
bisplrep
一个函数来找到一个表面的二元 B 样条表示
bisplev
一个评估二元 B 样条及其导数的函数
注释
目前，仅支持平滑样条逼近（iopt[0] = 0和iopt[0] = 1在 FITPACK 例程中）。 尚未实现精确的最小二乘样条逼近。
实际执行插值时，所请求的v值必须位于与原始v值选择相同长度的 2pi 间隔内。
欲了解更多信息，请参见关于此函数的FITPACK网站。
示例
假设我们有一个粗网格上的全局数据
>>> import numpy as np
>>> lats = np.linspace(10, 170, 9) * np.pi / 180.
>>> lons = np.linspace(0, 350, 18) * np.pi / 180.
>>> data = np.dot(np.atleast_2d(90. - np.linspace(-80., 80., 18)).T,
... np.atleast_2d(180. - np.abs(np.linspace(0., 350., 9)))).T
我们想将其插值到全局一度网格上
>>> new_lats = np.linspace(1, 180, 180) * np.pi / 180
>>> new_lons = np.linspace(1, 360, 360) * np.pi / 180
>>> new_lats, new_lons = np.meshgrid(new_lats, new_lons)
我们需要设置插值器对象
>>> from scipy.interpolate import RectSphereBivariateSpline
>>> lut = RectSphereBivariateSpline(lats, lons, data)
最后，我们插值数据。 RectSphereBivariateSpline对象只接受 1-D 数组作为输入，因此我们需要进行一些重塑。
>>> data_interp = lut.ev(new_lats.ravel(),
... new_lons.ravel()).reshape((360, 180)).T
查看原始和插值数据，可以看到插值器非常好地复制了原始数据：
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> ax1 = fig.add_subplot(211)
>>> ax1.imshow(data, interpolation='nearest')
>>> ax2 = fig.add_subplot(212)
>>> ax2.imshow(data_interp, interpolation='nearest')
>>> plt.show()
选择最优值s可能是一个微妙的任务。 推荐的s值取决于数据值的准确性。 如果用户对数据的统计误差有一个概念，她也可以找到一个合适的s的估计值。 假设，如果她指定了正确的s，插值器将使用一个完全复制数据背后函数的样条f(u,v)，她可以评估sum((r(i,j)-s(u(i),v(j)))**2)以找到这个s的良好估计值。 例如，如果她知道她的r(i,j)值的统计误差不大于 0.1，她可能期望一个好的s值不应大于u.size * v.size * (0.1)**2。
如果对于r(i,j)的统计误差一无所知，则s必须通过试探法确定。最好的方法是从一个非常大的值s开始（以确定最小二乘多项式和相应的上界fp0为s），然后逐渐减小s的值（比如一开始减小 10 倍，即s = fp0 / 10, fp0 / 100, ...，随着近似显示更多细节，操作更为谨慎）以获得更接近的拟合。
不同s值的插值结果为此过程提供了一些见解：
>>> fig2 = plt.figure()
>>> s = [3e9, 2e9, 1e9, 1e8]
>>> for idx, sval in enumerate(s, 1):
... lut = RectSphereBivariateSpline(lats, lons, data, s=sval)
... data_interp = lut.ev(new_lats.ravel(),
... new_lons.ravel()).reshape((360, 180)).T
... ax = fig2.add_subplot(2, 2, idx)
... ax.imshow(data_interp, interpolation='nearest')
... ax.set_title(f"s = {sval:g}")
>>> plt.show()
方法
__call__(theta, phi[, dtheta, dphi, grid]) |
在给定位置评估样条或其导数。 |
|---|---|
ev(theta, phi[, dtheta, dphi]) |
在点上评估样条 |
get_coeffs() |
返回样条系数。 |
get_knots() |
返回一个元组(tx,ty)，其中 tx,ty 分别包含关于 x、y 变量的样条结的位置。 |
get_residual() |
返回样条逼近的加权残差平方和：sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0) |
partial_derivative(dx, dy) |
构造代表此样条的偏导数的新样条。 |
scipy.interpolate.BivariateSpline
class scipy.interpolate.BivariateSpline
双变量样条的基类
这描述了在给定数据点(x, y, z)上从矩形[xb, xe] * [yb, ye]计算的kx和ky度数的样条s(x, y)。
这个类被设计成作为子类使用，不直接实例化。要构建这些样条，请调用SmoothBivariateSpline、LSQBivariateSpline 或 RectBivariateSpline。
另请参见
用于拟合给定数据点的平滑单变量样条
通过给定点平滑的双变量样条
使用加权最小二乘拟合的双变量样条
球上矩形网格的双变量样条
在球坐标中平滑的双变量样条
使用加权最小二乘拟合的球坐标中的双变量样条
一个在矩形网格上的双变量样条
查找曲面的双变量 B 样条表示
评估双变量 B 样条及其导数的函数
方法
__call__(x, y[, dx, dy, grid]) |
在给定位置评估样条函数或其导数。 |
|---|---|
ev(xi, yi[, dx, dy]) |
在给定点评估样条函数。 |
get_coeffs() |
返回样条函数的系数。 |
get_knots() |
返回一个元组(tx,ty)，其中 tx,ty 分别包含样条函数相对于 x 和 y 变量的节点位置。 |
get_residual() |
返回样条逼近的加权残差平方和：sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0)。 |
integral(xa, xb, ya, yb) |
计算样条函数在区域[xa,xb] x [ya,yb]上的积分。 |
partial_derivative(dx, dy) |
构造表示该样条函数偏导数的新样条函数。 |
scipy.interpolate.SmoothBivariateSpline
class scipy.interpolate.SmoothBivariateSpline(x, y, z, w=None, bbox=[None, None, None, None], kx=3, ky=3, s=None, eps=1e-16)
平滑的二元样条逼近。
参数：
x, y, zarray_like
一维数据点的序列（顺序不重要）。
warray_like，可选
正的一维权重序列，与x、y和z的长度相同。
bboxarray_like，可选
长度为 4 的序列，指定矩形逼近域的边界。默认情况下，bbox=[min(x), max(x), min(y), max(y)]。
kx, ky整数，可选
二元样条的度数。默认为 3。
sfloat，可选
正的平滑因子，用于估计条件：sum((w[i]*(z[i]-s(x[i], y[i])))**2, axis=0) <= s 默认s=len(w)，如果1/w[i]是z[i]标准差的估计值，这应该是一个良好的值。
epsfloat，可选
用于确定过决定线性方程组有效秩的阈值。eps应在开区间(0, 1)内，默认为 1e-16。
另请参阅
BivariateSpline
二元样条的基类。
UnivariateSpline
用于拟合给定数据点的平滑一元样条。
LSQBivariateSpline
使用加权最小二乘法的二元样条
RectSphereBivariateSpline
球上矩形网格上的二元样条
SmoothSphereBivariateSpline
球坐标系中的平滑二元样条
LSQSphereBivariateSpline
使用加权最小二乘法在球坐标系中的平滑二元样条
RectBivariateSpline
矩形网格上的二元样条
bisplrep
找到曲面的二元 B 样条表示的函数
bisplev
评估双变量 B-样条及其导数的函数。
注意
x、y 和 z 的长度应至少为(kx+1) * (ky+1)。
如果输入数据的输入维度具有不兼容的单位并且差异很大，则插值可能会出现数值伪影。考虑在插值之前重新缩放数据。
此例程通过 FITPACK 算法自动构造样条结节向量。样条结节可能位于数据点之外。对于某些数据集，即使请求使用s=0参数构造插值样条，此例程可能也无法成功构造。在这种情况下，建议直接使用bisplrep / bisplev，如有需要，增加bisplrep的nxest和nyest参数的值。
对于线性插值，建议优先使用LinearNDInterpolator。参见此处进行讨论。
方法
__call__(x, y[, dx, dy, grid]) |
在给定位置评估样条或其导数。 |
|---|---|
ev(xi, yi[, dx, dy]) |
在指定点评估样条 |
get_coeffs() |
返回样条系数。 |
get_knots() |
返回元组(tx,ty)，其中 tx,ty 分别包含与 x 和 y 变量相关的样条结节位置。 |
get_residual() |
返回样条逼近的加权残差平方和：sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0) |
integral(xa, xb, ya, yb) |
计算样条在区域[xa,xb] x [ya,yb]上的积分。 |
partial_derivative(dx, dy) |
构造一个新的样条曲线，表示该样条曲线的偏导数。 |
scipy.interpolate.SmoothSphereBivariateSpline
class scipy.interpolate.SmoothSphereBivariateSpline(theta, phi, r, w=None, s=0.0, eps=1e-16)
在球坐标中的平滑双变量样条近似。
版本 0.11.0 中的新功能。
参数：
theta, phi, rarray_like
数据点的 1-D 序列（顺序不重要）。坐标必须用弧度给出。Theta 必须在区间[0, pi]内，phi 必须在区间[0, 2pi]内。
warray_like，可选
正 1-D 权重序列。
sfloat，可选
为估计条件定义的正平滑因子：sum((w(i)*(r(i) - s(theta(i), phi(i))))**2, axis=0) <= s 默认值s=len(w)，如果1/w[i]是r[i]标准差的估计值，这应该是一个很好的值。
epsfloat，可选
用于确定超定线性方程组有效秩的阈值。eps应该在开区间(0, 1)内，缺省值为 1e-16。
另请参阅
双变量样条的基类。
用来拟合给定数据点的平滑单变量样条。
通过给定点进行平滑的双变量样条
使用加权最小二乘拟合的双变量样条
在球上矩形网格上的双变量样条
使用加权最小二乘拟合在球坐标中的双变量样条
在矩形网格上的双变量样条。
找到表面的双变量 B 样条表示的函数
评估双变量 B 样条及其导数的函数
注意事项
更多信息，请参阅关于此函数的FITPACK网站。
示例
假设我们有全局数据在粗网格上（输入数据不一定在网格上）：
>>> import numpy as np
>>> theta = np.linspace(0., np.pi, 7)
>>> phi = np.linspace(0., 2*np.pi, 9)
>>> data = np.empty((theta.shape[0], phi.shape[0]))
>>> data[:,0], data[0,:], data[-1,:] = 0., 0., 0.
>>> data[1:-1,1], data[1:-1,-1] = 1., 1.
>>> data[1,1:-1], data[-2,1:-1] = 1., 1.
>>> data[2:-2,2], data[2:-2,-2] = 2., 2.
>>> data[2,2:-2], data[-3,2:-2] = 2., 2.
>>> data[3,3:-2] = 3.
>>> data = np.roll(data, 4, 1)
我们需要设置插值器对象
>>> lats, lons = np.meshgrid(theta, phi)
>>> from scipy.interpolate import SmoothSphereBivariateSpline
>>> lut = SmoothSphereBivariateSpline(lats.ravel(), lons.ravel(),
... data.T.ravel(), s=3.5)
作为第一个测试，我们将看到在输入坐标上运行时算法返回什么。
>>> data_orig = lut(theta, phi)
最后，我们将数据插值到更细的网格上
>>> fine_lats = np.linspace(0., np.pi, 70)
>>> fine_lons = np.linspace(0., 2 * np.pi, 90)
>>> data_smth = lut(fine_lats, fine_lons)
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> ax1 = fig.add_subplot(131)
>>> ax1.imshow(data, interpolation='nearest')
>>> ax2 = fig.add_subplot(132)
>>> ax2.imshow(data_orig, interpolation='nearest')
>>> ax3 = fig.add_subplot(133)
>>> ax3.imshow(data_smth, interpolation='nearest')
>>> plt.show()
方法
__call__(theta, phi[, dtheta, dphi, grid]) |
评估给定位置的样条或其导数。 |
|---|---|
ev(theta, phi[, dtheta, dphi]) |
在指定点评估样条 |
get_coeffs() |
返回样条系数。 |
get_knots() |
返回一个元组 (tx,ty)，其中 tx、ty 分别包含样条相对于 x 和 y 变量的结点位置。 |
get_residual() |
返回样条逼近的加权残差平方和：sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0) |
partial_derivative(dx, dy) |
构造表示此样条的偏导数的新样条。 |
scipy.interpolate.LSQBivariateSpline
class scipy.interpolate.LSQBivariateSpline(x, y, z, tx, ty, w=None, bbox=[None, None, None, None], kx=3, ky=3, eps=None)
加权最小二乘双变量样条逼近。
参数：
x, y, z数组类型
数据点的一维序列（顺序不重要）。
tx, ty数组类型
严格排序的一维结节坐标序列。
w数组类型，可选
正权重的 1-D 数组，与x, y 和 z 的长度相同。
bbox（4,）数组类型，可选
指定矩形逼近域边界的长度为 4 的序列。默认情况下，bbox=[min(x,tx),max(x,tx), min(y,ty),max(y,ty)]。
kx, ky整数，可选
双变量样条的阶数。默认为 3。
eps浮点数，可选
用于确定过度确定的线性方程组的有效秩的阈值。eps 应该在开区间 (0, 1) 内取值，默认为 1e-16。
另请参阅
用于双变量样条的基类。
平滑的一维样条以适应给定的数据点集。
通过给定点的平滑双变量样条
球面上矩形网格上的双变量样条
在球面坐标中的平滑双变量样条
使用加权最小二乘拟合的球面坐标中的双变量样条
矩形网格上的双变量样条。
用于找到表面的双变量 B 样条表示的函数
评估双变量 B 样条及其导数的函数
注释
x, y 和 z 的长度至少应为 (kx+1) * (ky+1)。
如果输入数据的输入维度具有不相容的单位并且相差多个数量级，则插值可能具有数值人工。考虑在插值之前重新调整数据。
方法
__call__(x, y[, dx, dy, grid]) |
在给定位置评估样条或其导数。 |
|---|---|
ev(xi, yi[, dx, dy]) |
在点上评估样条 |
get_coeffs() |
返回样条系数。 |
get_knots() |
返回一个元组 (tx,ty)，其中 tx,ty 包含与 x 变量和 y 变量相关的样条结点位置。 |
get_residual() |
返回样条逼近的加权残差平方和：sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0) |
integral(xa, xb, ya, yb) |
评估样条在区域 [xa,xb] x [ya,yb] 上的积分。 |
partial_derivative(dx, dy) |
构造表示此样条的偏导数的新样条。 |
scipy.interpolate.LSQSphereBivariateSpline
class scipy.interpolate.LSQSphereBivariateSpline(theta, phi, r, tt, tp, w=None, eps=1e-16)
在球坐标中使用加权最小二乘双变量样条逼近。
根据theta和phi方向上给定的一组结点确定平滑的双三次样条。
0.11.0 版本中新增。
参数：
theta, phi, rarray_like
数据点的 1-D 序列（顺序不重要）。坐标必须以弧度给出。Theta 必须位于区间[0, pi]内，phi 必须位于区间[0, 2pi]内。
tt, tparray_like
严格排序的结点坐标的 1-D 序列。坐标必须满足0 < tt[i] < pi，0 < tp[i] < 2*pi。
warray_like, optional
与theta、phi和r长度相同的正 1-D 权重序列。
epsfloat, optional
用于确定超定线性方程组的有效秩的阈值。eps的值应在开区间(0, 1)内， 默认值为 1e-16。
另请参见
BivariateSpline
双变量样条的基类。
UnivariateSpline
用于拟合给定数据点的平滑单变量样条。
SmoothBivariateSpline
通过给定点的平滑双变量样条
LSQBivariateSpline
使用加权最小二乘拟合的双变量样条
RectSphereBivariateSpline
在球面上的矩形网格上的双变量样条
SmoothSphereBivariateSpline
在球坐标中的平滑双变量样条
RectBivariateSpline
在矩形网格上的双变量样条。
bisplrep
用于找到表面的双变量 B 样条表示的函数
bisplev
一个函数用于评估双变量 B 样条及其导数
注意事项
欲了解更多信息，请参阅关于该功能的FITPACK网站。
示例
假设我们有全局数据在粗网格上（输入数据不必在网格上）：
>>> from scipy.interpolate import LSQSphereBivariateSpline
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> theta = np.linspace(0, np.pi, num=7)
>>> phi = np.linspace(0, 2*np.pi, num=9)
>>> data = np.empty((theta.shape[0], phi.shape[0]))
>>> data[:,0], data[0,:], data[-1,:] = 0., 0., 0.
>>> data[1:-1,1], data[1:-1,-1] = 1., 1.
>>> data[1,1:-1], data[-2,1:-1] = 1., 1.
>>> data[2:-2,2], data[2:-2,-2] = 2., 2.
>>> data[2,2:-2], data[-3,2:-2] = 2., 2.
>>> data[3,3:-2] = 3.
>>> data = np.roll(data, 4, 1)
我们需要设置插值器对象。在这里，我们还必须指定要使用的节点坐标。
>>> lats, lons = np.meshgrid(theta, phi)
>>> knotst, knotsp = theta.copy(), phi.copy()
>>> knotst[0] += .0001
>>> knotst[-1] -= .0001
>>> knotsp[0] += .0001
>>> knotsp[-1] -= .0001
>>> lut = LSQSphereBivariateSpline(lats.ravel(), lons.ravel(),
... data.T.ravel(), knotst, knotsp)
作为第一个测试，我们将查看算法在输入坐标上运行时返回的内容。
>>> data_orig = lut(theta, phi)
最后，我们对数据进行插值，得到更精细的网格。
>>> fine_lats = np.linspace(0., np.pi, 70)
>>> fine_lons = np.linspace(0., 2*np.pi, 90)
>>> data_lsq = lut(fine_lats, fine_lons)
>>> fig = plt.figure()
>>> ax1 = fig.add_subplot(131)
>>> ax1.imshow(data, interpolation='nearest')
>>> ax2 = fig.add_subplot(132)
>>> ax2.imshow(data_orig, interpolation='nearest')
>>> ax3 = fig.add_subplot(133)
>>> ax3.imshow(data_lsq, interpolation='nearest')
>>> plt.show()
方法
__call__(theta, phi[, dtheta, dphi, grid]) |
在给定位置评估样条或其导数。 |
|---|---|
ev(theta, phi[, dtheta, dphi]) |
在点处评估样条 |
get_coeffs() |
返回样条系数。 |
get_knots() |
返回一个元组(tx,ty)，其中 tx、ty 包含关于 x、y 变量的样条节点位置。 |
get_residual() |
返回样条逼近的加权平方残差和：sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0) |
partial_derivative(dx, dy) |
构造表示此样条偏导数的新样条。 |
scipy.interpolate.bisplrep
scipy.interpolate.bisplrep(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None, kx=3, ky=3, task=0, s=None, eps=1e-16, tx=None, ty=None, full_output=0, nxest=None, nyest=None, quiet=1)
查找表面的二元 B-样条表示。
给定表示表面 z=f(x,y) 的一组数据点 (x[i], y[i], z[i])，计算表面的 B-样条表示。基于 FITPACK 中的 SURFIT 程序。
参数：
x, y, z 数组
数据点的一维数组。
w 数组，可选
权重的一维数组。默认情况下为 w=np.ones(len(x))。
xb, xe 浮点数，可选
x 轴逼近区间的端点。默认为 xb = x.min(), xe=x.max()。
yb, ye 浮点数，可选
y 轴逼近区间的端点。默认为 yb=y.min(), ye = y.max()。
kx, ky 整数，可选
样条的次数（1 <= kx, ky <= 5）。建议使用三阶（kx=ky=3）。
task 整数，可选
如果 task=0，则找到 x 和 y 的结点以及给定平滑因子 s 的系数。如果 task=1，则找到另一个平滑因子 s 的结点和系数。bisplrep 必须先前以 task=0 或 task=1 调用过。如果 task=-1，则找到给定结点 tx, ty 的系数。
s 浮点数，可选
非负平滑因子。如果权重对应于 z 中误差标准差的倒数，则应在范围内找到良好的 s 值 (m-sqrt(2*m),m+sqrt(2*m))，其中 m=len(x)。
eps 浮点数，可选
用于确定过度确定的线性方程组的有效秩的阈值 (0 < eps < 1)。eps 不太可能需要更改。
tx, ty 数组，可选
用于 task=-1 的样条结点的一维数组。
full_output 整数，可选
非零以返回可选输出。
nxest, nyest 整数，可选
对总节点数的过度估计。如果为 None，则nxest = max(kx+sqrt(m/2),2*kx+3), nyest = max(ky+sqrt(m/2),2*ky+3)。
quiet 整数，可选
非零以抑制消息的打印。
返回：
tck 类数组
包含结点 (tx, ty) 和系数 (c) 的二元 B-样条表示及样条度的列表 [tx, ty, c, kx, ky]。
fp 数组
样条逼近的加权平方残差和。
ier 整数
有关 splrep 成功的整数标志。如果 ier<=0，则表示成功。如果 ier 在 [1,2,3] 中，则表示发生错误但未引发错误。否则引发错误。
msg 字符串
与整数标志 ier 相对应的消息。
参见
splprep，splrep，splint，sproot，splev
UnivariateSpline，BivariateSpline
注释
见bisplev以评估其 tck 表示中的 B 样条的值。
如果输入数据的输入维度具有不相容的单位并且相差多个数量级，则插值可能会产生数值人工影响。在插值之前考虑重新缩放数据。
参考文献
[1]
Dierckx P.：用样条函数进行曲面拟合的算法 Ima J. Numer. Anal. 1 (1981) 267-283。
[2]
Dierckx P.：用样条函数进行曲面拟合的算法报告 tw50, Dept. Computer Science, K.U.Leuven, 1980。
[3]
Dierckx P.：用样条曲线和曲面拟合，数值分析专著，牛津大学出版社，1993 年。
示例
示例见教程。
scipy.interpolate.bisplev
scipy.interpolate.bisplev(x, y, tck, dx=0, dy=0)
评估双变量 B 样条及其导数。
返回一个样条函数值（或样条导数值）的二阶数组，在由一阶数组x和y的叉积给定的点处。在特殊情况下，如果x或y或两者都是浮点数，则返回一个数组或仅一个浮点数。基于 FITPACK 中的 BISPEV 和 PARDER。
参数：
x, yndarray
用于指定评估样条或其导数的域的一阶数组。
tcktuple
返回一个长度为 5 的序列，由bisplrep返回，包含结点位置、系数和样条的次数：[tx, ty, c, kx, ky]。
dx, dyint, optional
x和y分别的偏导数阶数。
返回：
valsndarray
在由x和y的叉积形成的集合上评估的 B 样条或其导数。
另请参阅
splprep, splrep, splint, sproot, splev
UnivariateSpline, BivariateSpline
注释
请参见bisplrep生成tck表示。
参考文献
[1]
Dierckx P.：用样条函数拟合曲面的算法，Ima J. Numer. Anal. 1 (1981) 267-283。
[2]
Dierckx P.：用样条函数拟合曲面的算法，报告 tw50，计算机科学系，K.U.Leuven，1980 年。
[3]
Dierckx P.：用样条拟合曲线和曲面，数值分析专著，牛津大学出版社，1993 年。
示例
示例见 tutorial。
scipy.interpolate.lagrange
scipy.interpolate.lagrange(x, w)
返回 Lagrange 插值多项式。
给定两个 1-D 数组x和w，返回通过点(x, w)的 Lagrange 插值多项式。
警告：此实现在数值上不稳定。即使选择了最佳点，也不要期望能够使用超过大约 20 个点。
参数：
xarray_like
x代表一组数据点的 x 坐标。
warray_like
w代表一组数据点的 y 坐标，即，f(x)。
返回：
lagrangenumpy.poly1d 实例
Lagrange 插值多项式。
示例
通过 3 个点插值(f(x) = x³)。
>>> import numpy as np
>>> from scipy.interpolate import lagrange
>>> x = np.array([0, 1, 2])
>>> y = x**3
>>> poly = lagrange(x, y)
由于只有 3 个点，Lagrange 多项式的次数为 2。具体地，它由以下公式给出：
[\begin{split}\begin{aligned} L(x) &= 1\times \frac{x (x - 2)}{-1} + 8\times \frac{x (x-1)}{2} \ &= x (-2 + 3x) \end{aligned}\end{split}]
>>> from numpy.polynomial.polynomial import Polynomial
>>> Polynomial(poly.coef[::-1]).coef
array([ 0., -2., 3.])
>>> import matplotlib.pyplot as plt
>>> x_new = np.arange(0, 2.1, 0.1)
>>> plt.scatter(x, y, label='data')
>>> plt.plot(x_new, Polynomial(poly.coef[::-1])(x_new), label='Polynomial')
>>> plt.plot(x_new, 3*x_new**2 - 2*x_new + 0*x_new,
... label=r"$3 x² - 2 x$", linestyle='-.')
>>> plt.legend()
>>> plt.show()
scipy.interpolate.approximate_taylor_polynomial
scipy.interpolate.approximate_taylor_polynomial(f, x, degree, scale, order=None)
通过多项式拟合来估计在 x 处的 f 的泰勒多项式。
参数：
f callable
寻求其泰勒多项式的函数。应接受一个 x 值的向量。
x 标量
要评估多项式的点。
degree int
泰勒多项式的阶数。
scale 标量
要评估泰勒多项式的区间宽度。在此宽度范围内的函数值用于拟合多项式。必须谨慎选择。
order int 或 None，可选
用于拟合的多项式的阶数；f 将被评估 order+1 次。如果为 None，则使用 degree。
返回：
p poly1d 实例
泰勒多项式（转化为原点，例如 p(0)=f(x)）。
注意
“比例尺”的适当选择是一种权衡；如果太大，函数与其泰勒多项式的差异太大，无法得到良好的答案；如果太小，舍入误差将淹没高阶项。即使在理想情况下，使用的算法在阶数为 30 时也会变得数值不稳定。
选择比 degree 稍大的 order 可能会改善高阶项。
示例
我们可以计算不同阶数的 sin 函数的泰勒逼近多项式：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.interpolate import approximate_taylor_polynomial
>>> x = np.linspace(-10.0, 10.0, num=100)
>>> plt.plot(x, np.sin(x), label="sin curve")
>>> for degree in np.arange(1, 15, step=2):
... sin_taylor = approximate_taylor_polynomial(np.sin, 0, degree, 1,
... order=degree + 2)
... plt.plot(x, sin_taylor(x), label=f"degree={degree}")
>>> plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left',
... borderaxespad=0.0, shadow=True)
>>> plt.tight_layout()
>>> plt.axis([-10, 10, -10, 10])
>>> plt.show()
scipy.interpolate.pade
scipy.interpolate.pade(an, m, n=None)
返回多项式的帕德逼近，作为两个多项式的比率。
参数：
an(N,) array_like
泰勒级数系数。
m整数
返回的逼近多项式 q 的顺序。
n整数，可选
返回的逼近多项式 p 的顺序。默认情况下，顺序是 len(an)-1-m。
返回值：
p, q多项式类
由 an 定义的多项式的帕德逼近为 p(x)/q(x)。
示例
>>> import numpy as np
>>> from scipy.interpolate import pade
>>> e_exp = [1.0, 1.0, 1.0/2.0, 1.0/6.0, 1.0/24.0, 1.0/120.0]
>>> p, q = pade(e_exp, 2)
>>> e_exp.reverse()
>>> e_poly = np.poly1d(e_exp)
比较 e_poly(x) 和帕德逼近 p(x)/q(x)。
>>> e_poly(1)
2.7166666666666668
>>> p(1)/q(1)
2.7179487179487181
输入输出（scipy.io）
SciPy 提供许多模块、类和函数，用于读取和写入多种文件格式的数据。
另请参阅
MATLAB® 文件
loadmat(file_name[, mdict, appendmat]) |
加载 MATLAB 文件。 |
|---|---|
savemat(file_name, mdict[, appendmat, ...]) |
将名称和数组字典保存到 MATLAB 风格的 .mat 文件中。 |
whosmat(file_name[, appendmat]) |
列出 MATLAB 文件中的变量。 |
有关低级 MATLAB 读写实用程序，请参见 scipy.io.matlab。
IDL® 文件
readsav(file_name[, idict, python_dict, ...]) |
读取 IDL .sav 文件。 |
|---|
Matrix Market 文件
mminfo(source) |
从类似 Matrix Market 文件的源返回大小和存储参数。 |
|---|---|
mmread(source) |
将类似 Matrix Market 文件的 'source' 的内容读入矩阵中。 |
mmwrite(target, a[, comment, field, ...]) |
将稀疏或密集数组 a 写入类似 Matrix Market 文件的 target 中。 |
无格式的 Fortran 文件
FortranFile(filename[, mode, header_dtype]) |
用于从 Fortran 代码中读取无格式顺序文件的文件对象。 |
|---|---|
FortranEOFError |
表示文件已正确结束。 |
FortranFormattingError |
表示文件在记录中途结束。 |
Netcdf
netcdf_file(filename[, mode, mmap, version, ...]) |
用于 NetCDF 数据的文件对象。 |
|---|---|
netcdf_variable(data, typecode, size, shape, ...) |
用于 netcdf 文件的数据对象。 |
Harwell-Boeing 文件
hb_read(path_or_open_file) |
读取 HB 格式文件。 |
|---|---|
hb_write(path_or_open_file, m[, hb_info]) |
写入 HB 格式文件。 |
Wav 音频文件 (scipy.io.wavfile)
read(filename[, mmap]) |
打开一个 WAV 文件。 |
|---|---|
write(filename, rate, data) |
将 NumPy 数组写入 WAV 文件。 |
| WavFileWarning | | ## Arff 文件 (scipy.io.arff)
loadarff(f) |
读取一个 arff 文件。 |
|---|---|
MetaData(rel, attr) |
小容器，用于保存 ARFF 数据集的有用信息。 |
ArffError |
|
ParseArffError |
scipy.io.loadmat
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.loadmat.html#scipy.io.loadmat
scipy.io.loadmat(file_name, mdict=None, appendmat=True, **kwargs)
加载 MATLAB 文件。
参数：
file_namestr
mat 文件的名称（如果 appendmat==True，则不需要 .mat 扩展名）。也可以传递打开的文件对象。
mdictdict，可选
要插入 mat 文件变量的字典。
appendmatbool，可选
如果给定的文件名末尾没有 .mat 扩展名，则为 True 追加 .mat 扩展名。默认为 True。
byte_orderstr 或 None，可选
默认为 None，表示从 mat 文件中猜测字节顺序。否则可以是（‘native’, ‘=’, ‘little’, ‘<’, ‘BIG’, ‘>’）中的一个。
mat_dtypebool，可选
如果为 True，则返回与加载到 MATLAB 中相同的 dtype 的数组（而不是保存时的 dtype）。
squeeze_mebool，可选
是否要压缩单元矩阵的维度。
chars_as_stringsbool，可选
是否将 char 数组转换为字符串数组。
matlab_compatiblebool，可选
将矩阵返回为 MATLAB 将加载的格式（意味着 squeeze_me=False, chars_as_strings=False, mat_dtype=True, struct_as_record=True）。
struct_as_recordbool，可选
是否将 MATLAB 结构加载为 NumPy 记录数组，或者加载为旧式 NumPy 数组（dtype=object）。将此标志设置为 False 复制 scipy 版本 0.7.x 的行为（返回 NumPy 对象数组）。默认设置为 True，因为它允许更容易地往返加载和保存 MATLAB 文件。
verify_compressed_data_integritybool，可选
是否应检查 MATLAB 文件中压缩序列的长度，以确保其不超过我们预期的长度。建议启用此功能（默认值），因为 MATLAB 文件中的超长压缩序列通常表明文件已经遭受了某种损坏。
variable_namesNone 或序列
如果为 None（默认值）- 读取文件中的所有变量。否则，variable_names 应为字符串序列，指定要从文件中读取的 MATLAB 变量的名称。读取器将跳过不在此序列中的任何变量名称，可能会节省一些读取处理。
simplify_cellsFalse，可选
如果为 True，则返回简化的字典结构（如果 mat 文件包含单元数组，则这对于有用）。请注意，这仅影响结果的结构，而不影响其内容（两种输出结构的内容相同）。如果为 True，则自动将 struct_as_record 设置为 False 和 squeeze_me 设置为 True，这是简化单元的必要设置。
返回：
mat_dictdict
以变量名作为键，加载的矩阵作为值的字典。
注意
支持 v4（Level 1.0）、v6 和 v7 到 7.2 mat 文件。
您需要一个 HDF5 Python 库来读取 MATLAB 7.3 格式的 mat 文件。因为 SciPy 没有提供此功能，我们在此不实现 HDF5 / 7.3 接口。
示例
>>> from os.path import dirname, join as pjoin
>>> import scipy.io as sio
从 tests/data 目录获取示例 .mat 文件的文件名。
>>> data_dir = pjoin(dirname(sio.__file__), 'matlab', 'tests', 'data')
>>> mat_fname = pjoin(data_dir, 'testdouble_7.4_GLNX86.mat')
加载 .mat 文件的内容。
>>> mat_contents = sio.loadmat(mat_fname)
结果是一个字典，每个变量对应一个键值对：
>>> sorted(mat_contents.keys())
['__globals__', '__header__', '__version__', 'testdouble']
>>> mat_contents['testdouble']
array([[0\. , 0.78539816, 1.57079633, 2.35619449, 3.14159265,
3.92699082, 4.71238898, 5.49778714, 6.28318531]])
默认情况下，SciPy 将 MATLAB 结构体读取为结构化的 NumPy 数组，其中 dtype 字段为 object 类型，名称对应 MATLAB 结构体字段名称。可以通过设置可选参数 struct_as_record=False 来禁用此功能。
获取包含名为 teststruct 的 MATLAB 结构体的示例 .mat 文件的文件名并加载内容。
>>> matstruct_fname = pjoin(data_dir, 'teststruct_7.4_GLNX86.mat')
>>> matstruct_contents = sio.loadmat(matstruct_fname)
>>> teststruct = matstruct_contents['teststruct']
>>> teststruct.dtype
dtype([('stringfield', 'O'), ('doublefield', 'O'), ('complexfield', 'O')])
结构化数组的大小是 MATLAB 结构体的大小，而不是任何特定字段中元素的数量。除非设置可选参数 squeeze_me=True，否则形状默认为 2-D，此时将移除所有长度为 1 的维度。
>>> teststruct.size
1
>>> teststruct.shape
(1, 1)
获取 MATLAB 结构体中第一个元素的 'stringfield'。
>>> teststruct[0, 0]['stringfield']
array(['Rats live on no evil star.'],
dtype='<U26')
获取 'doublefield' 的第一个元素。
>>> teststruct['doublefield'][0, 0]
array([[ 1.41421356, 2.71828183, 3.14159265]])
加载 MATLAB 结构体，压缩长度为 1 的维度，并获取 'complexfield' 的项。
>>> matstruct_squeezed = sio.loadmat(matstruct_fname, squeeze_me=True)
>>> matstruct_squeezed['teststruct'].shape
()
>>> matstruct_squeezed['teststruct']['complexfield'].shape
()
>>> matstruct_squeezed['teststruct']['complexfield'].item()
array([ 1.41421356+1.41421356j, 2.71828183+2.71828183j,
3.14159265+3.14159265j])
scipy.io.savemat
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.savemat.html#scipy.io.savemat
scipy.io.savemat(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')
将名称和数组的字典保存到 MATLAB 格式的 .mat 文件中。
将给定字典中的数组对象保存到 MATLAB 格式的 .mat 文件中。
参数：
file_name 字符串或类似文件的对象
.mat 文件的名称（如果 appendmat == True，则不需要 .mat 扩展名）。也可以传递打开的类似文件的对象。
mdict 字典
要保存为 mat 文件变量的字典。
appendmat 布尔值，可选
True（默认值）表示如果文件名末尾没有.mat扩展名，则会将其附加到给定的文件名上。
format {‘5’, ‘4’}，字符串，可选
‘5’（默认值）适用于 MATLAB 5 及更高版本（至 7.2），‘4’ 适用于 MATLAB 4 .mat 文件。
long_field_names 布尔值，可选
False（默认值）- 结构体中字段名的最大长度为 31 个字符，这是记录的最大长度。True - 结构体中字段名的最大长度为 63 个字符，适用于 MATLAB 7.6+。
do_compression 布尔值，可选
写入时是否压缩矩阵。默认为 False。
oned_as {‘row’, ‘column’}，可选
如果为 ‘column’，将 1-D NumPy 数组写为列向量。如果为 ‘row’，将 1-D NumPy 数组写为行向量。
示例
>>> from scipy.io import savemat
>>> import numpy as np
>>> a = np.arange(20)
>>> mdic = {"a": a, "label": "experiment"}
>>> mdic
{'a': array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19]),
'label': 'experiment'}
>>> savemat("matlab_matrix.mat", mdic)
scipy.io.whosmat
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.whosmat.html#scipy.io.whosmat
scipy.io.whosmat(file_name, appendmat=True, **kwargs)
列出 MATLAB 文件中的变量。
参数：
file_namestr
MAT 文件的名称（如果 appendmat==True，则不需要.mat 扩展名）。也可以传递打开的文件对象。
appendmatbool，可选
如果文件名末尾没有.mat 扩展名，则为 True，追加.mat 扩展名。默认为 True。
byte_orderstr 或 None，可选
默认情况下为 None，暗示从.mat 文件中猜测的字节顺序。否则可以是（'native'，'='，'little'，'<'，'BIG'，'>'）中的一个。
mat_dtypebool，可选
如果为 True，则返回与加载到 MATLAB 中的 dtype 相同的数组（而不是保存时的 dtype）。
squeeze_mebool，可选
是否压缩单位矩阵的维度。
chars_as_stringsbool，可选
是否将 char 数组转换为字符串数组。
matlab_compatiblebool，可选
返回矩阵，就像 MATLAB 加载的那样（意味着 squeeze_me=False，chars_as_strings=False，mat_dtype=True，struct_as_record=True）。
struct_as_recordbool，可选
是否将 MATLAB 结构加载为 NumPy 记录数组，或作为旧风格的 NumPy 数组（dtype=object）。将此标志设置为 False 可复制 SciPy 版本 0.7.x 的行为（返回 numpy 对象数组）。默认设置为 True，因为它允许更容易地往返加载和保存 MATLAB 文件。
返回：
variables元组列表
一个元组列表，每个元组包含矩阵名称（字符串）、其形状（整数元组）和其数据类（字符串）。可能的数据类有：int8、uint8、int16、uint16、int32、uint32、int64、uint64、single、double、cell、struct、object、char、sparse、function、opaque、logical、unknown。
注意
支持 v4（Level 1.0）、v6 和 v7 到 7.2 的 MAT 文件。
您将需要一个 HDF5 Python 库来读取 MATLAB 7.3 格式的.mat 文件（例如 h5py）。因为 SciPy 没有提供一个，所以我们在这里没有实现 HDF5 / 7.3 接口。
新增于版本 0.12.0。
示例
>>> from io import BytesIO
>>> import numpy as np
>>> from scipy.io import savemat, whosmat
创建一些数组，并使用savemat将它们写入BytesIO实例。
>>> a = np.array([[10, 20, 30], [11, 21, 31]], dtype=np.int32)
>>> b = np.geomspace(1, 10, 5)
>>> f = BytesIO()
>>> savemat(f, {'a': a, 'b': b})
使用whosmat来检查f。输出列表中的每个元组给出了f中数组的名称、形状和数据类型。
>>> whosmat(f)
[('a', (2, 3), 'int32'), ('b', (1, 5), 'double')]
scipy.io.readsav
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.readsav.html#scipy.io.readsav
scipy.io.readsav(file_name, idict=None, python_dict=False, uncompressed_file_name=None, verbose=False)
读取一个 IDL .sav 文件。
参数：
file_namestr
IDL 保存文件的名称。
idictdict，可选
要插入.sav 文件变量的字典。
python_dictbool，可选
默认情况下，返回的对象不是一个 Python 字典，而是一个不区分大小写的字典，可以通过项目、属性和调用访问变量。要获得标准的 Python 字典，请将此选项设置为 True。
uncompressed_file_namestr，可选
此选项仅对使用/compress 选项编写的.sav 文件有效。如果指定了文件名，则压缩的.sav 文件将解压缩到该文件中。否则，readsav 将使用tempfile模块自动确定临时文件名，并在成功读取后删除临时文件。
verbosebool，可选
是否打印有关保存文件的信息，包括读取的记录和可用变量。
返回：
idl_dictAttrDict 或 dict
如果python_dict设置为 False（默认值），此函数将返回一个不区分大小写的字典，可以通过项目、属性和调用访问变量。如果python_dict设置为 True，则此函数将返回一个所有变量名称均为小写的 Python 字典。如果指定了idict，则将变量写入指定的字典，并返回更新后的字典。
示例
>>> from os.path import dirname, join as pjoin
>>> import scipy.io as sio
>>> from scipy.io import readsav
从 tests/data 目录中获取示例.sav 文件的文件名。
>>> data_dir = pjoin(dirname(sio.__file__), 'tests', 'data')
>>> sav_fname = pjoin(data_dir, 'array_float32_1d.sav')
加载.sav 文件内容。
>>> sav_data = readsav(sav_fname)
获取.sav 文件内容的键。
>>> print(sav_data.keys())
dict_keys(['array1d'])
使用键访问内容。
>>> print(sav_data['array1d'])
[0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0.
0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0.
0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0.
0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0.
0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0.
0\. 0\. 0.]
scipy.io.mminfo
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.mminfo.html#scipy.io.mminfo
scipy.io.mminfo(source)
从 Matrix Market 文件类似的 'source' 返回大小和存储参数。
参数：
sourcestr 或类文件对象
Matrix Market 文件名（扩展名 .mtx）或打开的类文件对象
返回：
rowsint
矩阵行数。
colsint
矩阵列数。
entriesint
稀疏矩阵的非零条目数或稠密矩阵的行数*列数。
formatstr
要么 'coordinate' 或 'array'。
fieldstr
要么 'real'、'complex'、'pattern' 或 'integer'。
symmetrystr
要么 'general'、'symmetric'、'skew-symmetric' 或 'hermitian'。
注意事项
1.12.0 版本更改：C++ 实现。
示例
>>> from io import StringIO
>>> from scipy.io import mminfo
>>> text = '''%%MatrixMarket matrix coordinate real general
... 5 5 7
... 2 3 1.0
... 3 4 2.0
... 3 5 3.0
... 4 1 4.0
... 4 2 5.0
... 4 3 6.0
... 4 4 7.0
... '''
mminfo(source) 返回源文件的行数、列数、格式、字段类型和对称属性。
>>> mminfo(StringIO(text))
(5, 5, 7, 'coordinate', 'real', 'general')
scipy.io.mmread
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.mmread.html#scipy.io.mmread
scipy.io.mmread(source)
将 Matrix Market 文件类似的‘source’内容读入矩阵中。
参数：
source 字符串或类文件对象
Matrix Market 文件名（扩展名 .mtx, .mtz.gz）或打开的文件类对象。
返回：
a 数组或 coo_matrix
根据 Matrix Market 文件中的矩阵格式，返回密集或稀疏矩阵。
注意
在 1.12.0 版本中更改：采用 C++ 实现。
示例
>>> from io import StringIO
>>> from scipy.io import mmread
>>> text = '''%%MatrixMarket matrix coordinate real general
... 5 5 7
... 2 3 1.0
... 3 4 2.0
... 3 5 3.0
... 4 1 4.0
... 4 2 5.0
... 4 3 6.0
... 4 4 7.0
... '''
mmread(source) 返回 COO 格式的稀疏矩阵数据。
>>> m = mmread(StringIO(text))
>>> m
<5x5 sparse matrix of type '<class 'numpy.float64'>'
with 7 stored elements in COOrdinate format>
>>> m.A
array([[0., 0., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 2., 3.],
[4., 5., 6., 7., 0.],
[0., 0., 0., 0., 0.]])
此方法支持多线程。默认线程数等于系统中的 CPU 数量。使用 threadpoolctl 进行覆盖：
>>> import threadpoolctl
>>>
>>> with threadpoolctl.threadpool_limits(limits=2):
... m = mmread(StringIO(text))
scipy.io.mmwrite
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.mmwrite.html#scipy.io.mmwrite
scipy.io.mmwrite(target, a, comment=None, field=None, precision=None, symmetry='AUTO')
将稀疏或密集数组 a 写入类似 Matrix Market 文件的 target 中。
参数：
targetstr 或类文件对象
Matrix Market 文件名（扩展名为.mtx）或打开的类文件对象。
a类似数组
稀疏或密集的二维数组。
commentstr，可选
要添加到 Matrix Market 文件的注释。
fieldNone 或 str，可选
可选值为'real'、'complex'、'pattern'或'integer'。
precisionNone 或 int，可选
用于显示实数或复数值的位数。
symmetryNone 或 str，可选
可选值为'AUTO'、'general'、'symmetric'、'skew-symmetric'或'hermitian'。如果对称性为 None，则 'a' 的对称类型由其值确定。如果对称性为 'AUTO'，则 'a' 的对称类型将由mmwrite自行决定或设置为'general'。
返回：
None
注意事项
在版本 1.12.0 中更改：C++ 实现。
示例
>>> from io import BytesIO
>>> import numpy as np
>>> from scipy.sparse import coo_matrix
>>> from scipy.io import mmwrite
将小型 NumPy 数组写入 Matrix Market 文件。文件将以 'array' 格式写入。
>>> a = np.array([[1.0, 0, 0, 0], [0, 2.5, 0, 6.25]])
>>> target = BytesIO()
>>> mmwrite(target, a)
>>> print(target.getvalue().decode('latin1'))
%%MatrixMarket matrix array real general
%
2 4
1
0
0
2.5
0
0
0
6.25
向输出文件添加注释，并将精度设置为 3。
>>> target = BytesIO()
>>> mmwrite(target, a, comment='\n Some test data.\n', precision=3)
>>> print(target.getvalue().decode('latin1'))
%%MatrixMarket matrix array real general
%
% Some test data.
%
2 4
1.00e+00
0.00e+00
0.00e+00
2.50e+00
0.00e+00
0.00e+00
0.00e+00
6.25e+00
在调用mmwrite之前将其转换为稀疏矩阵。这将导致输出格式为'coordinate'而不是'array'。
>>> target = BytesIO()
>>> mmwrite(target, coo_matrix(a), precision=3)
>>> print(target.getvalue().decode('latin1'))
%%MatrixMarket matrix coordinate real general
%
2 4 3
1 1 1.00e+00
2 2 2.50e+00
2 4 6.25e+00
将复数 Hermite 数组写入 Matrix Market 文件。请注意，实际只有六个值写入文件；其余值由对称性隐含。
>>> z = np.array([[3, 1+2j, 4-3j], [1-2j, 1, -5j], [4+3j, 5j, 2.5]])
>>> z
array([[ 3\. +0.j, 1\. +2.j, 4\. -3.j],
[ 1\. -2.j, 1\. +0.j, -0\. -5.j],
[ 4\. +3.j, 0\. +5.j, 2.5+0.j]])
>>> target = BytesIO()
>>> mmwrite(target, z, precision=2)
>>> print(target.getvalue().decode('latin1'))
%%MatrixMarket matrix array complex hermitian
%
3 3
3.0e+00 0.0e+00
1.0e+00 -2.0e+00
4.0e+00 3.0e+00
1.0e+00 0.0e+00
0.0e+00 5.0e+00
2.5e+00 0.0e+00
此方法是线程化的。默认线程数等于系统中的 CPU 数量。使用threadpoolctl来覆盖：
>>> import threadpoolctl
>>>
>>> target = BytesIO()
>>> with threadpoolctl.threadpool_limits(limits=2):
... mmwrite(target, a)
scipy.io.FortranFile
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.FortranFile.html#scipy.io.FortranFile
class scipy.io.FortranFile(filename, mode='r', header_dtype=<class 'numpy.uint32'>)
用于从 Fortran 代码获取无格式顺序文件的文件对象。
参数：
filename文件或字符串
打开的文件对象或文件名。
mode，可选
读写模式，默认为‘r’。
header_dtypedtype，可选
头部的数据类型。大小和字节序必须与输入/输出文件匹配。
注意
这些文件被分解为未指定类型的记录。每个记录的大小在开始时给出（尽管此标题的大小不是标准的），并且数据以没有任何格式的方式写入磁盘。支持 BACKSPACE 语句的 Fortran 编译器将写入第二个大小的副本以便进行向后查找。
该类仅支持同时写入记录大小的文件。它还不支持 Intel 和 gfortran 编译器中用于大于 2GB 的记录的子记录，这些记录具有 4 字节头部。
在 Fortran 中，无格式的顺序文件的示例将会写为：
OPEN(1, FILE=myfilename, FORM='unformatted')
WRITE(1) myvariable
由于这是一种非标准的文件格式，其内容取决于编译器和机器的字节序，因此建议小心。已知适用于 x86_64 上的 gfortran 4.8.0 和 gfortran 4.1.2 生成的文件。
考虑使用 Fortran 直接访问文件或来自新 Stream I/O 的文件，这些文件可以轻松地被numpy.fromfile读取。
示例
要创建一个无格式的顺序 Fortran 文件：
>>> from scipy.io import FortranFile
>>> import numpy as np
>>> f = FortranFile('test.unf', 'w')
>>> f.write_record(np.array([1,2,3,4,5], dtype=np.int32))
>>> f.write_record(np.linspace(0,1,20).reshape((5,4)).T)
>>> f.close()
要读取此文件：
>>> f = FortranFile('test.unf', 'r')
>>> print(f.read_ints(np.int32))
[1 2 3 4 5]
>>> print(f.read_reals(float).reshape((5,4), order="F"))
[[0\. 0.05263158 0.10526316 0.15789474]
[0.21052632 0.26315789 0.31578947 0.36842105]
[0.42105263 0.47368421 0.52631579 0.57894737]
[0.63157895 0.68421053 0.73684211 0.78947368]
[0.84210526 0.89473684 0.94736842 1\. ]]
>>> f.close()
或者，在 Fortran 中：
integer :: a(5), i
double precision :: b(5,4)
open(1, file='test.unf', form='unformatted')
read(1) a
read(1) b
close(1)
write(*,*) a
do i = 1, 5
write(*,*) b(i,:)
end do
方法
close() |
关闭文件。 |
|---|---|
read_ints([dtype]) |
从文件中读取给定类型的记录，默认为整数类型（Fortran 中的 INTEGER*4）。 |
read_reals([dtype]) |
从文件中读取给定类型的记录，默认为浮点数（Fortran 中的 real*8）。 |
read_record(*dtypes, **kwargs) |
从文件中读取给定类型的记录。 |
write_record(*items) |
向文件中写入记录（包括大小）。 |
scipy.io.FortranEOFError
exception scipy.io.FortranEOFError
表示文件已经正确结束。
这个错误源自于 TypeError，因为代码用于引发 TypeError（这是唯一的方法来知道文件已经结束），所以用户可能会有except TypeError:。
errno
POSIX 异常代码
filename
异常的文件名
filename2
第二个异常的文件名
strerror
异常 strerror
with_traceback()
Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。
scipy.io.FortranFormattingError
exception scipy.io.FortranFormattingError
表明文件在记录中途结束。
派生自 TypeError 以保持向后兼容性。
errno
POSIX 异常代码
filename
异常 filename
filename2
第二个异常 filename
strerror
异常 strerror
with_traceback()
Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。
scipy.io.netcdf_file
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.netcdf_file.html#scipy.io.netcdf_file
class scipy.io.netcdf_file(filename, mode='r', mmap=None, version=1, maskandscale=False)
用于 NetCDF 数据的文件对象。
netcdf_file对象具有两个标准属性：dimensions和variables。两者的值都是字典，将维度名称映射到其相关长度和将变量名称映射到变量。
所有其他属性对应于 NetCDF 文件中定义的全局属性。全局文件属性是通过将netcdf_file对象的属性赋值而创建的。
参数：
文件名字符串或类文件
字符串 -> 文件名
模式，可选
读写追加模式，默认为‘r’
内存映射无或布尔值，可选
是否在读取时将文件名进行内存映射。当文件名是文件名时，默认为 True，当文件名是类文件对象时，默认为 False。请注意，当使用内存映射时，返回的数据数组直接引用磁盘上的 mmapped 数据，并且只要存在对它的引用，文件就不能关闭。
版本，可选
NetCDF 版本读取/写入，其中 1 表示经典格式，2 表示64 位偏移格式。默认为 1。详细信息请参阅此处。
掩码和缩放布尔值，可选
是否根据属性自动缩放和/或掩码数据。默认值为 False。
注意事项
该模块相对于其他模块的主要优势在于，它不需要代码链接到 NetCDF 库。该模块源自pupynere。
NetCDF 文件是一种自描述的二进制数据格式。该文件包含描述文件中维度和变量的元数据。关于 NetCDF 文件的更多细节可以在这里找到。NetCDF 数据结构有三个主要部分：
-
尺寸
-
变量
-
属性
尺寸部分记录了每个变量使用的每个维度的名称和长度。然后，变量将指示它使用的维度以及诸如数据单位的任何属性，同时包含变量的数据值。包含与轴的变量相同名称的变量是一个好的实践，以提供该轴的值。最后，属性部分将包含额外的信息，例如文件创建者的名称或用于收集数据的仪器。
在向 NetCDF 文件写入数据时，通常需要指定“记录维度”。记录维度是变量的无界维度。例如，温度变量可能具有纬度、经度和时间的维度。如果想要在时间推移时向 NetCDF 文件添加更多温度数据，则应将时间维度标记为记录维度。
此外，NetCDF 文件头包含文件中数据的位置，因此可以在不将不必要的数据加载到内存中的情况下有效访问。它使用mmap模块将 Numpy 数组映射到磁盘上的数据，以实现相同的目的。
注意，当使用netcdf_file以 mmap=True（只读模式的默认值）打开文件时，由其返回的数组直接引用磁盘上的数据。文件不应关闭，并且如果这些数组仍在使用，则无法在请求时完全关闭。如果需要在文件关闭后处理这些数组，则可能需要复制从内存映射 Netcdf 文件获取的数据数组，请参见下面的示例。
示例
创建 NetCDF 文件：
>>> from scipy.io import netcdf_file
>>> import numpy as np
>>> f = netcdf_file('simple.nc', 'w')
>>> f.history = 'Created for a test'
>>> f.createDimension('time', 10)
>>> time = f.createVariable('time', 'i', ('time',))
>>> time[:] = np.arange(10)
>>> time.units = 'days since 2008-01-01'
>>> f.close()
注意将arange(10)赋给time[:]。暴露时间变量的切片允许在对象中设置数据，而不是让arange(10)覆盖time变量。
读取刚创建的 NetCDF 文件：
>>> from scipy.io import netcdf_file
>>> f = netcdf_file('simple.nc', 'r')
>>> print(f.history)
b'Created for a test'
>>> time = f.variables['time']
>>> print(time.units)
b'days since 2008-01-01'
>>> print(time.shape)
(10,)
>>> print(time[-1])
9
当以只读方式打开 NetCDF 文件时，返回的数组直接引用磁盘上内存映射的数据：
>>> data = time[:]
如果需要在文件关闭后处理数据，则需要将其复制到主内存中：
>>> data = time[:].copy()
>>> del time
>>> f.close()
>>> data.mean()
4.5
NetCDF 文件也可以用作上下文管理器：
>>> from scipy.io import netcdf_file
>>> with netcdf_file('simple.nc', 'r') as f:
... print(f.history)
b'Created for a test'
方法
close() |
关闭 NetCDF 文件。 |
|---|---|
createDimension(name, length) |
将一个维度添加到 NetCDF 数据结构的 Dimension 部分。 |
createVariable(name, type, dimensions) |
为netcdf_file对象创建一个空变量，指定其数据类型和使用的维度。 |
flush() |
如果netcdf_file对象处于写入模式，则执行同步到磁盘的刷新操作。 |
sync() |
如果netcdf_file对象处于写入模式，则执行同步到磁盘的刷新操作。 |
scipy.io.netcdf_variable
class scipy.io.netcdf_variable(data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)
一个用于 netcdf 文件的数据对象。
netcdf_variable 对象是通过调用 netcdf_file.createVariable 方法在 netcdf_file 对象上构造的。netcdf_variable 对象的行为类似于 numpy 中定义的数组对象，不同之处在于它们的数据存储在文件中。通过索引读取数据，并通过分配给索引子集来写入数据；可以通过索引 [:] 访问整个数组，或者（对于标量）使用 getValue 和 assignValue 方法。netcdf_variable 对象还具有名为 shape 的属性，其含义与数组相同，但形状不可修改。还有一个只读属性 dimensions，其值是维度名称的元组，顺序与给定的 shape 中的长度相同。
所有其他属性对应于在 NetCDF 文件中定义的变量属性。通过将属性赋给 netcdf_variable 对象的属性来创建变量属性。
参数：
data 类似数组
保存变量值的数据数组。通常情况下，这是空初始化的，但具有适当的形状。
typecode dtype 字符代码
数据数组的期望数据类型。
size 整数
数据数组的期望元素大小。
shape 一组整数
数组的形状，应与变量维度的长度匹配。
dimensions 一组字符串
变量使用的维度名称。必须与 shape 中给出的维度长度的顺序相同。
attributes 字典，可选
属性值（任何类型），由字符串名称键入。这些属性成为 netcdf_variable 对象的属性。
maskandscale 布尔值，可选
根据属性自动缩放和/或屏蔽数据的选项。默认为 False。
参见
isrec, shape
属性:
dimensionslist of str
变量对象使用的维度名称列表。
isrec, shape
属性
方法
assignValue(value) |
给长度为一的netcdf_variable分配标量值。 |
|---|---|
getValue() |
从长度为一的netcdf_variable中检索标量值。 |
itemsize() |
返回变量的项目大小。 |
typecode() |
返回变量的类型代码。 |
| getitem |
scipy.io.hb_read
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.hb_read.html#scipy.io.hb_read
scipy.io.hb_read(path_or_open_file)
读取 HB 格式文件。
参数：
path_or_open_file路径或打开的文件
如果是文件样式对象，则直接使用。否则，在读取之前将其打开。
返回：
datascipy.sparse.csc_matrix 实例
从 HB 文件中读取的稀疏矩阵数据。
注释
目前不支持完整的 Harwell-Boeing 格式。支持的功能包括：
- 组装的、非对称的、实数矩阵
- 指针/索引的整数
- 浮点数值的指数格式和整数格式
示例
我们可以读取和写入 Harwell-Boeing 格式文件：
>>> from scipy.io import hb_read, hb_write
>>> from scipy.sparse import csr_matrix, eye
>>> data = csr_matrix(eye(3)) # create a sparse matrix
>>> hb_write("data.hb", data) # write a hb file
>>> print(hb_read("data.hb")) # read a hb file
(0, 0) 1.0
(1, 1) 1.0
(2, 2) 1.0
scipy.io.hb_write
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.hb_write.html#scipy.io.hb_write
scipy.io.hb_write(path_or_open_file, m, hb_info=None)
写入 HB 格式文件。
参数：
path_or_open_file路径或类似文件
如果是类似文件的对象，则使用原样。否则，在写入前打开。
m稀疏矩阵
要写入的稀疏矩阵
hb_infoHBInfo
包含写入元数据
返回：
None
注意事项
目前不支持完整的 Harwell-Boeing 格式。支持的特性包括：
- 组装的、非对称的、实数矩阵
- 指针/索引的整数
- 浮点值的指数格式和整数格式
示例
我们可以读取和写入 Harwell-Boeing 格式文件：
>>> from scipy.io import hb_read, hb_write
>>> from scipy.sparse import csr_matrix, eye
>>> data = csr_matrix(eye(3)) # create a sparse matrix
>>> hb_write("data.hb", data) # write a hb file
>>> print(hb_read("data.hb")) # read a hb file
(0, 0) 1.0
(1, 1) 1.0
(2, 2) 1.0
scipy.io.wavfile.read
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.wavfile.read.html#scipy.io.wavfile.read
scipy.io.wavfile.read(filename, mmap=False)
打开一个 WAV 文件。
返回 LPCM WAV 文件的采样率（以样本/秒为单位）和数据。
参数：
filename字符串或打开的文件句柄
输入 WAV 文件。
mmapbool，可选
是否将数据读取为内存映射（默认值：False）。与某些位深度不兼容；请参阅注释。仅适用于真实文件。
0.12.0 版本中的新功能。
返回：
rateint
WAV 文件的采样率。
datanumpy 数组
从 WAV 文件读取的数据。数据类型由文件确定；请参阅注释。对于 1 通道 WAV，数据为 1-D，否则为形状为 (Nsamples, Nchannels) 的 2-D。如果传递了类似文件的输入而没有类似 C 的文件描述符（例如 io.BytesIO)，则此数据不可写。
注释
常见数据类型：[1]
| WAV 格式 | 最小值 | 最大值 | NumPy 数据类型 |
|---|---|---|---|
| 32 位浮点数 | -1.0 | +1.0 | float32 |
| 32 位整数 PCM | -2147483648 | +2147483647 | int32 |
| 24 位整数 PCM | -2147483648 | +2147483392 | int32 |
| 16 位整数 PCM | -32768 | +32767 | int16 |
| 8 位整数 PCM | 0 | 255 | uint8 |
WAV 文件可以指定任意位深度，并且此函数支持从 1 到 64 位的任何整数 PCM 深度的读取。数据以最小兼容的 numpy int 类型返回，左对齐格式。8 位及以下为无符号，9 位及以上为有符号。
例如，24 位数据将以 int32 存储，其中 24 位数据的 MSB 存储在 int32 的 MSB 处，通常最不重要的字节为 0x00. （但是，如果文件实际包含超出指定位深度的数据，这些位也将被读取和输出。[2]）
此位对齐和符号匹配 WAV 的本机内部格式，允许内存映射使用每个样本 1、2、4 或 8 字节（因此 24 位文件不能进行内存映射，但 32 位可以）。
支持的 IEEE 浮点 PCM 格式为 32 位或 64 位，带有或不带有 mmap。超出 [-1, +1] 范围的值不会被剪切。
不支持非线性 PCM（mu-law, A-law）。
参考资料
[1]
IBM Corporation 和 Microsoft Corporation，“多媒体编程接口和数据规范 1.0”，第“样本数据格式”章节，1991 年 8 月 www.tactilemedia.com/info/MCI_Control_Info.html
[2]
Adobe Systems Incorporated，“Adobe Audition 3 用户指南”，第“音频文件格式：24 位打包整数（类型 1, 20 位）”章节，2007 年
示例
>>> from os.path import dirname, join as pjoin
>>> from scipy.io import wavfile
>>> import scipy.io
从 tests/data 目录中获取一个示例 .wav 文件的文件名。
>>> data_dir = pjoin(dirname(scipy.io.__file__), 'tests', 'data')
>>> wav_fname = pjoin(data_dir, 'test-44100Hz-2ch-32bit-float-be.wav')
加载 .wav 文件内容。
>>> samplerate, data = wavfile.read(wav_fname)
>>> print(f"number of channels = {data.shape[1]}")
number of channels = 2
>>> length = data.shape[0] / samplerate
>>> print(f"length = {length}s")
length = 0.01s
绘制波形。
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> time = np.linspace(0., length, data.shape[0])
>>> plt.plot(time, data[:, 0], label="Left channel")
>>> plt.plot(time, data[:, 1], label="Right channel")
>>> plt.legend()
>>> plt.xlabel("Time [s]")
>>> plt.ylabel("Amplitude")
>>> plt.show()
scipy.io.wavfile.write
scipy.io.wavfile.write(filename, rate, data)
将 NumPy 数组写入 WAV 文件。
参数：
filenamestring 或打开的文件句柄
输出 wav 文件。
rateint
采样率（每秒样本数）。
datandarray
一个一维或二维的 NumPy 数组，可以是整数或浮点数数据类型。
注意事项
-
写入一个简单的未压缩 WAV 文件。
-
若要写入多声道数据，请使用形状为 (Nsamples, Nchannels) 的二维数组。
-
位深和 PCM/浮点数将由数据类型确定。
常见数据类型：[1]
| WAV 格式 | 最小值 | 最大值 | NumPy 数据类型 |
|---|---|---|---|
| 32 位浮点数 | -1.0 | +1.0 | float32 |
| 32 位 PCM | -2147483648 | +2147483647 | int32 |
| 16 位 PCM | -32768 | +32767 | int16 |
| 8 位 PCM | 0 | 255 | uint8 |
请注意，8 位 PCM 是无符号的。
参考文献
[1]
IBM 公司和微软公司，“多媒体编程接口和数据规范 1.0”，章节“样本的数据格式”，1991 年 8 月 www.tactilemedia.com/info/MCI_Control_Info.html
示例
创建一个 100Hz 正弦波，采样率为 44100Hz。写入 16 位 PCM，单声道。
>>> from scipy.io.wavfile import write
>>> import numpy as np
>>> samplerate = 44100; fs = 100
>>> t = np.linspace(0., 1., samplerate)
>>> amplitude = np.iinfo(np.int16).max
>>> data = amplitude * np.sin(2. * np.pi * fs * t)
>>> write("example.wav", samplerate, data.astype(np.int16))
scipy.io.wavfile.WavFileWarning
exception scipy.io.wavfile.WavFileWarning
with_traceback()
Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。
scipy.io.arff.loadarff
scipy.io.arff.loadarff(f)
读取 ARFF 文件。
数据以记录数组的形式返回，可以像 NumPy 数组的字典一样访问。例如，如果其中一个属性称为“pressure”，则可以从 data 记录数组中访问其前 10 个数据点，如此：data['pressure'][0:10]
参数：
f 类似文件或字符串
用于读取的类文件对象或要打开的文件名。
返回：
data 记录数组
ARFF 文件的数据可通过属性名访问。
meta MetaData
包含 ARFF 文件的信息，如属性的名称和类型，关系（数据集的名称），等等。
引发：
ParseArffError
如果给定文件不符合 ARFF 格式，则会引发此错误。
NotImplementedError
ARFF 文件包含一个尚不支持的属性。
注意事项
此函数应能读取大多数 ARFF 文件。未实现的功能包括：
-
日期类型的属性
-
字符串类型的属性
它可以读取具有数值和名义属性的文件。但无法读取稀疏数据的文件（文件中的{}）。然而，此函数可以读取文件中具有缺失数据（文件中的?），将数据点表示为 NaN。
示例
>>> from scipy.io import arff
>>> from io import StringIO
>>> content = """
... @relation foo
... @attribute width numeric
... @attribute height numeric
... @attribute color {red,green,blue,yellow,black}
... @data
... 5.0,3.25,blue
... 4.5,3.75,green
... 3.0,4.00,red
... """
>>> f = StringIO(content)
>>> data, meta = arff.loadarff(f)
>>> data
array([(5.0, 3.25, 'blue'), (4.5, 3.75, 'green'), (3.0, 4.0, 'red')],
dtype=[('width', '<f8'), ('height', '<f8'), ('color', '|S6')])
>>> meta
Dataset: foo
width's type is numeric
height's type is numeric
color's type is nominal, range is ('red', 'green', 'blue', 'yellow', 'black')
scipy.io.arff.MetaData
class scipy.io.arff.MetaData(rel, attr)
一个小容器，用于保存 ARFF 数据集的有用信息。
知道属性的名称和类型。
笔记
也维护属性列表的顺序，即对于 meta 中的每个 i，其中 meta 是 MetaData 的一个实例，将按定义顺序返回不同的属性名。
示例
data, meta = loadarff('iris.arff')
# This will print the attributes names of the iris.arff dataset
for i in meta:
print(i)
# This works too
meta.names()
# Getting attribute type
types = meta.types()
方法
names() |
返回属性名的列表。 |
|---|---|
types() |
返回属性类型的列表。 |
scipy.io.arff.ArffError
exception scipy.io.arff.ArffError
errno
POSIX 异常代码
filename
异常文件名
filename2
第二个异常文件名
strerror
异常错误描述
with_traceback()
Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self.
scipy.io.arff.ParseArffError
exception scipy.io.arff.ParseArffError
errno
POSIX 异常代码
filename
异常文件名
filename2
第二异常文件名
strerror
异常 strerror
with_traceback()
Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。
线性代数（scipy.linalg）
线性代数函数。
另请参见：
numpy.linalg，获取更多线性代数函数。请注意，虽然scipy.linalg导入了大部分函数，但scipy.linalg中的同名函数可能提供更多或稍有不同的功能。
基础
inv(a[, overwrite_a, check_finite]) |
计算矩阵的逆。 |
|---|---|
solve(a, b[, lower, overwrite_a, ...]) |
解线性方程组 a @ x == b，求未知数x，其中 a 为方阵。 |
solve_banded(l_and_u, ab, b[, overwrite_ab, ...]) |
解方程 a x = b，假设 a 为带状矩阵。 |
solveh_banded(ab, b[, overwrite_ab, ...]) |
解方程 a x = b。 |
solve_circulant(c, b[, singular, tol, ...]) |
解 C x = b，其中 C 为循环矩阵。 |
solve_triangular(a, b[, trans, lower, ...]) |
解方程a x = b，假设 a 是上（或下）三角矩阵。 |
solve_toeplitz(c_or_cr, b[, check_finite]) |
使用 Levinson 递归解 Toeplitz 系统。 |
matmul_toeplitz(c_or_cr, x[, check_finite, ...]) |
使用 FFT 高效计算 Toeplitz 矩阵乘法 |
det(a[, overwrite_a, check_finite]) |
计算矩阵的行列式。 |
norm(a[, ord, axis, keepdims, check_finite]) |
矩阵或向量范数。 |
lstsq(a, b[, cond, overwrite_a, ...]) |
计算方程 Ax = b 的最小二乘解。 |
pinv(a, *[, atol, rtol, return_rank, ...]) |
计算矩阵的（Moore-Penrose）伪逆。 |
pinvh(a[, atol, rtol, lower, return_rank, ...]) |
计算 Hermitian 矩阵的（Moore-Penrose）伪逆。 |
kron(a, b) |
克罗内克积。 |
khatri_rao(a, b) |
Khatri-Rao 积。 |
tril(m[, k]) |
自版本 1.11.0 起已弃用。
|
triu(m[, k]) |
|---|
自版本 1.11.0 起已弃用。
|
orthogonal_procrustes(A, B[, check_finite]) |
计算正交 Procrustes 问题的矩阵解。 |
|---|---|
matrix_balance(A[, permute, scale, ...]) |
计算用于行/列平衡的对角相似性变换。 |
subspace_angles(A, B) |
计算两个矩阵之间的子空间角。 |
bandwidth(a) |
返回 2D 数值数组的下界和上界带宽。 |
issymmetric(a[, atol, rtol]) |
检查方形 2D 数组是否对称。 |
ishermitian(a[, atol, rtol]) |
检查方形 2D 数组是否 Hermitian。 |
LinAlgError |
由 linalg 函数引发的通用 Python 异常派生对象。 |
LinAlgWarning |
在线性代数相关操作接近失败条件或预计丢失精度时发出的警告。 |
特征值问题
eig(a[, b, left, right, overwrite_a, ...]) |
解决方形矩阵的普通或广义特征值问题。 |
|---|---|
eigvals(a[, b, overwrite_a, check_finite, ...]) |
计算普通或广义特征值问题的特征值。 |
eigh(a[, b, lower, eigvals_only, ...]) |
解决复 Hermitian 或实对称矩阵的标准或广义特征值问题。 |
eigvalsh(a[, b, lower, overwrite_a, ...]) |
解决复埃尔米特或实对称矩阵的标准或广义特征值问题。 |
eig_banded(a_band[, lower, eigvals_only, ...]) |
解决实对称或复共轭埃尔米特带状矩阵的特征值问题。 |
eigvals_banded(a_band[, lower, ...]) |
解决实对称或复共轭埃尔米特带状矩阵的特征值问题。 |
eigh_tridiagonal(d, e[, eigvals_only, ...]) |
解决实对称三对角矩阵的特征值问题。 |
eigvalsh_tridiagonal(d, e[, select, ...]) |
解决实对称三对角矩阵的特征值问题。 |
Decompositions
lu(a[, permute_l, overwrite_a, ...]) |
计算带部分选点的矩阵的 LU 分解。 |
|---|---|
lu_factor(a[, overwrite_a, check_finite]) |
计算矩阵的带有置换的 LU 分解。 |
lu_solve(lu_and_piv, b[, trans, ...]) |
给定矩阵的 LU 分解，解方程系统 a x = b。 |
svd(a[, full_matrices, compute_uv, ...]) |
奇异值分解。 |
svdvals(a[, overwrite_a, check_finite]) |
计算矩阵的奇异值。 |
diagsvd(s, M, N) |
根据奇异值和大小 M，N 构造 SVD 中的 sigma 矩阵。 |
orth(A[, rcond]) |
使用 SVD 构造矩阵 A 的范围的标准正交基 |
null_space(A[, rcond]) |
使用 SVD 构造矩阵 A 的零空间的标准正交基 |
ldl(A[, lower, hermitian, overwrite_a, ...]) |
计算对称/埃尔米特矩阵的 LDLt 或 Bunch-Kaufman 分解。 |
cholesky(a[, lower, overwrite_a, check_finite]) |
计算矩阵的 Cholesky 分解。 |
cholesky_banded(ab[, overwrite_ab, lower, ...]) |
Cholesky 分解带状埃尔米特正定矩阵。 |
cho_factor(a[, lower, overwrite_a, check_finite]) |
计算矩阵的 Cholesky 分解，用于 cho_solve。 |
cho_solve(c_and_lower, b[, overwrite_b, ...]) |
给定矩阵 A 的 Cholesky 分解，解线性方程 A x = b。 |
cho_solve_banded(cb_and_lower, b[, ...]) |
给定带状埃尔米特矩阵 A 的 Cholesky 分解，解线性方程 A x = b。 |
polar(a[, side]) |
计算极分解。 |
qr(a[, overwrite_a, lwork, mode, pivoting, ...]) |
计算矩阵的 QR 分解。 |
qr_multiply(a, c[, mode, pivoting, ...]) |
计算 QR 分解并将 Q 与矩阵相乘。 |
qr_update(Q, R, u, v[, overwrite_qruv, ...]) |
Rank-k QR 更新。 |
qr_delete(Q, R, k, int p=1[, which, ...]) |
在行或列删除上进行 QR 降级。 |
qr_insert(Q, R, u, k[, which, rcond, ...]) |
在行或列插入上进行 QR 更新。 |
rq(a[, overwrite_a, lwork, mode, check_finite]) |
计算矩阵的 RQ 分解。 |
qz(A, B[, output, lwork, sort, overwrite_a, ...]) |
对一对矩阵进行广义特征值的 QZ 分解。 |
ordqz(A, B[, sort, output, overwrite_a, ...]) |
对一对矩阵进行重新排序的 QZ 分解。 |
schur(a[, output, lwork, overwrite_a, sort, ...]) |
计算矩阵的 Schur 分解。 |
rsf2csf(T, Z[, check_finite]) |
将实 Schur 形式转换为复数 Schur 形式。 |
hessenberg(a[, calc_q, overwrite_a, ...]) |
计算矩阵的 Hessenberg 形式。 |
cdf2rdf(w, v) |
将复特征值w和特征向量v转换为块对角形式中的实特征值wr和相应的实特征向量vr，使得。 |
cossin(X[, p, q, separate, swap_sign, ...]) |
计算正交/酉矩阵的余弦-正弦（CS）分解。 |
另请参阅
scipy.linalg.interpolative – 插值矩阵分解
矩阵函数
expm(A) |
计算数组的矩阵指数。 |
|---|---|
logm(A[, disp]) |
计算矩阵的对数。 |
cosm(A) |
计算矩阵的余弦。 |
sinm(A) |
计算矩阵的正弦。 |
tanm(A) |
计算矩阵的正切。 |
coshm(A) |
计算矩阵的双曲余弦。 |
sinhm(A) |
计算矩阵的双曲正弦。 |
tanhm(A) |
计算矩阵的双曲正切。 |
signm(A[, disp]) |
矩阵的符号函数。 |
sqrtm(A[, disp, blocksize]) |
矩阵的平方根。 |
funm(A, func[, disp]) |
评估由可调用函数指定的矩阵函数。 |
expm_frechet(A, E[, method, compute_expm, ...]) |
A 在方向 E 上的矩阵指数的 Frechet 导数。 |
expm_cond(A[, check_finite]) |
矩阵指数在 Frobenius 范数下的相对条件数。 |
fractional_matrix_power(A, t) |
计算矩阵的分数幂。 |
矩阵方程求解器
solve_sylvester(a, b, q) |
计算 Sylvester 方程(AX + XB = Q)的解（X）。 |
|---|---|
solve_continuous_are(a, b, q, r[, e, s, ...]) |
解决连续时间代数 Riccati 方程（CARE）。 |
solve_discrete_are(a, b, q, r[, e, s, balanced]) |
解决离散时间代数 Riccati 方程（DARE）。 |
solve_continuous_lyapunov(a, q) |
解决连续 Lyapunov 方程(AX + XA^H = Q)。 |
solve_discrete_lyapunov(a, q[, method]) |
解决离散 Lyapunov 方程(AXA^H - X + Q = 0)。 |
草图和随机投影
clarkson_woodruff_transform(input_matrix, ...) |
对输入矩阵应用 Clarkson-Woodruff 变换/草图。 |
|---|
特殊矩阵
block_diag(*arrs) |
从提供的数组创建一个分块对角矩阵。 |
|---|---|
circulant(c) |
构造循环矩阵。 |
companion(a) |
创建一个伴随矩阵。 |
convolution_matrix(a, n[, mode]) |
构造一个卷积矩阵。 |
dft(n[, scale]) |
离散傅里叶变换矩阵。 |
fiedler(a) |
返回一个对称的 Fiedler 矩阵 |
fiedler_companion(a) |
返回一个 Fiedler 伴随矩阵 |
hadamard(n[, dtype]) |
构造一个 Hadamard 矩阵。 |
hankel(c[, r]) |
构造 Hankel 矩阵。 |
helmert(n[, full]) |
创建阶数为n的 Helmert 矩阵。 |
hilbert(n) |
创建阶为 n 的 Hilbert 矩阵。 |
invhilbert(n[, exact]) |
计算阶为 n 的 Hilbert 矩阵的逆矩阵。 |
leslie(f, s) |
创建 Leslie 矩阵。 |
pascal(n[, kind, exact]) |
返回 n x n Pascal 矩阵。 |
invpascal(n[, kind, exact]) |
返回 n x n Pascal 矩阵的逆矩阵。 |
toeplitz(c[, r]) |
构造一个 Toeplitz 矩阵。 |
tri(N[, M, k, dtype]) |
构造一个三角矩阵。 |
自版本 1.11.0 起不推荐使用。
|
低级例程
get_blas_funcs(names[, arrays, dtype, ilp64]) |
返回指定名称的可用 BLAS 函数对象。 |
|---|---|
get_lapack_funcs(names[, arrays, dtype, ilp64]) |
返回指定名称的可用 LAPACK 函数对象。 |
find_best_blas_type([arrays, dtype]) |
查找最佳匹配的 BLAS/LAPACK 类型。 |
另请参阅
scipy.linalg.blas – 低级 BLAS 函数
scipy.linalg.lapack – 低级 LAPACK 函数
scipy.linalg.cython_blas – 用于 Cython 的低级 BLAS 函数
scipy.linalg.cython_lapack – 用于 Cython 的低级 LAPACK 函数
scipy.linalg.inv
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.inv.html#scipy.linalg.inv
scipy.linalg.inv(a, overwrite_a=False, check_finite=True)
计算矩阵的逆。
参数：
aarray_like
要求逆的方阵。
overwrite_abool，可选
丢弃a中的数据（可能提高性能）。默认为 False。
check_finitebool，可选
是否检查输入矩阵是否仅包含有限数。禁用可能会提高性能，但如果输入包含无穷大或 NaN，可能会导致问题（崩溃、非终止）。
返回：
ainvndarray
矩阵a的逆。
抛出异常：
LinAlgError
如果a是奇异的。
ValueError
如果a不是方阵，或不是 2D。
示例
>>> import numpy as np
>>> from scipy import linalg
>>> a = np.array([[1., 2.], [3., 4.]])
>>> linalg.inv(a)
array([[-2\. , 1\. ],
[ 1.5, -0.5]])
>>> np.dot(a, linalg.inv(a))
array([[ 1., 0.],
[ 0., 1.]])
scipy.linalg.solve
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.solve.html#scipy.linalg.solve
scipy.linalg.solve(a, b, lower=False, overwrite_a=False, overwrite_b=False, check_finite=True, assume_a='gen', transposed=False)
解决方程组 a @ x == b 中未知数 x 的方形 a 矩阵。
如果数据矩阵已知为特定类型，则将相应的字符串供应给 assume_a 键选择专用求解器。可用选项为
| 通用矩阵 | ‘gen’ |
|---|---|
| 对称 | ‘sym’ |
| 共轭转置 | ‘her’ |
| 正定 | ‘pos’ |
如果省略，'gen' 是默认结构。
数组的数据类型定义了调用哪个求解器，而不考虑值。换句话说，即使复数数组条目具有精确的零虚部，也将基于数组的数据类型调用复数求解器。
参数：
a(N, N) 数组型
方形输入数据
b(N, NRHS) 数组型
右侧的输入数据。
lowerbool，默认值：假
如果 assume_a == 'gen'（默认）。如果为真，则计算仅使用 a 的下三角数据；忽略对角线上方的条目。如果为假（默认），则计算仅使用 a 的上三角数据；忽略对角线以下的条目。
overwrite_abool，默认值：假
允许覆盖 a 中的数据（可能提升性能）。
overwrite_bbool，默认值：假
允许覆盖 b 中的数据（可能提升性能）。
check_finitebool，默认值：真
是否检查输入矩阵仅包含有限数字。禁用可能会带来性能增益，但如果输入确实包含无穷大或 NaN，则可能会导致问题（崩溃、非终止）。
assume_astr，{‘gen’，‘sym’，‘her’，‘pos’}
有效条目如上所述。
transposedbool，默认值：假
如果为真，解决 a.T @ x == b。对复数 a 抛出 NotImplementedError。
返回：
x(N, NRHS) ndarray
解决方案数组。
引发：
值错误
如果检测到大小不匹配或输入 a 不是方形的。
LinAlgError
如果矩阵是奇异的。
LinAlgWarning
如果检测到病态输入的 a。
未实现错误
如果 transposed 为真且输入的 a 是复数矩阵。
注意事项
如果输入 b 矩阵是具有 N 个元素的 1-D 数组，并且与一个 NxN 输入的 a 一起提供，则尽管明显大小不匹配，但被假定为有效的列向量。这与 numpy.dot() 的行为兼容，返回的结果仍然是 1-D 数组。
通过调用 LAPACK 的 ?GESV、?SYSV、?HESV 和 ?POSV 程序获得通用、对称、共轭和正定解。
示例
给定 a 和 b，解 x：
>>> import numpy as np
>>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
>>> b = np.array([2, 4, -1])
>>> from scipy import linalg
>>> x = linalg.solve(a, b)
>>> x
array([ 2., -2., 9.])
>>> np.dot(a, x) == b
array([ True, True, True], dtype=bool)
scipy.linalg.solve_banded
scipy.linalg.solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, check_finite=True)
解方程 a x = b 以 x 为假设，假设 a 是带状矩阵。
矩阵a以矩阵对角线有序形式存储在ab中：
ab[u + i - j, j] == a[i,j]
ab的示例（a 的形状为(6,6)，u =1，l =2）：
* a01 a12 a23 a34 a45
a00 a11 a22 a33 a44 a55
a10 a21 a32 a43 a54 *
a20 a31 a42 a53 * *
参数：
(l, u)（整数，整数）
非零下、上对角线数量
ab(l + u + 1, M)数组样本
带状矩阵
b(M,)或(M, K)数组样本
右侧
overwrite_abbool，可选
丢弃ab中的数据（可能增强性能）
overwrite_bbool，可选
丢弃b中的数据（可能增强性能）
check_finitebool，可选
是否检查输入矩阵只包含有限数。禁用可能带来性能提升，但如果输入确实包含无穷大或 NaN，可能会导致问题（崩溃、非终止）。
返回：
x(M,)或(M, K)数组样本
系统方程 a x = b 的解。返回形状取决于b的形状。
示例
解决带状系统 a x = b，其中：
[5 2 -1 0 0] [0]
[1 4 2 -1 0] [1]
a = [0 1 3 2 -1] b = [2]
[0 0 1 2 2] [2]
[0 0 0 1 1] [3]
主对角线下有一个非零对角线（l = 1），上有两个（u = 2）。该矩阵的带状形式为：
[* * -1 -1 -1]
ab = [* 2 2 2 2]
[5 4 3 2 1]
[1 1 1 1 *]
>>> import numpy as np
>>> from scipy.linalg import solve_banded
>>> ab = np.array([[0, 0, -1, -1, -1],
... [0, 2, 2, 2, 2],
... [5, 4, 3, 2, 1],
... [1, 1, 1, 1, 0]])
>>> b = np.array([0, 1, 2, 2, 3])
>>> x = solve_banded((1, 2), ab, b)
>>> x
array([-2.37288136, 3.93220339, -4\. , 4.3559322 , -1.3559322 ])
scipy.linalg.solveh_banded
scipy.linalg.solveh_banded(ab, b, overwrite_ab=False, overwrite_b=False, lower=False, check_finite=True)
解方程 a x = b。a 是 Hermitian 正定带状矩阵。
使用 Thomas 算法，比标准 LU 分解更高效，但仅适用于 Hermitian 正定矩阵。
矩阵 a 存储在 ab 中，可以是下对角线或者上对角线排序形式：
如果是上三角形式，则 ab[u + i - j, j] == a[i,j]（i <= j）；如果是下三角形式，则 ab[i - j, j] == a[i,j]（i >= j）
ab 示例（a 的形状为 (6, 6)，上对角线数量 u = 2）：
upper form:
* * a02 a13 a24 a35
* a01 a12 a23 a34 a45
a00 a11 a22 a33 a44 a55
lower form:
a00 a11 a22 a33 a44 a55
a10 a21 a32 a43 a54 *
a20 a31 a42 a53 * *
未使用标记为 * 的单元格。
参数：
ab(u + 1, M) 类似数组
带状矩阵
b(M,) 或 (M, K) 类似数组
右侧
overwrite_abbool, optional
丢弃 ab 中的数据（可能提升性能）
overwrite_bbool, optional
丢弃 b 中的数据（可能提升性能）
lowerbool, optional
矩阵是否处于下三角形式（默认为上三角形式）
check_finitebool, optional
是否检查输入矩阵仅包含有限数字。禁用此选项可能提升性能，但如果输入包含无穷大或 NaN，则可能导致问题（崩溃、无法终止）。
返回：
x(M,) 或 (M, K) 数组
解决系统 a x = b。返回形状与 b 相匹配。
注意事项
对于非正定矩阵 a，可以使用求解器 solve_banded。
示例
解决带状系统 A x = b，其中：
[ 4 2 -1 0 0 0] [1]
[ 2 5 2 -1 0 0] [2]
A = [-1 2 6 2 -1 0] b = [2]
[ 0 -1 2 7 2 -1] [3]
[ 0 0 -1 2 8 2] [3]
[ 0 0 0 -1 2 9] [3]
>>> import numpy as np
>>> from scipy.linalg import solveh_banded
ab 包含主对角线和主对角线下方的非零对角线。也就是说，我们使用下三角形式：
>>> ab = np.array([[ 4, 5, 6, 7, 8, 9],
... [ 2, 2, 2, 2, 2, 0],
... [-1, -1, -1, -1, 0, 0]])
>>> b = np.array([1, 2, 2, 3, 3, 3])
>>> x = solveh_banded(ab, b, lower=True)
>>> x
array([ 0.03431373, 0.45938375, 0.05602241, 0.47759104, 0.17577031,
0.34733894])
解决 Hermitian 带状系统 H x = b，其中：
[ 8 2-1j 0 0 ] [ 1 ]
H = [2+1j 5 1j 0 ] b = [1+1j]
[ 0 -1j 9 -2-1j] [1-2j]
[ 0 0 -2+1j 6 ] [ 0 ]
在这个例子中，我们将上对角线放在数组 hb 中：
>>> hb = np.array([[0, 2-1j, 1j, -2-1j],
... [8, 5, 9, 6 ]])
>>> b = np.array([1, 1+1j, 1-2j, 0])
>>> x = solveh_banded(hb, b)
>>> x
array([ 0.07318536-0.02939412j, 0.11877624+0.17696461j,
0.10077984-0.23035393j, -0.00479904-0.09358128j])
scipy.linalg.solve_circulant
scipy.linalg.solve_circulant(c, b, singular='raise', tol=None, caxis=-1, baxis=0, outaxis=0)
解决 C x = b，其中 C 是循环矩阵。
C是与向量c相关联的循环矩阵。
通过在 Fourier 空间进行除法来解决系统。计算方法如下：
x = ifft(fft(b) / fft(c))
其中fft和ifft分别是快速傅里叶变换及其逆变换。对于一个大向量c，这比使用完整的循环矩阵解系统要快得多。
参数：
c类似数组
循环矩阵的系数。
b类似数组
a x = b中的右手边矩阵。
singular字符串，可选
此参数控制如何处理接近奇异的循环矩阵。如果singular为“raise”且循环矩阵接近奇异，则会引发LinAlgError。如果singular为“lstsq”，则返回最小二乘解。默认为“raise”。
tol浮点数，可选
如果循环矩阵的任何特征值的绝对值小于或等于tol，则矩阵被视为接近奇异。如果未给出，tol被设置为：
tol = abs_eigs.max() * abs_eigs.size * np.finfo(np.float64).eps
其中abs_eigs是循环矩阵特征值的绝对值数组。
caxis整数
当c的维度大于 1 时，它被视为循环向量的集合。在这种情况下，caxis是保持循环系数向量的c的轴。
baxis整数
当b的维度大于 1 时，它被视为向量的集合。在这种情况下，baxis是保持右侧向量的b的轴。
outaxis整数
当c或b是多维的时，由solve_circulant返回的值也是多维的。在这种情况下，outaxis是结果中保存解向量的轴。
返回：
x数组
解决系统C x = b。
引发：
线性代数错误
如果与c相关联的循环矩阵接近奇异。
另请参见
circulant
循环矩阵
注释
对于长度为m的一维向量c，和形状为(m, ...)的数组b，
solve_circulant(c, b)
返回与相同的结果
solve(circulant(c), b)
其中solve和circulant来自scipy.linalg。
版本 0.16.0 中的新功能。
示例
>>> import numpy as np
>>> from scipy.linalg import solve_circulant, solve, circulant, lstsq
>>> c = np.array([2, 2, 4])
>>> b = np.array([1, 2, 3])
>>> solve_circulant(c, b)
array([ 0.75, -0.25, 0.25])
将该结果与使用scipy.linalg.solve解决系统进行比较：
>>> solve(circulant(c), b)
array([ 0.75, -0.25, 0.25])
一个奇异的例子：
>>> c = np.array([1, 1, 0, 0])
>>> b = np.array([1, 2, 3, 4])
调用 solve_circulant(c, b) 将引发 LinAlgError。对于最小二乘解法，请使用选项 singular='lstsq'：
>>> solve_circulant(c, b, singular='lstsq')
array([ 0.25, 1.25, 2.25, 1.25])
与 scipy.linalg.lstsq 进行比较：
>>> x, resid, rnk, s = lstsq(circulant(c), b)
>>> x
array([ 0.25, 1.25, 2.25, 1.25])
广播示例：
假设我们有存储在形状为（2，5）的数组中的两个循环矩阵的向量，并且存储在形状为（3，5）的数组中的三个b向量。例如，
>>> c = np.array([[1.5, 2, 3, 0, 0], [1, 1, 4, 3, 2]])
>>> b = np.arange(15).reshape(-1, 5)
我们希望解决所有循环矩阵和b向量的组合，并将结果存储在形状为（2，3，5）的数组中。当我们忽略保存系数向量的c和b轴时，集合的形状分别为（2，）和（3，），这两者在广播时不兼容。为了获得形状为（2，3）的广播结果，我们向c添加一个无关紧要的维度：c[:, np.newaxis, :] 的形状为（2，1，5）。最后一个维度保存循环矩阵的系数，因此当我们调用 solve_circulant 时，可以使用默认的 caxis=-1。b向量的系数位于数组b的最后一个维度中，因此我们使用 baxis=-1。如果使用默认的 outaxis，则结果将具有形状（5，2，3），因此我们将使用 outaxis=-1 将解向量放在最后一个维度中。
>>> x = solve_circulant(c[:, np.newaxis, :], b, baxis=-1, outaxis=-1)
>>> x.shape
(2, 3, 5)
>>> np.set_printoptions(precision=3) # For compact output of numbers.
>>> x
array([[[-0.118, 0.22 , 1.277, -0.142, 0.302],
[ 0.651, 0.989, 2.046, 0.627, 1.072],
[ 1.42 , 1.758, 2.816, 1.396, 1.841]],
[[ 0.401, 0.304, 0.694, -0.867, 0.377],
[ 0.856, 0.758, 1.149, -0.412, 0.831],
[ 1.31 , 1.213, 1.603, 0.042, 1.286]]])
通过解决一对c和b向量来检查（参见 x[1, 1, :]）：
>>> solve_circulant(c[1], b[1, :])
array([ 0.856, 0.758, 1.149, -0.412, 0.831])
scipy.linalg.solve_triangular
scipy.linalg.solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, check_finite=True)
解方程a x = b以求解x，假设a为三角矩阵。
参数：
a(M, M) 的 array_like
一个三角形矩阵
b(M,) 或 (M, N) 的 array_like
a x = b中的右手边矩阵
lowerbool, 可选
仅使用a的下三角中的数据。默认使用上三角。
trans, 可选
要解决的系统类型：
| trans | system |
|---|---|
| 0 或 ‘N’ | a x = b |
| 1 或 ‘T’ | a^T x = b |
| 2 或 ‘C’ | a^H x = b |
unit_diagonalbool, 可选
如果为 True，则假定a的对角线元素为 1 且不会被引用。
overwrite_bbool, 可选
允许覆盖b中的数据（可能提高性能）
check_finitebool, 可选
是否检查输入矩阵仅包含有限数值。禁用此项可能会提高性能，但如果输入包含无穷大或 NaN，可能会导致问题（崩溃、非终止）。
返回：
x(M,) 或 (M, N) 的 ndarray
a x = b 系统的解。返回形状与b相匹配。
异常：
LinAlgError
如果a是奇异的
注意事项
0.9.0 版本中的新功能。
示例
解下三角系统a x = b，其中：
[3 0 0 0] [4]
a = [2 1 0 0] b = [2]
[1 0 1 0] [4]
[1 1 1 1] [2]
>>> import numpy as np
>>> from scipy.linalg import solve_triangular
>>> a = np.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]])
>>> b = np.array([4, 2, 4, 2])
>>> x = solve_triangular(a, b, lower=True)
>>> x
array([ 1.33333333, -0.66666667, 2.66666667, -1.33333333])
>>> a.dot(x) # Check the result
array([ 4., 2., 4., 2.])
scipy.linalg.solve_toeplitz
scipy.linalg.solve_toeplitz(c_or_cr, b, check_finite=True)
使用 Levinson 递归解 Toeplitz 系统
Toeplitz 矩阵具有常对角线，以 c 作为其第一列，r 作为其第一行。如果未提供 r，则假定r == conjugate(c)。
参数：
c_or_cr array_like 或 (array_like, array_like) 元组
向量c或数组元组(c, r)。无论c的实际形状如何，都将转换为 1-D 数组。如果未提供，则假定r = conjugate(c)；在这种情况下，如果 c[0]是实数，则 Toeplitz 矩阵是 Hermitian 的。忽略 r[0]；Toeplitz 矩阵的第一行是[c[0], r[1:]]。无论r的实际形状如何，都将转换为 1-D 数组。
b(M,) 或 (M, K) 的 array_like
右侧的T x = b。
check_finite bool，可选
是否检查输入矩阵只包含有限数字。禁用可能会提高性能，但如果输入确实包含无穷大或 NaN，则可能会导致问题（结果完全为 NaN）。
返回：
x(M,) 或 (M, K) 的 ndarray
系统T x = b的解。返回形状与b的形状相匹配。
另请参见
Toeplitz 矩阵
注意事项
使用 Levinson-Durbin 递归计算解，比通用的最小二乘法更快，但数值稳定性较差。
示例
解决 Toeplitz 系统 T x = b，其中：
[ 1 -1 -2 -3] [1]
T = [ 3 1 -1 -2] b = [2]
[ 6 3 1 -1] [2]
[10 6 3 1] [5]
要指定 Toeplitz 矩阵，只需要第一列和第一行。
>>> import numpy as np
>>> c = np.array([1, 3, 6, 10]) # First column of T
>>> r = np.array([1, -1, -2, -3]) # First row of T
>>> b = np.array([1, 2, 2, 5])
>>> from scipy.linalg import solve_toeplitz, toeplitz
>>> x = solve_toeplitz((c, r), b)
>>> x
array([ 1.66666667, -1\. , -2.66666667, 2.33333333])
通过创建完整的 Toeplitz 矩阵并将其与x相乘来检查结果。我们应该得到b。
>>> T = toeplitz(c, r)
>>> T.dot(x)
array([ 1., 2., 2., 5.])
scipy.linalg.matmul_toeplitz
scipy.linalg.matmul_toeplitz(c_or_cr, x, check_finite=False, workers=None)
使用 FFT 高效计算 Toeplitz 矩阵乘积
此函数返回 Toeplitz 矩阵与密集矩阵的矩阵乘积。
Toeplitz 矩阵具有恒定的对角线，以 c 作为其第一列，以 r 作为其第一行。如果未给出 r，则假定 r == conjugate(c)。
参数：
c_or_crarray_like 或 (array_like, array_like) 元组
向量 c，或数组元组 (c, r)。无论 c 的实际形状如何，都将转换为 1-D 数组。如果未提供，则假定 r = conjugate(c)；在这种情况下，如果 c[0] 是实数，则 Toeplitz 矩阵是 Hermitian 的。r[0] 将被忽略；Toeplitz 矩阵的第一行是 [c[0], r[1:]]。无论 r 的实际形状如何，都将转换为 1-D 数组。
x(M,) 或 (M, K) array_like
用于相乘的矩阵。
check_finitebool，可选
是否检查输入矩阵是否仅包含有限数字。禁用可能会提高性能，但如果输入包含无穷大或 NaN，则可能会出现问题（结果完全为 NaN）。
workersint，可选
传递给 scipy.fft.fft 和 ifft。用于并行计算的最大工作人数。如果为负数，则该值从 os.cpu_count() 循环。有关更多详细信息，请参阅 scipy.fft.fft。
返回：
T @ x(M,) 或 (M, K) ndarray
矩阵乘积 T @ x 的结果。返回的形状与 x 的形状相匹配。
另请参阅
toeplitz
Toeplitz 矩阵
solve_toeplitz
使用 Levinson 递归解决 Toeplitz 系统
注意
Toeplitz 矩阵嵌入在循环矩阵中，并使用 FFT 高效计算矩阵乘积。
由于计算基于 FFT，整数输入将产生浮点输出。这与 NumPy 的 matmul 不同，后者保留输入的数据类型。
这部分基于可以在 [1] 找到的实现，根据 MIT 许可证授权。有关该方法的更多信息，请参考参考文献 [2]。参考文献 [3] 和 [4] 中有更多 Python 的参考实现。
版本 1.6.0 中的新功能。
参考文献
[1]
Jacob R Gardner，Geoff Pleiss，David Bindel，Kilian Q Weinberger，Andrew Gordon Wilson，“GPyTorch：带 GPU 加速的黑盒矩阵-矩阵高斯过程推断”，Max Balandat 和 Ruihan Wu 有贡献。在线可用：github.com/cornellius-gp/gpytorch
[2]
J. Demmel, P. Koev, 和 X. Li, “直接线性求解器简要概述”. 在 Z. Bai, J. Demmel, J. Dongarra, A. Ruhe, 和 H. van der Vorst 编辑的书籍《代数特征值问题解法模板：实用指南》中. SIAM, 费城, 2000. 可在：www.netlib.org/utk/people/JackDongarra/etemplates/node384.html 获得。
[3]
R. Scheibler, E. Bezzam, I. Dokmanic, Pyroomacoustics：用于音频房间模拟和阵列处理算法的 Python 包, IEEE ICASSP 会议论文集, 加拿大卡尔加里, 2018. github.com/LCAV/pyroomacoustics/blob/pypi-release/ pyroomacoustics/adaptive/util.py
[4]
Marano S, Edwards B, Ferrari G 和 Fah D (2017), “拟合地震谱：有色噪声和不完整数据”, 美国地震学会通报.，2017 年 1 月，第 107 卷(1)，第 276-291 页。
示例
将 Toeplitz 矩阵 T 与矩阵 x 相乘：
[ 1 -1 -2 -3] [1 10]
T = [ 3 1 -1 -2] x = [2 11]
[ 6 3 1 -1] [2 11]
[10 6 3 1] [5 19]
要指定 Toeplitz 矩阵，只需第一列和第一行即可。
>>> import numpy as np
>>> c = np.array([1, 3, 6, 10]) # First column of T
>>> r = np.array([1, -1, -2, -3]) # First row of T
>>> x = np.array([[1, 10], [2, 11], [2, 11], [5, 19]])
>>> from scipy.linalg import toeplitz, matmul_toeplitz
>>> matmul_toeplitz((c, r), x)
array([[-20., -80.],
[ -7., -8.],
[ 9., 85.],
[ 33., 218.]])
通过创建完整的 Toeplitz 矩阵并将其与x相乘来检查结果。
>>> toeplitz(c, r) @ x
array([[-20, -80],
[ -7, -8],
[ 9, 85],
[ 33, 218]])
完整矩阵从未显式形成，因此这一例程适用于非常大的 Toeplitz 矩阵。
>>> n = 1000000
>>> matmul_toeplitz([1] + [0]*(n-1), np.ones(n))
array([1., 1., 1., ..., 1., 1., 1.])
scipy.linalg.det
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.det.html#scipy.linalg.det
scipy.linalg.det(a, overwrite_a=False, check_finite=True)
计算矩阵的行列式。
行列式是与相关方阵系数相关的标量。对于奇异矩阵，行列式值为零。
参数：
a(…, M, M) array_like
用于计算行列式的输入数组。
overwrite_abool, optional
允许在 a 中覆盖数据(可能会增强性能)。
check_finitebool, optional
是否检查输入矩阵仅包含有限数字。禁用此选项可能会带来性能提升，但如果输入确实包含无穷大或 NaN，可能会导致问题(崩溃、非终止)。
返回：
det(…) float or complex
a的行列式。对于堆叠数组，对输入的最后两个维度中的每个(m, m)切片返回一个标量。例如，形状为(p, q, m, m)的输入将产生形状为(p, q)的结果。如果所有维度都是 1，则无论 ndim 如何，都返回一个标量。
注意：
行列式通过使用 LAPACK 例程‘getrf’对输入执行 LU 分解，然后计算 U 因子的对角线条目的乘积。
即使输入数组是单精度(float32 或 complex64)，结果也将以双精度(float64 或 complex128)返回，以防止溢出。
示例：
>>> import numpy as np
>>> from scipy import linalg
>>> a = np.array([[1,2,3], [4,5,6], [7,8,9]]) # A singular matrix
>>> linalg.det(a)
0.0
>>> b = np.array([[0,2,3], [4,5,6], [7,8,9]])
>>> linalg.det(b)
3.0
>>> # An array with the shape (3, 2, 2, 2)
>>> c = np.array([[[[1., 2.], [3., 4.]],
... [[5., 6.], [7., 8.]]],
... [[[9., 10.], [11., 12.]],
... [[13., 14.], [15., 16.]]],
... [[[17., 18.], [19., 20.]],
... [[21., 22.], [23., 24.]]]])
>>> linalg.det(c) # The resulting shape is (3, 2)
array([[-2., -2.],
[-2., -2.],
[-2., -2.]])
>>> linalg.det(c[0, 0]) # Confirm the (0, 0) slice, [[1, 2], [3, 4]]
-2.0
scipy.linalg.norm
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.norm.html#scipy.linalg.norm
scipy.linalg.norm(a, ord=None, axis=None, keepdims=False, check_finite=True)
矩阵或向量的范数。
该函数能够返回八种不同的矩阵范数或无穷多种向量范数（如下所述），具体取决于ord参数的值。对于秩不同于 1 或 2 的张量，仅支持ord=None。
参数：
aarray_like
输入数组。如果axis为 None，则a必须为 1-D 或 2-D，除非ord为 None。如果axis和ord都为 None，则将返回a.ravel的 2-范数。
ord，可选
范数的顺序（见Notes表）。inf 表示 NumPy 的inf对象。
axis, optional
如果axis是一个整数，则指定要沿着a的轴计算向量范数。如果axis是一个 2 元组，则指定保持 2-D 矩阵的轴，并计算这些矩阵的矩阵范数。如果axis为 None，则在a为 1-D 时返回向量范数，在a为 2-D 时返回矩阵范数。
keepdimsbool, optional
如果设置为 True，则规范化的轴将保留在结果中作为大小为一的维度。使用此选项，结果将正确地对原始a广播。
check_finitebool, optional
是否检查输入矩阵仅包含有限数。禁用可能会提高性能，但如果输入确实包含无穷大或 NaN，则可能会导致问题（崩溃、非终止）。
返回：
nfloat 或 ndarray
矩阵或向量的范数。
注记
对于ord <= 0的值，严格来说，结果并不是数学上的‘范数’，但在各种数值目的中仍可能有用。
可以计算以下范数：
| ord | 矩阵的范数 | 向量的范数 |
|---|---|---|
| None | 弗罗贝尼乌斯范数 | 2-范数 |
| ‘fro’ | 弗罗贝尼乌斯范数 | – |
| ‘nuc’ | 核范数 | – |
| inf | 最大(sum(abs(a), axis=1)) | max(abs(a)) |
| -inf | min(sum(abs(a), axis=1)) | min(abs(a)) |
| 0 | – | sum(a != 0) |
| 1 | 最大(sum(abs(a), axis=0)) | 如下 |
| -1 | 最小(sum(abs(a), axis=0)) | 如下 |
| 2 | 2-范数（最大奇异值） | 如下 |
| -2 | 最小奇异值 | 如下 |
| other | – | sum(abs(a)ord)(1./ord) |
弗罗贝尼乌斯范数由[1]给出：
(||A||F = [\sum abs(a_{i,j})²]^{1/2})
核范数是奇异值的总和。
弗罗贝尼乌斯和核范数的顺序仅适用于矩阵。
参考文献
[1]
G. H. Golub 和 C. F. Van Loan，《Matrix Computations》，Baltimore, MD, Johns Hopkins University Press, 1985，第 15 页
示例
>>> import numpy as np
>>> from scipy.linalg import norm
>>> a = np.arange(9) - 4.0
>>> a
array([-4., -3., -2., -1., 0., 1., 2., 3., 4.])
>>> b = a.reshape((3, 3))
>>> b
array([[-4., -3., -2.],
[-1., 0., 1.],
[ 2., 3., 4.]])
>>> norm(a)
7.745966692414834
>>> norm(b)
7.745966692414834
>>> norm(b, 'fro')
7.745966692414834
>>> norm(a, np.inf)
4
>>> norm(b, np.inf)
9
>>> norm(a, -np.inf)
0
>>> norm(b, -np.inf)
2
>>> norm(a, 1)
20
>>> norm(b, 1)
7
>>> norm(a, -1)
-4.6566128774142013e-010
>>> norm(b, -1)
6
>>> norm(a, 2)
7.745966692414834
>>> norm(b, 2)
7.3484692283495345
>>> norm(a, -2)
0
>>> norm(b, -2)
1.8570331885190563e-016
>>> norm(a, 3)
5.8480354764257312
>>> norm(a, -3)
0
scipy.linalg.lstsq
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.lstsq.html#scipy.linalg.lstsq
scipy.linalg.lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False, check_finite=True, lapack_driver=None)
计算方程 Ax = b 的最小二乘解。
计算向量 x，使得二范数 |b - A x| 最小化。
参数：
a(M, N) array_like
左手边数组
b(M,) or (M, K) array_like
右手边数组
condfloat, optional
用于确定 a 的有效秩的‘小’奇异值的截断值。小于 cond * largest_singular_value 的奇异值被视为零。
overwrite_abool, optional
丢弃 a 中的数据（可能增强性能）。默认为 False。
overwrite_bbool, optional
丢弃 b 中的数据（可能增强性能）。默认为 False。
check_finitebool, optional
是否检查输入矩阵仅包含有限数值。禁用可能会带来性能提升，但如果输入包含无穷大或 NaN，则可能会导致问题（崩溃，非终止）。
lapack_driverstr, optional
用于解决最小二乘问题的 LAPACK 驱动程序。选项有 'gelsd', 'gelsy', 'gelss'。默认 ('gelsd') 是一个很好的选择。但在许多问题上，'gelsy' 可能略快。'gelss' 曾被历史性地使用。它通常速度较慢但使用的内存较少。
新版本 0.17.0 中的新功能。
返回：
x(N,) or (N, K) ndarray
最小二乘解。
residues(K,) ndarray or float
对于 M > N 且 ndim(A) == n 中 b - a x 每列的二范数的平方（如果 b 是一维则返回标量）。否则返回形状为 (0,) 的数组。
rankint
a 的有效秩。
s(min(M, N),) ndarray or None
a 的奇异值。a 的条件数是 s[0] / s[-1]。
引发：
LinAlgError
如果计算不收敛。
ValueError
当参数不兼容时。
另请参阅
scipy.optimize.nnls
具有非负约束的线性最小二乘
注释
当使用 'gelsy' 作为驱动程序时，residues 被设置为形状为 (0,) 的数组，s 总是 None。
示例
>>> import numpy as np
>>> from scipy.linalg import lstsq
>>> import matplotlib.pyplot as plt
假设我们有以下数据：
>>> x = np.array([1, 2.5, 3.5, 4, 5, 7, 8.5])
>>> y = np.array([0.3, 1.1, 1.5, 2.0, 3.2, 6.6, 8.6])
我们希望拟合一个二次多项式 y = a + b*x**2 到这些数据上。我们首先形成“设计矩阵” M，其中包含一个全为 1 的常数列和一个包含 x**2 的列：
>>> M = x[:, np.newaxis]**[0, 2]
>>> M
array([[ 1\. , 1\. ],
[ 1\. , 6.25],
[ 1\. , 12.25],
[ 1\. , 16\. ],
[ 1\. , 25\. ],
[ 1\. , 49\. ],
[ 1\. , 72.25]])
我们希望找到最小二乘解来满足 M.dot(p) = y，其中 p 是一个长度为 2 的向量，包含参数 a 和 b。
>>> p, res, rnk, s = lstsq(M, y)
>>> p
array([ 0.20925829, 0.12013861])
绘制数据和拟合曲线。
>>> plt.plot(x, y, 'o', label='data')
>>> xx = np.linspace(0, 9, 101)
>>> yy = p[0] + p[1]*xx**2
>>> plt.plot(xx, yy, label='least squares fit, $y = a + bx²$')
>>> plt.xlabel('x')
>>> plt.ylabel('y')
>>> plt.legend(framealpha=1, shadow=True)
>>> plt.grid(alpha=0.25)
>>> plt.show()
scipy.linalg.pinv
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.pinv.html#scipy.linalg.pinv
scipy.linalg.pinv(a, *, atol=None, rtol=None, return_rank=False, check_finite=True, cond=<object object>, rcond=<object object>)
计算矩阵的（摩尔-彭罗斯）伪逆。
使用奇异值分解的经济模式 U @ S @ V 计算矩阵的广义逆，并仅选择与显著奇异值相关联的列/行。
如果 s 是 a 的最大奇异值，则显著性截止值由 atol + rtol * s 决定。任何低于此值的奇异值被认为是不显著的。
参数：
a(M, N) 数组类型
要伪逆的矩阵。
atolfloat, optional
绝对阈值项，默认值为 0。
从版本 1.7.0 新增。
rtolfloat, optional
相对阈值项，默认值为 max(M, N) * eps，其中 eps 是 a 数据类型的机器精度值。
从版本 1.7.0 新增。
return_rankbool, optional
如果为 True，则返回矩阵的有效秩。
check_finitebool, optional
是否检查输入矩阵仅包含有限数。禁用可能会带来性能提升，但如果输入确实包含无穷大或 NaN，则可能导致问题（崩溃、非终止）。
cond, rcondfloat, optional
在旧版本中，这些值被用作 atol 和 rtol=0。如果两者都给定，则 rcond 会覆盖 cond，因此代码是不正确的。因此，强烈建议使用上述的公差。
自版本 1.7.0 起弃用：建议使用上述的 rtol 和 atol 参数，因此不再支持这些旧版本。事实上，如果提供了 atol 和 rtol，则这些关键字将优先于这些。
在版本 1.3.0 中更改：先前的默认截止值只是 eps*f，其中 f 是单精度为 1e3，双精度为 1e6。
返回：
B(N, M) ndarray
矩阵 a 的伪逆。
rankint
矩阵的有效秩。如果 return_rank 为 True，则返回。
Raises：
LinAlgError
如果 SVD 计算不收敛。
另请参阅
pinvh
Hermitian 矩阵的摩尔-彭罗斯伪逆。
注意事项
如果 A 可逆，则摩尔-彭罗斯伪逆恰好是 A 的逆 [1]。如果 A 不可逆，则摩尔-彭罗斯伪逆计算满足 Ax = b 且使 ||Ax - b|| 最小化的 x 解 [1]。
参考文献
[1] (1,2,3)
Penrose, R. (1956). On best approximate solutions of linear matrix equations. Mathematical Proceedings of the Cambridge Philosophical Society, 52(1), 17-19. doi:10.1017/S0305004100030929
示例
给定一个 m x n 矩阵 A 和一个 n x m 矩阵 B，四个摩尔-彭罗斯条件是：
-
ABA = A(B是A的广义逆）， -
BAB = B(A是B的广义逆)， -
(AB)* = AB(AB是埃尔米特矩阵)， -
(BA)* = BA(BA是埃尔米特矩阵) [1].
这里，A* 表示共轭转置。摩尔-彭罗斯伪逆 B 满足所有这四个条件，并且对于任意的 A 都存在。需要注意的是，与标准矩阵逆不同的是，A 并不必是方阵或具有线性独立的列/行。
举例来说，我们可以计算一个随机的非方阵的摩尔-彭罗斯伪逆，并验证它满足这四个条件。
>>> import numpy as np
>>> from scipy import linalg
>>> rng = np.random.default_rng()
>>> A = rng.standard_normal((9, 6))
>>> B = linalg.pinv(A)
>>> np.allclose(A @ B @ A, A) # Condition 1
True
>>> np.allclose(B @ A @ B, B) # Condition 2
True
>>> np.allclose((A @ B).conj().T, A @ B) # Condition 3
True
>>> np.allclose((B @ A).conj().T, B @ A) # Condition 4
True
scipy.linalg.pinvh
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.pinvh.html#scipy.linalg.pinvh
scipy.linalg.pinvh(a, atol=None, rtol=None, lower=True, return_rank=False, check_finite=True)
计算（摩尔-彭罗斯）矩阵的伪逆。
使用复数埃尔米特/实对称矩阵的特征值分解计算广义逆，并包括所有具有“大”绝对值的特征值。
参数：
a(N, N) 类似数组
要伪逆的实对称或复数埃尔米特矩阵
atol浮点数，可选项
绝对阈值项，默认值为 0。
新版本为 1.7.0。
rtol浮点数，可选项
相对阈值项，默认值为N * eps，其中eps为a数据类型的机器精度值。
新版本为 1.7.0。
lower布尔值，可选项
指定是否从a的下三角或上三角获取相关数组数据。（默认值：下三角）
return_rank布尔值，可选项
如果为 True，返回矩阵的有效秩。
check_finite布尔值，可选项
是否检查输入矩阵仅包含有限数。禁用可能会提高性能，但如果输入确实包含无穷大或 NaN，则可能导致问题（崩溃、非终止）。
返回：
B(N, N) ndarray
矩阵a的伪逆。
rank整数
矩阵的有效秩。如果return_rank为 True，则返回。
引发：
LinAlgError
如果特征值算法不收敛。
另请参见
矩阵的摩尔-彭罗斯伪逆。
示例
有关更详细的示例，请参见pinv。
>>> import numpy as np
>>> from scipy.linalg import pinvh
>>> rng = np.random.default_rng()
>>> a = rng.standard_normal((9, 6))
>>> a = np.dot(a, a.T)
>>> B = pinvh(a)
>>> np.allclose(a, a @ B @ a)
True
>>> np.allclose(B, B @ a @ B)
True
scipy.linalg.kron
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.kron.html#scipy.linalg.kron
scipy.linalg.kron(a, b)
克罗内克积。
结果是块状矩阵：
a[0,0]*b a[0,1]*b ... a[0,-1]*b
a[1,0]*b a[1,1]*b ... a[1,-1]*b
...
a[-1,0]*b a[-1,1]*b ... a[-1,-1]*b
参数：
a(M, N) ndarray
输入数组
b(P, Q) ndarray
输入数组
返回：
A(MP, NQ) ndarray
a 和 b 的克罗内克积。
示例
>>> from numpy import array
>>> from scipy.linalg import kron
>>> kron(array([[1,2],[3,4]]), array([[1,1,1]]))
array([[1, 1, 1, 2, 2, 2],
[3, 3, 3, 4, 4, 4]])
scipy.linalg.khatri_rao
scipy.linalg.khatri_rao(a, b)
Khatri-Rao 乘积
两个矩阵的列向 Kronecker 乘积
参数：
a(n, k) 数组型
输入数组
b(m, k) 数组型
输入数组
返回：
c: (n*m, k) ndarray
a 和 b 的 Khatri-Rao 乘积。
另见
kron
Kronecker 乘积
注意
Khatri-Rao 乘积的数学定义如下：
[(A_{ij} \bigotimes B_{ij})_{ij}]
即 A 和 B 的每列的 Kronecker 乘积，例如：
c = np.vstack([np.kron(a[:, k], b[:, k]) for k in range(b.shape[1])]).T
示例
>>> import numpy as np
>>> from scipy import linalg
>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> b = np.array([[3, 4, 5], [6, 7, 8], [2, 3, 9]])
>>> linalg.khatri_rao(a, b)
array([[ 3, 8, 15],
[ 6, 14, 24],
[ 2, 6, 27],
[12, 20, 30],
[24, 35, 48],
[ 8, 15, 54]])
scipy.linalg.tril
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.tril.html#scipy.linalg.tril
scipy.linalg.tril(m, k=0)
自 1.11.0 版本起已弃用：tril 已被numpy.tril 取代，将在 SciPy 1.13.0 中移除。
复制矩阵，并将第 k 个对角线以上的元素置零。
参数：
marray_like
要返回其元素的矩阵
kint，可选
对角线上方要置零的元素。k == 0 是主对角线，k < 0 是次对角线，k > 0 是超对角线。
返回值：
trilndarray
返回值与m相同的形状和类型。
示例
>>> from scipy.linalg import tril
>>> tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
array([[ 0, 0, 0],
[ 4, 0, 0],
[ 7, 8, 0],
[10, 11, 12]])
scipy.linalg.triu
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.triu.html#scipy.linalg.triu
scipy.linalg.triu(m, k=0)
自版本 1.11.0 起已弃用：tril 已弃用，推荐使用 numpy.triu，并且将在 SciPy 1.13.0 中移除。
复制一个矩阵，使得第 k 条对角线以下的元素为零。
参数:
m array_like
要返回其元素的矩阵
k 整数，可选
需要将元素置零的对角线下标。k == 0 是主对角线，k < 0 是次对角线，k > 0 是超对角线。
返回：
triu 数组
返回一个矩阵，该矩阵的第 k 条对角线以下的元素为零，并且与m具有相同的形状和类型。
示例
>>> from scipy.linalg import triu
>>> triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 0, 8, 9],
[ 0, 0, 12]])
scipy.linalg.orthogonal_procrustes
scipy.linalg.orthogonal_procrustes(A, B, check_finite=True)
计算正交 Procrustes 问题的矩阵解。
给定形状相同的矩阵 A 和 B，使用给定的算法找到一个最接近将 A 映射到 B 的正交矩阵 R，详见 [1]。
参数：
A(M, N) array_like
要映射的矩阵。
B(M, N) array_like
目标矩阵。
check_finitebool，可选
是否检查输入矩阵是否只包含有限数字。禁用可能会提高性能，但如果输入包含无穷大或 NaN，则可能导致问题（崩溃、非终止）。
返回：
R(N, N) ndarray
正交 Procrustes 问题的矩阵解。最小化 (A @ R) - B 的 Frobenius 范数，满足 R.T @ R = I。
scalefloat
A.T @ B的奇异值之和。
抛出异常：
ValueError
如果输入数组的形状不匹配，或者如果 check_finite 为 True 并且数组包含 Inf 或 NaN。
注释
注意，与空间数据的高级 Procrustes 分析不同，此函数仅使用正交变换如旋转和反射，不使用缩放或平移。
自版本 0.15.0 新增。
参考文献
[1]
Peter H. Schonemann，“正交 Procrustes 问题的广义解”，Psychometrica – Vol. 31，No. 1，March，1966。DOI:10.1007/BF02289451
示例
>>> import numpy as np
>>> from scipy.linalg import orthogonal_procrustes
>>> A = np.array([[ 2, 0, 1], [-2, 0, 0]])
翻转列的顺序并检查反对角线映射
>>> R, sca = orthogonal_procrustes(A, np.fliplr(A))
>>> R
array([[-5.34384992e-17, 0.00000000e+00, 1.00000000e+00],
[ 0.00000000e+00, 1.00000000e+00, 0.00000000e+00],
[ 1.00000000e+00, 0.00000000e+00, -7.85941422e-17]])
>>> sca
9.0
scipy.linalg.matrix_balance
scipy.linalg.matrix_balance(A, permute=True, scale=True, separate=False, overwrite_a=False)
计算行/列平衡的对角相似变换。
平衡试图通过应用相似变换来使行和列的 1-范数相等，以反映矩阵条目的幅度变化到缩放矩阵中。
此外，如果启用，矩阵首先被置换以隔离矩阵的上三角部分，再次如果启用缩放，则仅对剩余的子块进行缩放。
平衡矩阵满足以下等式
[B = T^{-1} A T]
缩放系数被近似为最接近的 2 的幂，以避免舍入误差。
参数：
A(n, n) 类似数组
平衡的方阵数据。
permute布尔型，可选
选择器，用于定义在缩放之前是否对 A 进行置换。
scale布尔型，可选
选择器，用于打开和关闭缩放。如果为 False，则矩阵不会被缩放。
separate布尔型，可选
这会从返回变换的完整矩阵切换为两个独立的 1 维置换和缩放数组的元组。
overwrite_a布尔型，可选
这直接传递给 xGEBAL。本质上，它覆盖了数据的结果。它可能会提高空间效率。有关详细信息，请参阅 LAPACK 手册。默认为 False。
返回：
B(n, n) ndarray
平衡后的矩阵
T(n, n) ndarray
可能经过置换的对角矩阵，其非零元素为 2 的整数幂，以避免数值截断误差。
scale, perm(n,) ndarray
如果 separate 关键字设置为 True，则不使用上述数组 T，而是将缩放和置换向量分别给出为一个元组，而不分配完整的数组 T。
注意事项
这种算法在特征值和矩阵分解中特别有用，并且在许多情况下已经由各种 LAPACK 例程调用。
该算法基于众所周知的技术[1]，并已修改以考虑特殊情况。参见[2]以了解自 LAPACK v3.5.0 以来已实施的细节。在此版本之前，有些特例情况下，平衡实际上可能会恶化条件。参见[3]了解此类示例。
此代码是对 LAPACK 的 xGEBAL 程序包围器，用于矩阵平衡。
从版本 0.19.0 开始新增。
参考文献
[1]
B.N. Parlett 和 C. Reinsch，“平衡矩阵以计算特征值和特征向量”，Numerische Mathematik，Vol.13(4)，1969 年，DOI:10.1007/BF02165404
[2]
R. James, J. Langou, B.R. Lowery，“矩阵平衡和特征向量计算”，2014 年，arXiv:1401.5766
[3]
D.S. Watkins. 平衡有害的案例。 电子。 数值分析交易，第 23 卷，2006 年。
例子
>>> import numpy as np
>>> from scipy import linalg
>>> x = np.array([[1,2,0], [9,1,0.01], [1,2,10*np.pi]])
>>> y, permscale = linalg.matrix_balance(x)
>>> np.abs(x).sum(axis=0) / np.abs(x).sum(axis=1)
array([ 3.66666667, 0.4995005 , 0.91312162])
>>> np.abs(y).sum(axis=0) / np.abs(y).sum(axis=1)
array([ 1.2 , 1.27041742, 0.92658316]) # may vary
>>> permscale # only powers of 2 (0.5 == 2^(-1))
array([[ 0.5, 0\. , 0\. ], # may vary
[ 0\. , 1\. , 0\. ],
[ 0\. , 0\. , 1\. ]])
scipy.linalg.subspace_angles
scipy.linalg.subspace_angles(A, B)
计算两个矩阵之间的子空间角度。
参数：
A(M, N) array_like
第一个输入数组。
B(M, K) array_like
第二个输入数组。
返回：
anglesndarray，形状为(min(N, K),)
A和B的列空间之间的子空间角度按降序排列。
参见
注意事项
根据提供在[1]中的公式计算子空间角度。为了与 MATLAB 和 Octave 行为等效，请使用angles[0]。
自 1.0 版本开始新增。
参考
[1]
Knyazev A, Argentati M (2002) Principal Angles between Subspaces in an A-Based Scalar Product: Algorithms and Perturbation Estimates. SIAM J. Sci. Comput. 23:2008-2040.
示例
一个哈达玛矩阵，其具有正交列，因此我们期望子空间角为 (\frac{\pi}{2})：
>>> import numpy as np
>>> from scipy.linalg import hadamard, subspace_angles
>>> rng = np.random.default_rng()
>>> H = hadamard(4)
>>> print(H)
[[ 1 1 1 1]
[ 1 -1 1 -1]
[ 1 1 -1 -1]
[ 1 -1 -1 1]]
>>> np.rad2deg(subspace_angles(H[:, :2], H[:, 2:]))
array([ 90., 90.])
并且矩阵到自身的子空间角应为零：
>>> subspace_angles(H[:, :2], H[:, :2]) <= 2 * np.finfo(float).eps
array([ True, True], dtype=bool)
非正交子空间之间的角度处于这些极端之间：
>>> x = rng.standard_normal((4, 3))
>>> np.rad2deg(subspace_angles(x[:, :2], x[:, [2]]))
array([ 55.832]) # random
scipy.linalg.bandwidth
scipy.linalg.bandwidth(a)
返回一个二维数值数组的下界和上界带宽。
参数：
ndarray（数组）
输入大小为（N，M）的数组
返回：
lu元组
2-tuple of ints indicating the lower and upper bandwidth. A zero denotes no sub- or super-diagonal on that side (triangular), and, say for N rows (N-1) means that side is full. Same example applies to the upper triangular part with (M-1).
Raises:
TypeError
如果数组的 dtype 不受支持，特别是 NumPy 的 float16，float128 和 complex256 dtypes。
Notes
这个辅助函数简单地遍历数组，查找非零条目，无论数组中是否存在带状结构。因此，性能取决于非零条目的密度和内存布局。Fortran 或 C 连续数组处理最佳，否则会遭受额外的随机内存访问成本。
策略是分别查找上三角部分和下三角部分中仅未测试的带元素；根据内存布局，我们可以逐行或逐列扫描。此外，例如我们正在扫描行，并且在第 6 行，第 4 个条目不为零，则在后续行中，仅在该带条目处进行水平搜索，因为我们知道该带已被占用。因此，完全密集矩阵扫描的成本是按照 n 的顺序。
Examples
>>> import numpy as np
>>> from scipy.linalg import bandwidth
>>> A = np.array([[3., 0., 0., 0., 0.],
... [0., 4., 0., 0., 0.],
... [0., 0., 5., 1., 0.],
... [8., 0., 0., 6., 2.],
... [0., 9., 0., 0., 7.]])
>>> bandwidth(A)
(3, 1)
scipy.linalg.issymmetric
scipy.linalg.issymmetric(a, atol=None, rtol=None)
检查方阵是否对称。
参数：
andarray
尺寸为 (N, N) 的输入数组。
atol 浮点数，可选
绝对误差界限
rtol 浮点数，可选
相对误差界限
返回：
symbool
如果数组对称，则返回 True。
引发：
类型错误
如果数组的 dtype 不受支持，特别是 NumPy 中的 float16、float128 和 complex256 dtypes 用于精确比较。
另请参见
ishermitian
检查方阵是否是 Hermitean
注：
对于空方阵，按照约定返回 True 的结果。复数值数组测试对称性而不是 Hermitean（参见示例）
不扫描数组的对角线。因此，如果对角线上存在无限大、NaN 或类似的问题条目，则将被忽略。然而，numpy.inf 将被视为一个数字，也就是说 [[1, inf], [inf, 2]] 将返回 True。另一方面，numpy.nan 永远不是对称的，例如，[[1, nan], [nan, 2]] 将返回 False。
当 atol 和/或 rtol 被设置为，那么比较将由 numpy.allclose 执行，并且容差值将传递给它。否则，内部函数将执行针对零的精确比较。因此，性能可能会因数组的大小和 dtype 而改善或恶化。如果给定了 atol 或 rtol 中的一个，则另一个自动设置为零。
示例
>>> import numpy as np
>>> from scipy.linalg import issymmetric
>>> A = np.arange(9).reshape(3, 3)
>>> A = A + A.T
>>> issymmetric(A)
True
>>> Ac = np.array([[1. + 1.j, 3.j], [3.j, 2.]])
>>> issymmetric(Ac) # not Hermitian but symmetric
True
scipy.linalg.ishermitian
scipy.linalg.ishermitian(a, atol=None, rtol=None)
检查方形 2D 数组是否为 Hermite 矩阵。
参数：
andarray
输入大小为(N, N)的数组
atolfloat，可选
绝对误差界限
rtolfloat，可选
相对误差界限
返回：
herbool
如果数组是 Hermite 矩阵，则返回 True。
抛出：
类型错误
如果数组的 dtype 不受支持，特别是 NumPy 的 float16、float128 和 complex256 dtypes。
另请参阅
issymmetric
检查方形 2D 数组是否对称
注意
对于方形空数组，按照惯例结果返回 True。
numpy.inf将被视为数字，也就是说[[1, inf], [inf, 2]]将返回True。另一方面，numpy.nan从不对称，例如[[1, nan], [nan, 2]]将返回False。
当设置了atol和/或rtol时，则通过numpy.allclose进行比较，并将容差值传递给它。否则，内部函数执行针对零的精确比较。因此，性能根据数组的大小和 dtype 可能会提高或降低。如果给定atol或rtol中的一个，则另一个自动设置为零。
示例
>>> import numpy as np
>>> from scipy.linalg import ishermitian
>>> A = np.arange(9).reshape(3, 3)
>>> A = A + A.T
>>> ishermitian(A)
True
>>> A = np.array([[1., 2. + 3.j], [2. - 3.j, 4.]])
>>> ishermitian(A)
True
>>> Ac = np.array([[1. + 1.j, 3.j], [3.j, 2.]])
>>> ishermitian(Ac) # not Hermitian but symmetric
False
>>> Af = np.array([[0, 1 + 1j], [1 - (1+1e-12)*1j, 0]])
>>> ishermitian(Af)
False
>>> ishermitian(Af, atol=5e-11) # almost hermitian with atol
True
scipy.linalg.LinAlgError
exception scipy.linalg.LinAlgError
由 linalg 函数引发的基本 Python 异常对象。
通用目的的异常类，派生自 Python 的 ValueError 类，在 linalg 函数中以编程方式引发，当线性代数相关条件会阻止函数进一步正确执行时。
Parameters:
None
Examples
>>> from numpy import linalg as LA
>>> LA.inv(np.zeros((2,2)))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "...linalg.py", line 350,
in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
File "...linalg.py", line 249,
in solve
raise LinAlgError('Singular matrix')
numpy.linalg.LinAlgError: Singular matrix
with_traceback()
Exception.with_traceback(tb) – 将 self.traceback 设置为 tb 并返回 self。
scipy.linalg.LinAlgWarning
exception scipy.linalg.LinAlgWarning
当线性代数相关操作接近算法失效条件或预计精度损失时发出警告。
with_traceback()
Exception.with_traceback(tb) – 将 self.traceback 设置为 tb 并返回 self。
scipy.linalg.eig
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.eig.html#scipy.linalg.eig
scipy.linalg.eig(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False, check_finite=True, homogeneous_eigvals=False)
解一个方阵的普通或广义特征值问题。
寻找一般矩阵的特征值 w 和右特征向量或左特征向量：
a vr[:,i] = w[i] b vr[:,i]
a.H vl[:,i] = w[i].conj() b.H vl[:,i]
其中.H是共轭转置。
参数：
a(M, M) array_like
将计算其特征值和特征向量的复数或实数矩阵。
b(M, M) array_like, optional
广义特征值问题中的右手边矩阵。默认为 None，假定为单位矩阵。
leftbool, optional
是否计算并返回左特征向量。默认为 False。
rightbool, optional
是否计算并返回右特征向量。默认为 True。
overwrite_abool, optional
是否覆盖a；可能会提高性能。默认为 False。
overwrite_bbool, optional
是否覆盖b；可能会提高性能。默认为 False。
check_finitebool, optional
是否检查输入矩阵只包含有限数字。禁用可能会提高性能，但如果输入包含无穷大或 NaN，可能会导致问题（崩溃、非终止）。
homogeneous_eigvalsbool, optional
如果为 True，则以齐次坐标返回特征值。在这种情况下，w是一个(2, M)的数组，使得：
w[1,i] a vr[:,i] = w[0,i] b vr[:,i]
默认为 False。
返回：
w(M,)或(2, M)的双精度或复数 ndarray
每个特征值根据其重数重复。形状为(M,)，除非homogeneous_eigvals=True。
vl(M, M)的双精度或复数 ndarray
与特征值w[i]对应的左特征向量是列vl[:,i]。仅在left=True时返回。左特征向量未归一化。
vr(M, M)的双精度或复数 ndarray
与特征值w[i]对应的归一化右特征向量是列vr[:,i]。仅在right=True时返回。
Raises:
LinAlgError
如果特征值计算未收敛。
另请参阅
一般数组的特征值
对称/Hermitian 数组的特征值和右特征向量。
对称/Hermitian 带状矩阵的特征值和右特征向量
对称/Hermitian 三对角矩阵的特征值和右特征向量
示例
>>> import numpy as np
>>> from scipy import linalg
>>> a = np.array([[0., -1.], [1., 0.]])
>>> linalg.eigvals(a)
array([0.+1.j, 0.-1.j])
>>> b = np.array([[0., 1.], [1., 1.]])
>>> linalg.eigvals(a, b)
array([ 1.+0.j, -1.+0.j])
>>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]])
>>> linalg.eigvals(a, homogeneous_eigvals=True)
array([[3.+0.j, 8.+0.j, 7.+0.j],
[1.+0.j, 1.+0.j, 1.+0.j]])
>>> a = np.array([[0., -1.], [1., 0.]])
>>> linalg.eigvals(a) == linalg.eig(a)[0]
array([ True, True])
>>> linalg.eig(a, left=True, right=False)[1] # normalized left eigenvector
array([[-0.70710678+0.j , -0.70710678-0.j ],
[-0\. +0.70710678j, -0\. -0.70710678j]])
>>> linalg.eig(a, left=False, right=True)[1] # normalized right eigenvector
array([[0.70710678+0.j , 0.70710678-0.j ],
[0\. -0.70710678j, 0\. +0.70710678j]])
