SciPy库详解：从优化到信号处理

5星 · 超过95%的资源需积分: 48 29 浏览量更新于2024-07-22 1 收藏 16.59MB PDF 举报

"Python scipy 说明文档是针对scipy库的详尽指南，适用于版本0.14.0。这份文档由scipy社区编写，涵盖了数值计算的各种功能，包括特殊函数、积分、优化、插值、傅里叶变换、信号处理、线性代数、稀疏矩阵计算、空间数据结构和算法、统计学、多维图像处理以及文件I/O等。此外，还包含了对贡献者的信息，如如何向scipy项目贡献代码、维护现有代码以及开发环境的设置建议。文档中还讨论了关于API导入的指导原则。" 在Python的科学计算领域，scipy是一个核心库，它提供了许多高级数学和科学计算的功能。以下是scipy库中各个模块的主要知识点： 1. **SciPy Tutorial**：这是对scipy库的基本介绍，适合初学者了解scipy的基础用法。 2. **特殊函数(scipy.special)**：包含大量特殊数学函数，如贝塞尔函数、伽马函数、错误函数等，这些函数在物理、工程和统计等领域广泛应用。 3. **积分(scipy.integrate)**：提供数值积分和微分方程求解方法，如quad函数用于一维积分，odeint函数用于常微分方程的解算。 4. **优化(scipy.optimize)**：包括各种优化算法，如最小化问题、根查找、线性规划等，有iminuit、curve_fit等功能用于参数拟合。 5. **插值(scipy.interpolate)**：提供不同类型的插值方法，如线性插值、样条插值，用于数据平滑和预测。 6. **傅里叶变换(scipy.fftpack)**：实现了快速傅里叶变换(FFT)，用于频域分析和信号处理。 7. **信号处理(scipy.signal)**：包含滤波器设计、信号分析、系统辨识等功能，如firwin函数用于设计有限 impulse response (FIR) 滤波器。 8. **线性代数(scipy.linalg)**：提供了矩阵操作和线性代数函数，如求解线性系统、特征值和特征向量计算等。 9. **稀疏矩阵计算(Arpack)**：支持稀疏矩阵的特征值问题求解，对于大型稀疏矩阵特别有用。 10. **压缩稀疏图算法(scipy.sparse.csgraph)**：处理稀疏图形数据，如最短路径、连通组件等。 11. **空间数据结构和算法(scipy.spatial)**：提供距离计算、KD树、voronoi图等空间数据处理工具。 12. **统计(scipy.stats)**：包含多种统计分布、假设检验、回归分析等统计函数。 13. **多维图像处理(scipy.ndimage)**：提供了对多维数组进行图像处理的函数，如滤波、形态学操作等。 14. **文件I/O(scipy.io)**：支持读写多种科学数据格式，如MATLAB文件、wav音频文件等。 15. **Weave模块(scipy.weave)**：允许将C/C++代码直接嵌入到Python中，提高性能。贡献者可以参考文档中的信息参与到scipy的开发中，通过编写新代码、维护现有代码或者提供其他形式的帮助。推荐的开发环境设置和API导入原则有助于保持代码的统一性和可维护性。

SciPy Reference Guide, Release 0.14.0

If the function to integrate takes additional parameters, the can be provided in the args argument. Suppose that the

following integral shall be calculated:

𝐼(𝑎, 𝑏) =



𝑎𝑥

+ 𝑏 𝑑𝑥.

This integral can be evaluated by using the following code:

>>> from scipy.integrate import quad

>>> def integrand(x, a, b):

... return a

x + b

>>> a = 2

>>> b = 1

>>> I = quad(integrand, 0, 1, args=(a,b))

>>> I = (2.0, 2.220446049250313e-14)

Inﬁnite inputs are also allowed in quad by using ± inf as one of the arguments. For example, suppose that a

numerical value for the exponential integral:

𝐸

𝑛

(𝑥) =



∞

𝑒

−𝑥𝑡

𝑡

𝑛

𝑑𝑡.

is desired (and the fact that this integral can be computed as special.expn(n,x) is forgotten). The functionality

of the function special.expn can be replicated by deﬁning a new function vec_expint based on the routine

quad:

>>> from scipy.integrate import quad

>>> def integrand(t, n, x):

... return exp(-x

t) / t

>>> def expint(n, x):

... return quad(integrand, 1, Inf, args=(n, x))[0]

>>> vec_expint = vectorize(expint)

>>> vec_expint(3,arange(1.0,4.0,0.5))

array([ 0.1097, 0.0567, 0.0301, 0.0163, 0.0089, 0.0049])

