scipy.fft is Python’s go-to module for converting signals between time and frequency domains. It handles FFT operations, frequency analysis, and signal filtering with better performance than numpy.fft, especially for multi-dimensional arrays.
I switched to scipy.fft after numpy.fft was too slow processing multi-channel audio data in a music visualization project. The speed difference was noticeable enough to make the real-time rendering actually work.
Here’s what you need to know to use scipy.fft effectively, including when to use it over numpy and which functions solve which problems.
What is scipy.fft?
scipy.fft computes the Fast Fourier Transform (FFT), which breaks down a signal into its frequency components. Think of it like a musical equalizer that shows you which frequencies are present in a sound.
The module includes functions for forward transforms (time → frequency), inverse transforms (frequency → time), and specialized variants for real-valued signals. It’s a superset of numpy.fft with additional features and better performance.
When Should You Use scipy.fft?
Use scipy.fft when you need to:
- Analyze frequency content of signals (audio, sensors, time series)
- Filter signals by frequency (remove noise, isolate specific frequencies)
- Compute convolutions efficiently (signal processing, image processing)
- Work with multi-dimensional data (images, spectrograms, 3D volumes)
- Run parallel FFT operations on large datasets
scipy.fft vs numpy.fft: scipy.fft is faster for multi-dimensional arrays because it uses vector instructions. It also supports parallel computation with the workers parameter. If you’re only doing simple 1D transforms on small arrays, numpy.fft works fine. For everything else, use scipy.fft.
scipy.fft vs scipy.fftpack: Don’t use scipy.fftpack. It’s legacy code that scipy documentation explicitly says to avoid. scipy.fft is the modern replacement (introduced in SciPy 1.4.0).
How Do You Install scipy.fft?
scipy.fft comes with scipy, so just install scipy:
Verify the installation:
import scipy
print(scipy.__version__) # Should be 1.4.0 or higher
Current stable version is 1.17.0 (as of February 2026).
What Are the Core Functions?
scipy.fft.fft() – Compute 1D FFT
from scipy.fft import fft
import numpy as np
# Simple sine wave
signal = np.sin(2 * np.pi * 5 * np.linspace(0, 1, 500)) # 5 Hz
frequencies = fft(signal)
scipy.fft.ifft() – Inverse FFT (frequency → time)
from scipy.fft import fft, ifft
# Transform and back
frequencies = fft(signal)
recovered = ifft(frequencies)
# recovered now equals original signal (within floating point error)
scipy.fft.rfft() – Real FFT (for real-valued signals)
from scipy.fft import rfft
# Twice as fast for real signals
frequencies = rfft(signal) # Returns only positive frequencies
scipy.fft.fftfreq() – Get frequency bins
from scipy.fft import fft, fftfreq
sample_rate = 500 # Hz
n = len(signal)
frequencies = fft(signal)
freq_bins = fftfreq(n, 1/sample_rate)
scipy.fft.fftshift() – Center the zero frequency
from scipy.fft import fft, fftshift
frequencies = fftshift(fft(signal))
# Now DC component (0 Hz) is in the middle, not at index 0
How Do You Analyze a Signal’s Frequencies?
Here’s a complete example analyzing a mixed-frequency signal:
from scipy.fft import fft, fftfreq
import numpy as np
import matplotlib.pyplot as plt
# Create signal: 5 Hz + 20 Hz + 35 Hz
sample_rate = 1000 # samples per second
duration = 1.0 # seconds
t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
signal = (
2.0 * np.sin(2 * np.pi * 5 * t) + # 5 Hz, amplitude 2
1.0 * np.sin(2 * np.pi * 20 * t) + # 20 Hz, amplitude 1
0.5 * np.sin(2 * np.pi * 35 * t) # 35 Hz, amplitude 0.5
)
# Compute FFT
frequencies = fft(signal)
freq_bins = fftfreq(len(signal), 1/sample_rate)
# Get magnitude (amplitude) of each frequency
magnitude = np.abs(frequencies)
# Plot (only positive frequencies)
positive_freq_idx = freq_bins > 0
plt.figure(figsize=(10, 4))
plt.plot(freq_bins[positive_freq_idx], magnitude[positive_freq_idx])
plt.xlabel('Frequency (Hz)')
plt.ylabel('Amplitude')
plt.title('Frequency Spectrum')
plt.show()
# You'll see three clear peaks at 5, 20, and 35 Hz
The FFT output has:
- Index 0: DC component (average value)
- Indices 1 to n/2: Positive frequencies
- Indices n/2+1 to n-1: Negative frequencies (mirror of positive for real signals)
How Do You Filter a Signal?
Filtering in frequency domain is straightforward. Here’s a simple low-pass filter:
from scipy.fft import fft, ifft, fftfreq
import numpy as np
# Same signal as before
sample_rate = 1000
duration = 1.0
t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
signal = (
2.0 * np.sin(2 * np.pi * 5 * t) +
1.0 * np.sin(2 * np.pi * 20 * t) +
0.5 * np.sin(2 * np.pi * 35 * t)
)
# Transform to frequency domain
frequencies = fft(signal)
freq_bins = fftfreq(len(signal), 1/sample_rate)
# Low-pass filter: keep only frequencies below 15 Hz
cutoff = 15 # Hz
frequencies[np.abs(freq_bins) > cutoff] = 0
# Transform back to time domain
filtered_signal = np.real(ifft(frequencies))
# filtered_signal now contains only the 5 Hz component
This zeroes out the 20 Hz and 35 Hz components, leaving only the 5 Hz sine wave.
When Should You Use rfft()?
Use rfft() when your input signal is real-valued (no imaginary components). It’s about twice as fast because it skips computing the redundant negative frequencies.
from scipy.fft import rfft, rfftfreq
import numpy as np
signal = np.random.randn(1000) # Real-valued noise
# rfft is faster and returns only positive frequencies
frequencies = rfft(signal)
freq_bins = rfftfreq(len(signal), 1/sample_rate)
# Result is half the size of fft() output
print(f"rfft output length: {len(frequencies)}") # 501
print(f"fft would give: {len(signal)}") # 1000
Use regular fft() only when working with complex signals.
How Do You Handle Multi-Dimensional Data?
scipy.fft excels at multi-dimensional transforms. Use fft2() for images or fftn() for n-dimensional arrays.
from scipy.fft import fft2, ifft2
import numpy as np
# 2D signal (e.g., grayscale image)
image = np.random.randn(256, 256)
# 2D FFT
freq_2d = fft2(image)
# Access DC component
dc = freq_2d[0, 0]
# Transform back
recovered = np.real(ifft2(freq_2d))
The workers parameter enables parallel computation:
from scipy.fft import fftn
# 3D volume
volume = np.random.randn(128, 128, 128)
# Use 4 CPU cores
freq_3d = fftn(volume, workers=4)
What’s the norm Parameter?
The norm parameter controls FFT scaling. SciPy 1.6.0+ supports three modes:
from scipy.fft import fft, ifft
import numpy as np
signal = np.array([1, 2, 3, 4])
# Default: "backward" (no scaling on forward, 1/n on inverse)
freq = fft(signal, norm='backward')
recovered = ifft(freq, norm='backward')
# "ortho": sqrt scaling both directions (orthonormal)
freq = fft(signal, norm='ortho')
recovered = ifft(freq, norm='ortho')
# "forward": 1/n scaling on forward, no scaling on inverse
freq = fft(signal, norm='forward')
recovered = ifft(freq, norm='forward')
Default is 'backward'. Use 'ortho' if you want symmetric forward/inverse transforms.
Common Pitfalls and Solutions
Issue 1: FFT output is hard to interpret
The output isn’t ordered intuitively. Use fftshift():
from scipy.fft import fft, fftshift, fftfreq
frequencies = fft(signal)
freq_bins = fftfreq(len(signal), 1/sample_rate)
# Shift so 0 Hz is in center
frequencies_shifted = fftshift(frequencies)
freq_bins_shifted = fftshift(freq_bins)
Issue 2: Filtering creates artifacts
Abrupt cutoffs in frequency domain create ringing in time domain. Use a smooth window:
from scipy.signal import butter, filtfilt
# Better approach: use designed filters for audio/signals
# scipy.signal has proper filter design tools
b, a = butter(4, cutoff/(sample_rate/2), 'low')
filtered = filtfilt(b, a, signal)
Issue 3: Memory issues with large arrays
Process in chunks or use workers=-1 for auto-parallelization:
from scipy.fft import fft
# Use all available CPU cores
result = fft(large_signal, workers=-1)
scipy.fft vs numpy.fft: Which Should You Choose?
Use scipy.fft when:
- Processing multi-dimensional arrays (images, volumes)
- Need parallel computation (large datasets)
- Working with specialized transforms (DCT, DST)
- Performance matters
Use numpy.fft when:
- Simple 1D transforms on small arrays
- Want to avoid scipy dependency
- Working in numpy-only environment
scipy.fft is generally the better choice. It’s faster, more feature-complete, and actively maintained.
Real-World Example: Audio Processing
Here’s how to find the dominant frequency in an audio file:
from scipy.fft import rfft, rfftfreq
from scipy.io import wavfile
import numpy as np
# Load audio file
sample_rate, audio = wavfile.read('recording.wav')
# Convert stereo to mono if needed
if len(audio.shape) == 2:
audio = audio.mean(axis=1)
# Compute FFT (use rfft since audio is real-valued)
frequencies = rfft(audio)
freq_bins = rfftfreq(len(audio), 1/sample_rate)
# Find dominant frequency
magnitude = np.abs(frequencies)
dominant_idx = np.argmax(magnitude[1:]) + 1 # Skip DC component
dominant_freq = freq_bins[dominant_idx]
print(f"Dominant frequency: {dominant_freq:.2f} Hz")
This works for pitch detection, musical note identification, or engine RPM analysis.
