< All Topics


SciPy is an open-source Python package used for scientific and engineering computing. It contains several user-friendly and efficient modules or sub-packages for linear algebra, optimization, interpolation, fast Fourier transform, Ordinary Differential Equations (ODE) solvers, and image processing.

It is built on top of NumPy, which provides the base for the library’s array objects and numerical computations. NumPy is also a widely used library in scientific computing and is often used alongside SciPy.

In addition, this library also integrates well with other scientific Python packages, such as Matplotlib for data visualization and Pandas for data manipulation. Users are encouraged to use SciPy when working with scientific engineering calculations.

SciPy is actively maintained and updated, adding new features and improvements regularly. It has a large and active community of users and contributors, and, as a result, many resources are available online.

Components and Modules

SciPy contains several modules designed to provide scientific computing capabilities. Some of the key modules include:


It provides functions for clustering and related tasks, which are commonly used in machine learning, data mining, and pattern recognition. Clustering consists of dividing data into groups or clusters based on their similarity. Cluster functions include hierarchical, vector quantization, and k-means algorithms.


It provides functions for computing fast Fourier transforms (FFT). FFT is an essential mathematical method for signal processing, image processing, and data analysis. It also supports functions for computing discrete Fourier transforms.


It provides functions for numerical integration and differentiation. These numerical operations are relevant in many areas of science and engineering, for example, to compute rates, areas, volume, and other physical systems.


It provides functions to perform interpolation on tensors. In the mathematical field, interpolation estimates a value between two or more known values. Its accuracy will depend on the method and data quantity used to estimate it.


It is a SciPy module that provides functions for optimization, root-finding, and minimization of scalar functions. Some of the commonly used functions in the “optimize” module are “minimize,” “root,” “curve_fit,” and “linprog.”

SciPy vs. Python Packages


NumPy is an open-source Python package specializing in large, multi-dimensional arrays, matrices, and high-level mathematical functions. It provides efficient array computations by allowing array elements to be stored together in memory, which makes them easily and quickly accessible. This feature improves performance significantly, especially when dealing with large datasets.


Pandas is a Python package that assists in data analysis and manipulation. It is built on top of NumPy and provides fast and efficient operations on arrays, data frames, and series. For example, Pandas allows users to concatenate and merge arrays and easily view and manipulate data.


Scikit-learn is an open-source Python package built upon Numpy and SciPy. It is a collection of modules dedicated to machine learning tasks, including classification, regression, random forests, gradient boosting, and k-means. Scikit-learn integrates many other Python libraries to provide a complete data analysis and visualization toolkit. The most famous libraries used with Scikit-learn are Matplotlib, Plotly, Seaborn, and Pandas.

Quick Installation Guide

SciPy is already included in the Anaconda distribution by default. To verify that SciPy is in your system, use the following command in the Anaconda prompt:

conda list

It will print a list and you will be able to see the “scipy” package. In case your system does not contain SciPy, you can install it by executing:

conda install -c anaconda scipy

It will download and install the latest SciPy version and any required dependencies. Alternatively, if you prefer to use pip:

pip install scipy

Once the installation is complete, you can import the package into your code by specifying the subpackage you want. In other words, users must import modules individually.

from scipy import integrate
from scipy.optimize import minimize
The import statement for a SciPy module.

SciPy Fundamentals

Fourier Transforms

Fourier analysis is a transform method that helps to decompose a temporal function or signal into a sum of periodic components. Use the “.fft()” function to perform this operation.

import numpy as np
from scipy.fft import fft

# Generate a test signal
t = np.linspace(0, 2*np.pi, 1000)
signal = np.sin(5*t) + 0.5*np.sin(10*t)

# Compute the FFT of the signal
fft_signal = fft(signal)

# Compute the power spectrum of the FFT
power_spectrum = np.abs(fft_signal)**2

# Plot the power spectrum
import matplotlib.pyplot as plt
freqs = np.fft.fftfreq(signal.size, t[1]-t[0])
idx = np.argsort(freqs)
plt.plot(freqs[idx], power_spectrum[idx])
plt.ylabel('Power Spectrum')
Power distribution vs. frequency.