>>> special.expn(3,arange(1.0,4.0,0.5))

array([ 0.1097, 0.0567, 0.0301, 0.0163, 0.0089, 0.0049])

The function which is integrated can even use the quad argument (though the error bound may underestimate the error

due to possible numerical error in the integrand from the use of quad ). The integral in this case is

𝐼

𝑛



∞



∞

𝑒

−𝑥𝑡

𝑡

𝑛

𝑑𝑡 𝑑𝑥 =

𝑛

>>> result = quad(lambda x: expint(3, x), 0, inf)

>>> print result

(0.33333333324560266, 2.8548934485373678e-09)

>>> I3 = 1.0/3.0

>>> print I3

0.333333333333

>>> print I3 - result[0]

8.77306560731e-11

This last example shows that multiple integration can be handled using repeated calls to quad.

12 Chapter 1. SciPy Tutorial

SciPy Reference Guide, Release 0.14.0

1.4.2 General multiple integration (dblquad, tplquad, nquad)

The mechanics for double and triple integration have been wrapped up into the functions dblquad and tplquad.

These functions take the function to integrate and four, or six arguments, respecively. The limits of all inner integrals

need to be deﬁned as functions.

An example of using double integration to compute several values of 𝐼

𝑛

is shown below:

>>> from scipy.integrate import quad, dblquad

>>> def I(n):

... return dblquad(lambda t, x: exp(-x

t)/t

n, 0, Inf, lambda x: 1, lambda x: Inf)

>>> print I(4)

(0.25000000000435768, 1.0518245707751597e-09)

>>> print I(3)

(0.33333333325010883, 2.8604069919261191e-09)

>>> print I(2)

(0.49999999999857514, 1.8855523253868967e-09)

As example for non-constant limits consider the integral

𝐼 =



1/2

𝑦=0



1−2𝑦

𝑥=0

𝑥𝑦 𝑑𝑥 𝑑𝑦 =

This integral can be evaluated using the expression below (Note the use of the non-constant lambda functions for the

upper limit of the inner integral):

>>> from scipy.integrate import dblquad

