How do I plot the FFT in Python?

After X = np.fft.rfft(signal) and freqs = np.fft.rfftfreq(N, 1/fs), plot with plt.plot(freqs, 2*np.abs(X)/N) for a properly scaled one-sided magnitude spectrum. Use plt.xlabel('Frequency (Hz)') and plt.ylabel('Amplitude'). For dB scale: plt.plot(freqs, 20*np.log10(np.abs(X)/N)).

What is the difference between numpy.fft and scipy.fft?

scipy.fft is the recommended module for new code — it supports multi-threading (workers parameter), automatic plan caching, and additional transform types (DCT, DST). numpy.fft provides basic FFT functionality and is always available without installing SciPy. Both produce identical results for the same inputs.

How do I apply a window function before FFT in Python?

Multiply the signal by the window array before FFT: windowed = signal * np.hanning(len(signal)); X = np.fft.rfft(windowed). NumPy provides np.hanning(), np.hamming(), np.blackman(), and np.bartlett(). SciPy's scipy.signal.windows module offers 20+ additional window types including Kaiser, Tukey, and flat-top.

Python Fft

Quick Answer

Python FFT is computed using numpy.fft.fft(x) for the Fast Fourier Transform, returning N complex frequency coefficients from N time samples. The frequency axis is generated with numpy.fft.fftfreq(N, d=1/fs) where fs is the sampling rate. For real signals, numpy.fft.rfft() computes only the positive-frequency half (N/2+1 points), saving computation and memory. SciPy's scipy.fft module provides additional features including multi-dimensional transforms and the DCT.

Calculate this instantly on LAPLACE Calculator →

Python FFT: Getting Started with NumPy

Python's NumPy library provides comprehensive FFT functionality via the numpy.fft module. The basic workflow: import numpy as np; x = your_signal_array; X = np.fft.fft(x) computes the N-point FFT, returning an array of N complex coefficients. The magnitude spectrum is np.abs(X), the phase spectrum is np.angle(X), and the power spectrum is np.abs(X)**2. The frequency axis is f = np.fft.fftfreq(N, d=1/fs), where fs is the sampling rate and d = 1/fs is the sample spacing. For plotting, use np.fft.fftshift() to center the zero-frequency component. For real-valued signals (which is most practical data), np.fft.rfft() computes only the non-redundant positive frequencies, returning N//2+1 coefficients instead of N. The analytical Fourier and Laplace transforms at www.lapcalc.com provide symbolic results that complement Python's numerical FFT analysis.

Key Formulas

Python Fast Fourier Transform: Complete Example

A complete Python FFT example: import numpy as np; import matplotlib.pyplot as plt; fs = 1000 (sampling rate 1 kHz); t = np.arange(0, 1, 1/fs) (1 second of data); x = np.sin(2*np.pi*50*t) + 0.5*np.sin(2*np.pi*120*t) (50 Hz + 120 Hz signal); X = np.fft.rfft(x); freqs = np.fft.rfftfreq(len(x), 1/fs); plt.plot(freqs, 2*np.abs(X)/len(x)); plt.xlabel('Frequency (Hz)'). This produces a spectrum with peaks at 50 Hz (amplitude 1.0) and 120 Hz (amplitude 0.5). The 2/N scaling converts raw FFT magnitudes to physical amplitudes (factor of 2 accounts for the one-sided spectrum). Adding a Hanning window: X = np.fft.rfft(x * np.hanning(len(x))) reduces spectral leakage for non-integer-period signals.

Compute python fft Instantly

Get step-by-step solutions with AI-powered explanations. Free for basic computations.

Open Calculator

SciPy FFT: Advanced Features

SciPy's scipy.fft module (replacing the older scipy.fftpack) provides enhanced FFT functionality. scipy.fft.fft() offers automatic zero-padding to the next power of 2 for speed, multi-threaded computation via the 'workers' parameter, and plan caching for repeated transforms. scipy.fft.dct() and scipy.fft.dst() compute Discrete Cosine and Sine Transforms for signal compression and boundary-value problems. scipy.signal integrates with FFT for practical signal processing: scipy.signal.welch() computes averaged power spectral density (Welch's method) for noise-robust spectral estimation, scipy.signal.spectrogram() generates time-frequency spectrograms, and scipy.signal.stft() computes the Short-Time Fourier Transform. The scipy.signal.freqz() function evaluates discrete-time filter frequency responses.

Fourier Transformation in Python: Practical Applications

Audio analysis: import librosa; y, sr = librosa.load('audio.wav'); S = np.abs(librosa.stft(y)) computes a spectrogram for music/speech analysis. Vibration monitoring: read accelerometer CSV data with pandas, FFT to identify fault frequencies (bearing defect, imbalance, misalignment). Image processing: from scipy.fft import fft2, ifft2; F = fft2(image) computes the 2D FFT for spatial frequency analysis, filtering (multiply F by a mask), and inverse transforming with ifft2. Signal filtering: design a frequency-domain filter H[k], multiply X[k]*H[k], and ifft to get the filtered signal — faster than time-domain convolution for long filters. Correlation: cross_corr = np.fft.ifft(np.fft.fft(x) * np.conj(np.fft.fft(y))) for fast cross-correlation via FFT.

Performance Tips for Python FFT

Optimize Python FFT performance with these techniques. Use power-of-2 lengths: np.fft.fft(x, n=2**int(np.ceil(np.log2(len(x))))) zero-pads to the next power of 2, which is 2–3× faster than arbitrary lengths. Use rfft for real data: rfft computes only positive frequencies, halving computation and memory. Use scipy.fft instead of numpy.fft for large transforms — it supports multi-threading (workers=-1 uses all CPU cores). For GPU acceleration: import cupy; X = cupy.fft.fft(cupy.array(x)) leverages NVIDIA CUDA for 10–100× speedup on large datasets. For repeated same-size transforms, pyfftw (Python wrapper for FFTW) provides 2–5× speedup over NumPy through plan optimization. Always pre-allocate output arrays and avoid unnecessary copies when processing streaming data.

Frequently Asked Questions

Use import numpy as np; X = np.fft.fft(signal) to compute the FFT. Get the frequency axis with freqs = np.fft.fftfreq(len(signal), d=1/sampling_rate). Plot the magnitude spectrum with matplotlib: plt.plot(freqs, np.abs(X)). For real signals, use np.fft.rfft() for efficiency — it returns only positive frequencies.

Master Your Engineering Math

Join thousands of students and engineers using LAPLACE Calculator for instant, step-by-step solutions.

Start Calculating Free →