python scipy vs numpy: Practical Usage and Code Examples

python scipy vs numpy requires a clear understanding of the core syntax, runtime behavior, and practical implementation patterns demonstrated in the examples below.

When you start doing numerical work in Python, you'll quickly encounter both NumPy and SciPy. They are often imported together, and for good reason: SciPy builds directly on NumPy's array infrastructure. But they are not interchangeable, and knowing which one to reach for depends on the specific operation you need to perform.

The Relationship Between NumPy and SciPy

NumPy provides the foundational data structure—the ndarray—and a collection of basic operations for fast array manipulation. SciPy, on the other hand, is a higher-level library that uses NumPy arrays as its input and output format. SciPy adds algorithms for optimization, integration, interpolation, eigenvalue problems, signal and image processing, and more.

Think of NumPy as the engine that handles storage and element-wise operations, and SciPy as the toolbox that implements complex mathematical procedures on top of that engine. When you call a SciPy function, you pass NumPy arrays to it, and it returns results as NumPy arrays or scalars.

What NumPy Provides on Its Own

NumPy's core strength is the ndarray, a homogeneous n-dimensional array that supports vectorized operations. With NumPy alone you can perform:

Element-wise arithmetic: a + b, a * b, np.sin(a)
Basic linear algebra: np.dot, np.linalg.inv, np.linalg.eig
Random number generation: np.random.normal, np.random.randint
Array reshaping, slicing, broadcasting, and aggregation: np.reshape, np.sum, np.mean
Fast Fourier transforms via np.fft

For many data-processing tasks, NumPy is sufficient. If you need to compute a moving average, filter an array, or solve a small linear system, NumPy's built-in functions get the job done without importing SciPy.

import numpy as np

# Solve a small linear system Ax = b
A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
x = np.linalg.solve(A, b)
print(x)  # [2.  3.]

What SciPy Adds on Top of NumPy

SciPy organizes its algorithms into submodules, each focused on a domain. Some of the most commonly used ones include:

scipy.optimize: root finding, curve fitting, minimization
scipy.integrate: numerical integration and ordinary differential equation solvers
scipy.interpolate: interpolation of 1D and multidimensional data
scipy.signal: filtering, convolution, spectral analysis
scipy.sparse: sparse matrix representations and algorithms
scipy.stats: probability distributions and statistical tests

These submodules rely on NumPy arrays for input and output, but they implement algorithms that go far beyond what NumPy offers. For example, scipy.optimize.curve_fit can fit a model function to data using non-linear least squares, something you would have to implement manually with NumPy.

from scipy.optimize import curve_fit
import numpy as np

# Define a model function
def model(x, a, b):
    return a * np.exp(-b * x)

# Sample data
xdata = np.linspace(0, 4, 50)
ydata = model(xdata, 2.5, 1.3) + 0.1 * np.random.normal(size=50)

# Fit the model
popt, _ = curve_fit(model, xdata, ydata)
print(popt)  # approximately [2.5, 1.3]

How SciPy Uses NumPy Arrays

SciPy functions accept NumPy arrays and return NumPy arrays. This design means you can move data between the two libraries without conversion overhead. For instance, you can create an array with NumPy, pass it to a SciPy routine, and then use NumPy methods on the result.

import numpy as np
from scipy.integrate import quad

# Integrate a function from 0 to 1
result, error = quad(lambda x: np.exp(-x**2), 0, 1)
print(result)  # 0.7468241328124271

The quad function returns a tuple containing the integral and an estimate of the error. The function passed to it can use NumPy's universal functions, and the integration is performed in compiled code, making it fast and accurate.

This tight coupling means you rarely need to convert between different array types. When you read data from a file using np.loadtxt, you can immediately feed it to scipy.signal.butter to design a filter. The seamless interaction is a major reason why the two libraries are often used together.

When to Use NumPy Without SciPy

If your task involves basic array manipulation, element-wise operations, or simple linear algebra, NumPy alone is the right choice. Importing SciPy adds overhead—both in memory footprint and import time—so for lightweight scripts or applications that only need array storage and arithmetic, stick with NumPy.

