Introduction#
SciPy is a collection of mathematical algorithms and convenience functions built on the NumPy extension of Python. It adds significant power to the interactive Python session by providing the user with highlevel commands and classes for manipulating and visualizing data. With SciPy, an interactive Python session becomes a dataprocessing and systemprototyping environment rivaling systems, such as MATLAB, IDL, Octave, RLab, and SciLab.
The additional benefit of basing SciPy on Python is that this also makes a powerful programming language available for use in developing sophisticated programs and specialized applications. Scientific applications using SciPy benefit from the development of additional modules in numerous niches of the software landscape by developers across the world. Everything from parallel programming to web and database subroutines and classes have been made available to the Python programmer. All of this power is available in addition to the mathematical libraries in SciPy.
This tutorial will acquaint the firsttime user of SciPy with some of its most important features. It assumes that the user has already installed the SciPy package. Some general Python facility is also assumed, such as could be acquired by working through the Python distribution’s Tutorial. For further introductory help the user is directed to the NumPy documentation.
SciPy Organization#
SciPy is organized into subpackages covering different scientific computing domains. These are summarized in the following table:
Subpackage 
Description 

Clustering algorithms 

Physical and mathematical constants 

Fast Fourier Transform routines 

Integration and ordinary differential equation solvers 

Interpolation and smoothing splines 

Input and Output 

Linear algebra 

Ndimensional image processing 

Orthogonal distance regression 

Optimization and rootfinding routines 

Signal processing 

Sparse matrices and associated routines 

Spatial data structures and algorithms 

Special functions 

Statistical distributions and functions 
SciPy subpackages need to be imported separately, for example:
>>> from scipy import linalg, optimize
Because of their ubiquitousness, some of the functions in these
subpackages are also made available in the scipy
namespace to ease
their use in interactive sessions and programs. In addition, many
basic array functions from numpy
are also available at the
toplevel of the scipy
package. Before looking at the
subpackages individually, we will first look at some of these common
functions.
Finding Documentation#
SciPy and NumPy have documentation versions in both HTML and PDF format available at https://docs.scipy.org/, that cover nearly all available functionality. However, this documentation is still workinprogress and some parts may be incomplete or sparse. As we are a volunteer organization and depend on the community for growth, your participation  everything from providing feedback to improving the documentation and code  is welcome and actively encouraged.
Python’s documentation strings are used in SciPy for online
documentation. There are two methods for reading them and
getting help. One is Python’s command help
in the pydoc
module. Entering this command with no arguments (i.e. >>> help
)
launches an interactive help session that allows searching through the
keywords and modules available to all of Python. Secondly, running the command
help(obj) with an object as the argument displays that object’s calling
signature, and documentation string.
The pydoc method of help
is sophisticated but uses a pager to display
the text. Sometimes this can interfere with the terminal within which you are
running the interactive session. A numpy/scipyspecific help system
is also available under the command numpy.info
. The signature and
documentation string for the object passed to the help
command are
printed to standard output (or to a writeable object passed as the
third argument). The second keyword argument of numpy.info
defines
the maximum width of the line for printing. If a module is passed as
the argument to help
then a list of the functions and classes defined
in that module is printed. For example:
>>> np.info(optimize.fmin)
fmin(func, x0, args=(), xtol=0.0001, ftol=0.0001, maxiter=None, maxfun=None,
full_output=0, disp=1, retall=0, callback=None)
Minimize a function using the downhill simplex algorithm.
Parameters

func : callable func(x,*args)
The objective function to be minimized.
x0 : ndarray
Initial guess.
args : tuple
Extra arguments passed to func, i.e. ``f(x,*args)``.
callback : callable
Called after each iteration, as callback(xk), where xk is the
current parameter vector.
Returns

xopt : ndarray
Parameter that minimizes function.
fopt : float
Value of function at minimum: ``fopt = func(xopt)``.
iter : int
Number of iterations performed.
funcalls : int
Number of function calls made.
warnflag : int
1 : Maximum number of function evaluations made.
2 : Maximum number of iterations reached.
allvecs : list
Solution at each iteration.
Other parameters

xtol : float
Relative error in xopt acceptable for convergence.
ftol : number
Relative error in func(xopt) acceptable for convergence.
maxiter : int
Maximum number of iterations to perform.
maxfun : number
Maximum number of function evaluations to make.
full_output : bool
Set to True if fopt and warnflag outputs are desired.
disp : bool
Set to True to print convergence messages.
retall : bool
Set to True to return list of solutions at each iteration.
Notes

Uses a NelderMead simplex algorithm to find the minimum of function of
one or more variables.
Another useful command is dir
,
which can be used to look at the namespace of a module or package.