>>> area = dblquad(lambda x, y: x

y, 0, 0.5, lambda x: 0, lambda x: 1-2

>>> area

(0.010416666666666668, 1.1564823173178715e-16)

For n-fold integration, scipy provides the function nquad. The integration bounds are an iterable object: either a

list of constant bounds, or a list of functions for the non-constant integration bounds. The order of integration (and

therefore the bounds) is from the innermost integral to the outermost one.

The integral from above

𝐼

𝑛



∞



∞

𝑒

−𝑥𝑡

𝑡

𝑛

𝑑𝑡 𝑑𝑥 =

𝑛

can be calculated as

>>> from scipy import integrate

>>> N = 5

>>> def f(t, x):

>>> return np.exp(-x

t) / t

>>> integrate.nquad(f, [[1, np.inf],[0, np.inf]])

(0.20000000000002294, 1.2239614263187945e-08)

Note that the order of arguments for f must match the order of the integration bounds; i.e. the inner integral with

respect to 𝑡 is on the interval [1, ∞] and the outer integral with respect to 𝑥 is on the interval [0, ∞].

Non-constant integration bounds can be treated in a similar manner; the example from above

𝐼 =



1/2

𝑦=0



1−2𝑦

𝑥=0

𝑥𝑦 𝑑𝑥 𝑑𝑦 =

can be evaluated by means of

1.4. Integration (scipy.integrate) 13

SciPy Reference Guide, Release 0.14.0

>>> from scipy import integrate

>>> def f(x, y):

>>> return x

>>> def bounds_y():

>>> return [0, 0.5]

>>> def bounds_x(y):

>>> return [0, 1-2

>>> integrate.nquad(f, [bounds_x, bounds_y])

(0.010416666666666668, 4.101620128472366e-16)

which is the same result as before.

1.4.3 Gaussian quadrature

A few functions are also provided in order to perform simple Gaussian quadrature over a ﬁxed interval. The ﬁrst

is fixed_quad which performs ﬁxed-order Gaussian quadrature. The second function is quadrature which

performs Gaussian quadrature of multiple orders until the difference in the integral estimate is beneath some tolerance

supplied by the user. These functions both use the module special.orthogonal which can calculate the roots

and quadrature weights of a large variety of orthogonal polynomials (the polynomials themselves are available as

special functions returning instances of the polynomial class — e.g. special.legendre).

1.4.4 Romberg Integration

Romberg’s method [WPR] is another method for numerically evaluating an integral. See the help function for

romberg for further details.

1.4.5 Integrating using Samples

If the samples are equally-spaced and the number of samples available is 2

𝑘

+ 1 for some integer 𝑘, then Romberg

romb integration can be used to obtain high-precision estimates of the integral using the available samples. Romberg

integration uses the trapezoid rule at step-sizes related by a power of two and then performs Richardson extrapolation

on these estimates to approximate the integral with a higher-degree of accuracy.

In case of arbitrary spaced samples, the two functions trapz (deﬁned in numpy [NPT]) and simps are available.

They are using Newton-Coates formulas of order 1 and 2 respectively to perform integration. The trapezoidal rule

approximates the function as a straight line between adjacent points, while Simpson’s rule approximates the function

between three adjacent points as a parabola.

For an odd number of samples that are equally spaced Simpson’s rule is exact if the function is a polynomial of order

3 or less. If the samples are not equally spaced, then the result is exact only if the function is a polynomial of order 2

or less.

>>> from scipy.integrate import simps

>>> import numpy as np

>>> def f(x):

... return x

>>> def f2(x):

... return x

>>> x = np.array([1,3,4])

>>> y1 = f1(x)

>>> I1 = integrate.simps(y1, x)

>>> print(I1)

21.0

14 Chapter 1. SciPy Tutorial

SciPy Reference Guide, Release 0.14.0

There are many optional inputs and outputs available when using odeint which can help tune the solver. These ad-

ditional inputs and outputs are not needed much of the time, however, and the three required input arguments and

the output solution sufﬁce. The required inputs are the function deﬁning the derivative, fprime, the initial conditions

vector, y0, and the time points to obtain a solution, t, (with the initial value point as the ﬁrst element of this sequence).

The output to odeint is a matrix where each row contains the solution vector at each requested time point (thus, the

initial conditions are given in the ﬁrst output row).

The following example illustrates the use of odeint including the usage of the Dfun option which allows the user to

specify a gradient (with respect to y ) of the function, f (y, 𝑡).

>>> from scipy.integrate import odeint

>>> from scipy.special import gamma, airy

>>> y1_0 = 1.0 / 3

(2.0/3.0) / gamma(2.0/3.0)

>>> y0_0 = -1.0 / 3

(1.0/3.0) / gamma(1.0/3.0)

>>> y0 = [y0_0, y1_0]

>>> def func(y, t):

... return [t

y[1],y[0]]

>>> def gradient(y, t):

... return [[0,t], [1,0]]

>>> x = arange(0, 4.0, 0.01)

>>> t = x

>>> ychk = airy(x)[0]

>>> y = odeint(func, y0, t)

>>> y2 = odeint(func, y0, t, Dfun=gradient)

>>> print ychk[:36:6]

[ 0.355028 0.339511 0.324068 0.308763 0.293658 0.278806]

>>> print y[:36:6,1]

[ 0.355028 0.339511 0.324067 0.308763 0.293658 0.278806]

>>> print y2[:36:6,1]

[ 0.355028 0.339511 0.324067 0.308763 0.293658 0.278806]

References

1.5 Optimization (scipy.optimize)

The scipy.optimize package provides several commonly used optimization algorithms. A detailed listing is

available: scipy.optimize (can also be found by help(scipy.optimize)).

The module contains:

1. Unconstrained and constrained minimization of multivariate scalar functions (minimize) using a variety of

algorithms (e.g. BFGS, Nelder-Mead simplex, Newton Conjugate Gradient, COBYLA or SLSQP)

2. Global (brute-force) optimization routines (e.g., anneal, basinhopping)

3. Least-squares minimization (leastsq) and curve ﬁtting (curve_fit) algorithms

4. Scalar univariate functions minimizers (minimize_scalar) and root ﬁnders (newton)

5. Multivariate equation system solvers (root) using a variety of algorithms (e.g. hybrid Powell, Levenberg-

Marquardt or large-scale methods such as Newton-Krylov).

Below, several examples demonstrate their basic usage.

16 Chapter 1. SciPy Tutorial

剩余1383页未读，继续阅读

garstoon

粉丝: 0
资源: 1

SciPy库详解：从优化到信号处理

Python SciPy：最小二乘拟合与数值计算库简介

SciPy官方文档：历史更新与API指南

Python/SciPy中稀疏ndarray协议的实现与改进

Python Scipy 实例教程

numpy官方文档1.12版本scipy官方文档0.19版本

scipy参考文档（机器学习）

python-scipy-numpy

scipy-2018-intro-to-python:SciPy 2018的Python教程简介

python安装scipy的方法步骤

学习Scipy文档

最新资源