Common NumPy-only scenarios:

Data preprocessing: normalizing columns, handling missing values, reshaping
Simple statistics: mean, median, standard deviation, percentiles
Linear algebra for small systems: solving Ax = b, eigenvalues, matrix inversion
Fast element-wise transformations: applying a function to every element
Random sampling for Monte Carlo simulations

import numpy as np

# Compute the element-wise product and sum
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.dot(a, b)  # 32
print(c)

When to Use SciPy

Reach for SciPy when you need an algorithm that is not part of NumPy's standard toolkit. This includes numerical integration, optimization, signal filtering, interpolation, and statistical testing. SciPy's implementations are typically well-tested, numerically stable, and optimized for performance.

For example, if you need to find the minimum of a multi-variable function, scipy.optimize.minimize offers several algorithms (BFGS, L-BFGS-B, Nelder-Mead) that you can select based on your constraints. Implementing a robust optimizer from scratch is error-prone and time-consuming; SciPy provides a reliable, battle-tested alternative.

from scipy.optimize import minimize
import numpy as np

# Define a simple objective function
def objective(x):
    return x[0]**2 + x[1]**2

# Initial guess
x0 = np.array([1.0, 1.0])
res = minimize(objective, x0, method='BFGS')
print(res.x)  # [0. 0.]

Performance and Memory Considerations

Both NumPy and SciPy are implemented in C and Fortran under the hood, so their core operations are compiled and fast. However, there are practical differences in how they behave at runtime.

NumPy's strength is its low overhead for array creation and element-wise operations. If you are working with large arrays and only need basic arithmetic, NumPy will be more efficient than calling a SciPy function that does the same thing—though SciPy rarely duplicates NumPy functionality. The main performance cost of SciPy comes from the more complex algorithms it implements, which are often iterative and may not be vectorized in the same way as NumPy's element-wise operations.

Memory usage is another factor. SciPy's submodules can allocate additional temporary arrays for intermediate calculations. For example, scipy.integrate.odeint uses adaptive step sizes and may allocate memory for internal state. If you are memory-constrained and your problem can be solved with NumPy's vectorized operations, that is usually the lighter option.

Import time also matters in short-lived scripts. Importing scipy can take noticeably longer than importing numpy because it loads many submodules. In a web service that handles frequent requests, you might want to avoid importing SciPy at module load time if you only need a single function. Instead, import the specific submodule lazily or use a separate worker process.

# Lazy import inside a function
def filter_signal(data, cutoff):
    from scipy.signal import butter, filtfilt
    b, a = butter(4, cutoff, btype='low')
    return filtfilt(b, a, data)

Making the Choice

The decision between NumPy and SciPy is not a matter of one being better than the other; it's about matching the library to the problem.

Use NumPy when you need array storage, element-wise operations, basic linear algebra, or random number generation. It is lightweight, fast, and sufficient for most data manipulation tasks.
Use SciPy when you need advanced algorithms like optimization, integration, interpolation, signal processing, or statistical analysis. These are implemented with numerical stability and performance in mind.
Use both when your workflow involves data preparation with NumPy and then a specialized computation from SciPy. This is the most common pattern in scientific computing.

A good rule of thumb: if you find yourself implementing a numerical algorithm that you know is a standard technique—like a Runge-Kutta integrator or a Savitzky-Golay filter—check whether SciPy already provides it. More often than not, it does, and using the library version will save you time and reduce the risk of subtle numerical errors.

SciPy also extends NumPy's capabilities in areas like sparse matrices and statistical distributions. If your data is mostly zeros, scipy.sparse can drastically reduce memory usage compared to a dense NumPy array. Similarly, scipy.stats provides a wide range of probability distributions and hypothesis tests that are not available in NumPy.

Ultimately, the choice is driven by the specific operation you need to perform. NumPy is the foundation; SciPy is the specialized toolkit that builds on it. Understanding what each provides lets you write code that is both efficient and maintainable.