SciPy 1.12 中文文档（十三）

原文：docs.scipy.org/doc/scipy-1.12.0/index.html

`scipy.interpolate.RectSphereBivariateSpline`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.RectSphereBivariateSpline.html#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。

另请参阅

BivariateSpline

用于双变量样条的基类。

UnivariateSpline

用于拟合给定数据点的平滑单变量样条。

SmoothBivariateSpline

平滑拟合给定点的双变量样条

LSQBivariateSpline

使用加权最小二乘拟合的双变量样条

SmoothSphereBivariateSpline

在球面坐标中的平滑双变量样条

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()

../../_images/scipy-interpolate-RectSphereBivariateSpline-1_00_00.png

选择最优值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()

../../_images/scipy-interpolate-RectSphereBivariateSpline-1_01_00.png

方法

`__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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.BivariateSpline.html#scipy.interpolate.BivariateSpline

class scipy.interpolate.BivariateSpline

双变量样条的基类

这描述了在给定数据点(x, y, z)上从矩形[xb, xe] * [yb, ye]计算的kx和ky度数的样条s(x, y)。

这个类被设计成作为子类使用，不直接实例化。要构建这些样条，请调用SmoothBivariateSpline、LSQBivariateSpline 或 RectBivariateSpline。

另请参见

UnivariateSpline

用于拟合给定数据点的平滑单变量样条

SmoothBivariateSpline

通过给定点平滑的双变量样条

LSQBivariateSpline

使用加权最小二乘拟合的双变量样条

RectSphereBivariateSpline

球上矩形网格的双变量样条

SmoothSphereBivariateSpline

在球坐标中平滑的双变量样条

LSQSphereBivariateSpline

使用加权最小二乘拟合的球坐标中的双变量样条

RectBivariateSpline

一个在矩形网格上的双变量样条

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.SmoothBivariateSpline`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.SmoothBivariateSpline.html#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`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.SmoothSphereBivariateSpline.html#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。

另请参阅

BivariateSpline

双变量样条的基类。

UnivariateSpline

用来拟合给定数据点的平滑单变量样条。

SmoothBivariateSpline

通过给定点进行平滑的双变量样条

LSQBivariateSpline

使用加权最小二乘拟合的双变量样条

RectSphereBivariateSpline

在球上矩形网格上的双变量样条

LSQSphereBivariateSpline

使用加权最小二乘拟合在球坐标中的双变量样条

RectBivariateSpline

在矩形网格上的双变量样条。

bisplrep

找到表面的双变量 B 样条表示的函数

bisplev

评估双变量 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()

../../_images/scipy-interpolate-SmoothSphereBivariateSpline-1.png

方法

`__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`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.LSQBivariateSpline.html#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。

另请参阅

BivariateSpline

用于双变量样条的基类。

UnivariateSpline

平滑的一维样条以适应给定的数据点集。

SmoothBivariateSpline

通过给定点的平滑双变量样条

RectSphereBivariateSpline

球面上矩形网格上的双变量样条

SmoothSphereBivariateSpline

在球面坐标中的平滑双变量样条

LSQSphereBivariateSpline

使用加权最小二乘拟合的球面坐标中的双变量样条

RectBivariateSpline

矩形网格上的双变量样条。

bisplrep

用于找到表面的双变量 B 样条表示的函数

bisplev

评估双变量 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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.LSQSphereBivariateSpline.html#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()

../../_images/scipy-interpolate-LSQSphereBivariateSpline-1.png

方法

`__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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.bisplrep.html#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`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.bisplev.html#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`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.lagrange.html#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()

../../_images/scipy-interpolate-lagrange-1.png

`scipy.interpolate.approximate_taylor_polynomial`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.approximate_taylor_polynomial.html#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()

../../_images/scipy-interpolate-approximate_taylor_polynomial-1.png

`scipy.interpolate.pade`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.pade.html#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`）

原文：docs.scipy.org/doc/scipy-1.12.0/reference/io.html

SciPy 提供许多模块、类和函数，用于读取和写入多种文件格式的数据。

另请参阅

NumPy IO routines

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’, ‘w’}，可选

读写模式，默认为‘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`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.FortranEOFError.html#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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.FortranFormattingError.html#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’, ‘w’, ‘a’}，可选

读写追加模式，默认为‘r’

内存映射无或布尔值，可选

是否在读取时将文件名进行内存映射。当文件名是文件名时，默认为 True，当文件名是类文件对象时，默认为 False。请注意，当使用内存映射时，返回的数据数组直接引用磁盘上的 mmapped 数据，并且只要存在对它的引用，文件就不能关闭。

版本{1, 2}，可选

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-1-12-中文文档-十三-

SciPy 1.12 中文文档（十三）

scipy.interpolate.RectSphereBivariateSpline

scipy.interpolate.BivariateSpline

scipy.interpolate.SmoothBivariateSpline

scipy.interpolate.SmoothSphereBivariateSpline

scipy.interpolate.LSQBivariateSpline

scipy.interpolate.LSQSphereBivariateSpline

scipy.interpolate.bisplrep

scipy.interpolate.bisplev

scipy.interpolate.lagrange

scipy.interpolate.approximate_taylor_polynomial

scipy.interpolate.pade

输入输出（scipy.io）

MATLAB® 文件

IDL® 文件

Matrix Market 文件

无格式的 Fortran 文件

Netcdf

Harwell-Boeing 文件

Wav 音频文件 (scipy.io.wavfile)

scipy.io.loadmat

scipy.io.savemat

scipy.io.whosmat

scipy.io.readsav

scipy.io.mminfo

scipy.io.mmread

scipy.io.mmwrite

scipy.io.FortranFile

scipy.io.FortranEOFError

scipy.io.FortranFormattingError

scipy.io.netcdf_file

`scipy.interpolate.RectSphereBivariateSpline`

`scipy.interpolate.BivariateSpline`

`scipy.interpolate.SmoothBivariateSpline`

`scipy.interpolate.SmoothSphereBivariateSpline`

`scipy.interpolate.LSQBivariateSpline`

`scipy.interpolate.LSQSphereBivariateSpline`

`scipy.interpolate.bisplrep`

`scipy.interpolate.bisplev`

`scipy.interpolate.lagrange`

`scipy.interpolate.approximate_taylor_polynomial`

`scipy.interpolate.pade`

输入输出（`scipy.io`）

Wav 音频文件 (`scipy.io.wavfile`)

`scipy.io.loadmat`

`scipy.io.savemat`

`scipy.io.whosmat`

`scipy.io.readsav`

`scipy.io.mminfo`

`scipy.io.mmread`

`scipy.io.mmwrite`

`scipy.io.FortranFile`

`scipy.io.FortranEOFError`

`scipy.io.FortranFormattingError`

`scipy.io.netcdf_file`