SciPy 0.11.0 数据处理扩展全指南：Python中的MATLAB替代

5星 · 超过95%的资源需积分: 10 28 浏览量更新于2024-07-23 2 收藏 5.81MB PDF 举报

SciPy Reference Guide.pdf 是一份详细的指南，针对Python中的科学计算库SciPy进行了全面介绍。作为Python的数据处理扩展，SciPy类似于MATLAB，但专为Python语言设计，提供了丰富的数学、科学和工程计算功能。这份文档涵盖了多个核心模块和功能，包括但不限于： 1. **SciPy Tutorial**：首先介绍了SciPy的基本概念和使用方法，引导读者从入门到深入了解。内容包括基础的NumPy函数和SciPy的顶级函数，如特殊函数（scipy.special）、积分计算（scipy.integrate）、优化工具（scipy.optimize）等。 2. **Special Functions**：这部分着重于各种数学函数，如三角函数、伽马函数、Bessel函数等，是进行数值分析时不可或缺的部分。 3. **Integration**：提供了一套完整的数值积分方法，对于解决微分方程、概率分布等问题至关重要。 4. **Optimization**：涉及线性及非线性优化算法，包括最小化或最大化函数，以及求解约束优化问题。 5. **Interpolation**：科学计算中常需要数据插值，SciPy提供了多项式、样条和其他插值方法。 6. **Fourier Transforms**：支持快速傅里叶变换（FFT），在信号处理和图像分析中应用广泛。 7. **Signal Processing**：提供了处理数字信号的工具，如滤波器设计、谱分析等。 8. **Linear Algebra**：包含矩阵运算、线性方程组求解和特征值问题等功能，是许多科学计算的基础。 9. **Sparse Eigenvalue Problems with ARPACK**：针对稀疏矩阵的特征值问题，利用ARPACK库实现高效的求解策略。 10. **Statistics**：提供了统计分析工具，涵盖概率分布、假设检验和统计模型等。 11. **Multi-dimensional Image Processing**：用于处理多维图像数据的函数，例如滤波、形态学操作等。 12. **File I/O**：支持数据的输入输出，便于与其他格式的数据进行交互。 13. **Weave**：尽管这部分在后来的版本中可能不再重要，但早期版本可能涉及到C++代码的嵌入，以提高性能。此外，文档还包含了如何导入SciPy模块的指导原则，以及各个版本的Release Notes，记录了SciPy自0.7.0以来的重要更新和改进。这份参考指南对于Python科学家和工程师来说是一份宝贵的资源，它不仅介绍了库的功能，还有助于理解如何有效地在实际项目中利用SciPy进行高级数学和科学计算。

SciPy Reference Guide, Release 0.11.0.dev-600e81f

1.4.1 General integration (quad)

The function quad is provided to integrate a function of one variable between two points. The points can be ±∞ (±

inf) to indicate inﬁnite limits. For example, suppose you wish to integrate a bessel function jv(2.5,x) along the

interval [0, 4.5].

I =

4.5

2.5

(x) dx.

This could be computed using quad:

>>> result = integrate.quad(lambda x: special.jv(2.5,x), 0, 4.5)

>>> print result

(1.1178179380783249, 7.8663172481899801e-09)

>>> I = sqrt(2/pi)

(18.0/27

sqrt(2)

cos(4.5)-4.0/27

sqrt(2)

sin(4.5)+

sqrt(2

pi)

special.fresnel(3/sqrt(pi))[0])

>>> print I

1.117817938088701

>>> print abs(result[0]-I)

1.03761443881e-11

The ﬁrst argument to quad is a “callable” Python object (i.e a function, method, or class instance). Notice the use of a

lambda- function in this case as the argument. The next two arguments are the limits of integration. The return value

is a tuple, with the ﬁrst element holding the estimated value of the integral and the second element holding an upper

bound on the error. Notice, that in this case, the true value of this integral is

I =



√

2 cos (4.5) −

√

2 sin (4.5) +

√

2πSi



√



where

Si (x) =

sin





dt.

is the Fresnel sine integral. Note that the numerically-computed integral is within 1.04 × 10

−11

of the exact result —

well below the reported error bound.

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:

(x) =

∞

−xt

dt.

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

12 Chapter 1. SciPy Tutorial

SciPy Reference Guide, Release 0.11.0.dev-600e81f

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

∞

−xt

dt dx =

>>> 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. The mechanics of this

for double and triple integration have been wrapped up into the functions

dblquad and tplquad. The function,

dblquad performs double integration. Use the help function to be sure that the arguments are deﬁned in the correct

order. In addition, the limits on all inner integrals are actually functions which can be constant functions. An example

of using double integration to compute several values of I

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)

1.4.2 Gaussian quadrature (integrate.gauss_quadtol)

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.3 Integrating using samples

There are three functions for computing integrals given only samples: trapz , simps, and romb . The ﬁrst two

