SciPy参考指南：Python数据分析利器

4星 · 超过85%的资源需积分: 9 183 浏览量更新于2024-07-31 收藏 4.35MB PDF 举报

"SciPy_Reference_Guide" SciPy是Python生态系统中的一个核心库，它专注于科学计算，提供了大量的数学、科学和工程计算工具。这个参考指南是针对SciPy 0.9.0.dev6641版本编写的，由SciPy社区撰写，并在2010年7月28日发布。以下是对SciPy主要功能模块的详细概述： 1. **SciPy教程** - **简介**: 提供了关于如何使用SciPy的基本指导，适合初学者入门。 - **NumPy与SciPy的顶级函数**: 介绍NumPy（NumPy是SciPy的基础）以及SciPy中的一些通用函数，它们用于数组操作和计算。 2. **特殊函数（scipy.special）** - 提供了一组广泛的特殊数学函数，包括贝塞尔函数、伽马函数、埃尔米特函数等，这些函数在物理学、工程学和统计学等领域中广泛应用。 3. **积分（scipy.integrate）** - 包含了数值积分和微分方程求解的功能，如定积分、重积分、微分方程初值问题的求解等。 4. **优化（optimize）** - 提供了各种优化算法，用于最小化或最大化函数、找到曲线的根、拟合数据等任务。 5. **插值（scipy.interpolate）** - 支持一维到多维的数据插值，包括线性插值、样条插值和最近邻插值等方法，用于数据平滑和预测。 6. **傅立叶变换（scipy.fftpack）** - 实现了快速傅立叶变换（FFT）和其他相关变换，用于频域分析。 7. **信号处理（signal）** - 包括滤波器设计、频谱分析、窗口函数等，用于处理和分析时间序列数据。 8. **线性代数（linear algebra）** - 提供了矩阵运算、特征值计算、解线性方程组等功能，与numpy.linalg一起构建了强大的线性代数工具。 9. **统计（statistics）** - 包含基本的统计函数，如平均值、标准差、分布函数、假设检验等，支持随机数生成和统计模型。 10. **多维图像处理（ndimage）** - 用于处理和分析多维图像数据，包括形态学操作、滤波、测量等。 11. **文件输入输出（scipy.io）** - 支持多种数据格式的读写，如MATLAB文件、wav音频文件等。 12. **Weave** - 这是一个工具，允许用户将C或C++代码直接集成到Python脚本中，以提高计算效率。 13. **版本发布说明** - 每个版本的发布都会包含详细的变更记录和新特性介绍，帮助用户了解更新内容。 14. **参考文档** - 对各个模块的详细API进行了全面的文档化，方便开发者查阅和使用。 SciPy是Python中用于科学计算的重要库，其丰富的功能使得在处理数学、物理、工程等问题时更为便捷高效。无论是初学者还是经验丰富的科学家，都能从中受益。通过结合其他Python库，如NumPy、matplotlib等，可以构建出强大的数据分析和科学计算平台。

SciPy Reference Guide, Release 0.9.0.dev6641

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

∞

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

12 Chapter 1. SciPy Tutorial

SciPy Reference Guide, Release 0.9.0.dev6641

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

1.4. Integration (scipy.integrate) 13

SciPy Reference Guide, Release 0.9.0.dev6641

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) = exp



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

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

1.5 Optimization (optimize)

There are several classical optimization algorithms provided by SciPy in the scipy.optimize package. An

overview of the module is available using help (or pydoc.help):

14 Chapter 1. SciPy Tutorial

SciPy Reference Guide, Release 0.9.0.dev6641

from scipy import optimize

>>> info(optimize)

Optimization Tools

==================

A collection of general-purpose optimization routines.

fmin -- Nelder-Mead Simplex algorithm

(uses only function calls)

fmin_powell -- Powell’s (modified) level set method (uses only

function calls)

fmin_cg -- Non-linear (Polak-Ribiere) conjugate gradient algorithm

(can use function and gradient).

fmin_bfgs -- Quasi-Newton method (Broydon-Fletcher-Goldfarb-Shanno);

(can use function and gradient)

fmin_ncg -- Line-search Newton Conjugate Gradient (can use

function, gradient and Hessian).