In the example, the signal is the sum of two sine waves with frequencies of 5 and 10 Hz. The “.fft()” function computes the FFT of the signal, giving the amplitudes of its frequency components. The code also computes the power spectrum by squaring the FFT. As a result, we get the power distribution vs. the signal’s frequency components.

Integration Functions

You can use the “integrate.quad()” function to integrate a function and declare the lower and upper bounds.

from scipy import integrate
import numpy as np

# Define the function to integrate
def f(x):
    return np.sin(x)

# Integrate the function from 0 to pi
result, error = integrate.quad(f, 0, np.pi)

# Print the result
print("The integral of sin(x) from 0 to pi is: ", result)
print("Error: ", error)
## Result
The integral of sin(x) from 0 to pi is:  2.0
Error:  2.220446049250313e-14

In the example, we integrate the “sin(x)” function from 0 to pi. The function returns the value of the integral and estimates the absolute error of the result.

If you need to integrate a function of multiple variables, you can use the “nquad()” function instead.


For optimization operations, SciPy provides various modules. For example, you can use the “minimize()” function to discover the minimum value of a scalar function.

import numpy as np
from scipy.optimize import minimize

# Define the scalar function
def f(x):
    return x**2 + 2*x + 1

# Use the Nelder-Mead algorithm to minimize the function
result = minimize(f, x0=0, method='nelder-mead')

# Print the result
## Result
final_simplex: (array([[-1.       ],
       [-0.9999375]]), array([0.00000000e+00, 3.90624999e-09]))
           fun: 0.0
       message: 'Optimization terminated successfully.'
          nfev: 50
           nit: 25
        status: 0
       success: True
             x: array([-1.])

The example uses a scalar function f(x) = x^2 + 2x + 1, and applies the Nelder-Mead numerical method to find the minimum value of the objective function. Scientists can use it for nonlinear optimization problems, particularly when derivatives are unknown.


Project Background

  • Project: SciPy
  • Author: Travis Oliphant, Pearu Peterson, Eric Jones
  • Initial Release: 2001
  • Type: Technical Computing
  • License: New BSD Licence
  • Contains: luster, constant, integrate, interpolate, optimize, signal, park, etc
  • Language: Python, Fortran, C, C++
  • GitHub: scipy/scipy
  • Runs On: Windows, Linux, MacOS
  • Twitter: –

Main Features

  • It provides additional tools for array computing.
  • Users can compute complex math operations like FFT and conduct optimization problems.
  • SciPy provides functions for linear algebra, interpolation, ODE solvers, image processing, and many more, making it a useful tool for scientists and engineers.

Prior Knowledge Requirements

  • Understanding basic programming concepts such as data structures, loops, functions, and methods. 
  • Familiarity with the Python language itself and its syntax. 
  • Deep knowledge of Fourier transforms, optimization problems, and imaging processing.

Community Benchmarks

  • 10,900 Stars
  • 4,600 Forks
  • 1,270+ Code contributors
  • 75+ releases
  • Source: GitHub


  • SciPy 1.10.1 (2-20-2023): Update and Fixes: e.g., interpolate.interpn fails with read only input.
  • SciPy 1.10.0 (1-3-2023): Update and Fixes. This release requires Python 3.8+ and NumPy 1.19.5 or greater.
  • SciPy 1.9.3 (10-19-2022): Update and Fixes: e.g., dtype not preserved with operations on sparse arrays.
  • SciPy 1.9.0 (7-29-2022): Update and Fixes: e.g., Added scipy.optimize.milp, new function for mixed-integer linear programming.
  • SciPy 1.8.0 (2-5-2022): Users should expect minor API refinements over the next few releases.



Was this article helpful?
0 out of 5 stars
5 Stars 0%
4 Stars 0%
3 Stars 0%
2 Stars 0%
1 Stars 0%
Please Share Your Feedback
How Can We Improve This Article?
Table of Contents
Scroll to Top