functions use Newton-Coates formulas of order 1 and 2 respectively to perform integration. These two functions

can handle, non-equally-spaced samples. 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.

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

+ 1 for some integer k, then Romberg

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

tegration 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. (A different interface to Romberg

integration useful when the function can be provided is also available as romberg).

1.4. Integration (scipy.integrate) 13

SciPy Reference Guide, Release 0.11.0.dev-600e81f

1.4.4 Ordinary differential equations (odeint)

Integrating a set of ordinary differential equations (ODEs) given initial conditions is another useful example. The

function odeint is available in SciPy for integrating a ﬁrst-order vector differential equation:

= f (y, t) ,

given initial conditions y (0) = y

, where y is a length N vector and f is a mapping from R

to R

. A higher-order

ordinary differential equation can always be reduced to a differential equation of this type by introducing intermediate

derivatives into the y vector.

For example suppose it is desired to ﬁnd the solution to the following second-order differential equation:

− zw(z) = 0

with initial conditions w (0) =

√

(

)

and



z=0

= −

√

3Γ

(

)

. It is known that the solution to this differential

equation with these boundary conditions is the Airy function

w = Ai (z) ,

which gives a means to check the integrator using

special.airy.

First, convert this ODE into standard form by setting y =



, w



and t = z. Thus, the differential equation becomes







0 t

1 0







0 t

1 0



In other words,

f (y, t) = A (t) y.

As an interesting reminder, if A (t) commutes with

A (τ) dτ under matrix multiplication, then this linear differen-

tial equation has an exact solution using the matrix exponential:

y (t) = e xp



A (τ) dτ



y (0) ,

However, in this case, A (t) and its integral do not commute.

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, t).

>>> 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]]

14 Chapter 1. SciPy Tutorial

SciPy Reference Guide, Release 0.11.0.dev-600e81f

>>> from scipy.optimize import fmin

>>> def rosen(x):

... """The Rosenbrock function"""

... return sum(100.0

(x[1:]-x[:-1]

2.0)

2.0 + (1-x[:-1])

2.0)

>>> x0 = [1.3, 0.7, 0.8, 1.9, 1.2]

>>> xopt = fmin(rosen, x0, xtol=1e-8)

Optimization terminated successfully.

Current function value: 0.000000

Iterations: 339

Function evaluations: 571

>>> print xopt

[ 1. 1. 1. 1. 1.]

Another optimization algorithm that needs only function calls to ﬁnd the minimum is Powell’s method available as

fmin_powell.

1.5.2 Broyden-Fletcher-Goldfarb-Shanno algorithm (fmin_bfgs)

In order to converge more quickly to the solution, this routine uses the gradient of the objective function. If the gradient

is not given by the user, then it is estimated using ﬁrst-differences. The Broyden-Fletcher-Goldfarb-Shanno (BFGS)

method typically requires fewer function calls than the simplex algorithm even when the gradient must be estimated.

To demonstrate this algorithm, the Rosenbrock function is again used. The gradient of the Rosenbrock function is the

vector:

∂f

∂x

i=1

200



− x

i−1



(δ

i,j

− 2x

i−1

i−1,j

) − 2 (1 − x

i−1

) δ

i−1,j

= 200



− x

j−1



− 400x



j+1

− x



− 2 (1 − x

) .

This expression is valid for the interior derivatives. Special cases are

∂f

∂x

= −400x



− x



− 2 (1 − x

) ,

∂f

∂x

N−1

= 200



N−1

− x

N−2



A Python function which computes this gradient is constructed by the code-segment:

>>> def rosen_der(x):

... xm = x[1:-1]

... xm_m1 = x[:-2]

... xm_p1 = x[2:]

... der = zeros_like(x)

... der[1:-1] = 200

(xm-xm_m1

2) - 400

(xm_p1 - xm

xm - 2

(1-xm)

... der[0] = -400

x[0]

(x[1]-x[0]

2) - 2

(1-x[0])

... der[-1] = 200

(x[-1]-x[-2]

... return der

The calling signature for the BFGS minimization algorithm is similar to fmin with the addition of the fprime ar-

gument. An example usage of fmin_bfgs is shown in the following example which minimizes the Rosenbrock

function.

>>> from scipy.optimize import fmin_bfgs

16 Chapter 1. SciPy Tutorial

剩余982页未读，继续阅读

Aloys_Code

粉丝: 40

SciPy 0.11.0 数据处理扩展全指南：Python中的MATLAB替代

scipy和numpy参考手册 pdf

SciPy Reference Guide Release 0.13.0.pdf

abaqus scripting reference manual.pdf

scipy-ref-1.7.1.pdf

SciPy 1.7.1 Reference Guide

sympy-docs-pdf-1.0.pdf

numpy-ref-1.11.0.pdf

scipy-ref-1.0.0

Scipy官方参考文档

SciPy_Reference_Guide

最新资源