leastsq -- Minimize the sum of squares of M equations in

N unknowns given a starting estimate.

Constrained Optimizers (multivariate)

fmin_l_bfgs_b -- Zhu, Byrd, and Nocedal’s L-BFGS-B constrained optimizer

(if you use this please quote their papers -- see help)

fmin_tnc -- Truncated Newton Code originally written by Stephen Nash and

adapted to C by Jean-Sebastien Roy.

fmin_cobyla -- Constrained Optimization BY Linear Approximation

Global Optimizers

anneal -- Simulated Annealing

brute -- Brute force searching optimizer

Scalar function minimizers

fminbound -- Bounded minimization of a scalar function.

brent -- 1-D function minimization using Brent method.

golden -- 1-D function minimization using Golden Section method

bracket -- Bracket a minimum (given two starting points)

Also a collection of general-purpose root-finding routines.

fsolve -- Non-linear multi-variable equation solver.

Scalar function solvers

brentq -- quadratic interpolation Brent method

brenth -- Brent method (modified by Harris with hyperbolic

extrapolation)

ridder -- Ridder’s method

bisect -- Bisection method

newton -- Secant method or Newton’s method

fixed_point -- Single-variable fixed-point solver.

A collection of general-purpose nonlinear multidimensional solvers.

broyden1 -- Broyden’s first method - is a quasi-Newton-Raphson

method for updating an approximate Jacobian and then

inverting it

broyden2 -- Broyden’s second method - the same as broyden1, but

updates the inverse Jacobian directly

broyden3 -- Broyden’s second method - the same as broyden2, but

instead of directly computing the inverse Jacobian,

it remembers how to construct it using vectors, and

when computing inv(J)

F, it uses those vectors to

compute this product, thus avoding the expensive NxN

matrix multiplication.

broyden_generalized -- Generalized Broyden’s method, the same as broyden2,

but instead of approximating the full NxN Jacobian,

it construct it at every iteration in a way that

avoids the NxN matrix multiplication. This is not

as precise as broyden3.

anderson -- extended Anderson method, the same as the

broyden_generalized, but added w_0^2

I to before

taking inversion to improve the stability

anderson2 -- the Anderson method, the same as anderson, but

formulated differently

Utility Functions

line_search -- Return a step that satisfies the strong Wolfe conditions.

check_grad -- Check the supplied derivative using finite difference

techniques.

1.5. Optimization (optimize) 15

SciPy Reference Guide, Release 0.9.0.dev6641

The ﬁrst four algorithms are unconstrained minimization algorithms (fmin: Nelder-Mead simplex, fmin_bfgs:

BFGS, fmin_ncg: Newton Conjugate Gradient, and leastsq: Levenburg-Marquardt). The last algorithm actually

ﬁnds the roots of a general function of possibly many variables. It is included in the optimization package because at

the (non-boundary) extreme points of a function, the gradient is equal to zero.

1.5.1 Nelder-Mead Simplex algorithm (fmin)

The simplex algorithm is probably the simplest way to minimize a fairly well-behaved function. The simplex algorithm

requires only function evaluations and is a good choice for simple minimization problems. However, because it does

not use any gradient evaluations, it may take longer to ﬁnd the minimum. To demonstrate the minimization function

consider the problem of minimizing the Rosenbrock function of N variables:

f (x) =

N−1

i=1

100



− x

i−1



+ (1 − x

i−1

)

The minimum value of this function is 0 which is achieved when x

= 1. This minimum can be found using the fmin

routine as shown in the example below:

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



16 Chapter 1. SciPy Tutorial

剩余735页未读，继续阅读

Friendgh

粉丝: 0
资源: 1

SciPy参考指南：Python数据分析利器

SciPy Reference Guide.pdf

scipy 使用指南1

Scipy Reference Release0.16.0

SciPy 1.7.1 Reference Guide

SciPy Reference Guide Release 0.13.0.pdf

scipy-ref-1.0.0

scipy和numpy参考手册 pdf

scipy-ref-1.7.1.pdf

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

基于springboot+Javaweb的二手图书交易系统源码数据库文档.zip

最新资源