FFT computation (fft) in SciPy

Introduction

FFT helps us quickly find the frequencies inside a signal. It turns time data into frequency data.

You want to find the main tones in a sound recording.

You need to analyze the heartbeat pattern from sensor data.

You want to detect repeating patterns in stock prices.

You want to compress data by focusing on important frequencies.

Syntax

SciPy

from scipy.fft import fft

result = fft(data)

data is your input signal, usually a list or array of numbers.

The output result is a complex array showing frequency info.

Examples

Basic example: FFT of a simple array of 4 numbers.

SciPy

from scipy.fft import fft
import numpy as np

x = np.array([1, 2, 3, 4])
result = fft(x)
print(result)

FFT of a sine wave with frequency 5 Hz, showing first 10 frequency components.

SciPy

from scipy.fft import fft
import numpy as np

x = np.sin(2 * np.pi * 5 * np.linspace(0, 1, 100))
result = fft(x)
print(result[:10])

Sample Program

This program creates a signal with two sine waves at 5 Hz and 20 Hz. It uses FFT to find these frequencies and prints their amplitudes.

SciPy

from scipy.fft import fft
import numpy as np

# Create a signal with two frequencies
fs = 100  # Sampling rate 100 Hz
T = 1.0 / fs  # Sampling interval
N = 100  # Number of samples

# Time vector
x = np.linspace(0.0, (N-1)*T, N, endpoint=True)

# Signal: sum of 5 Hz and 20 Hz sine waves
y = np.sin(2*np.pi*5*x) + 0.5*np.sin(2*np.pi*20*x)

# Compute FFT
yf = fft(y)

# Compute frequency bins
xf = np.fft.fftfreq(N, T)[:N//2]

# Print frequencies with highest amplitudes
amplitudes = np.abs(yf[:N//2])

# Find top 2 frequencies
top_indices = amplitudes.argsort()[-2:][::-1]

for i in top_indices:
    print(f"Frequency: {xf[i]:.1f} Hz, Amplitude: {amplitudes[i]:.2f}")

Important Notes

The FFT output is complex numbers; use abs() to get amplitude.

Frequency bins can be found with np.fft.fftfreq() using sample spacing.

FFT works best when the number of samples is a power of two, but it can handle others too.

Summary

FFT changes time data into frequency data quickly.

Use scipy.fft.fft() to compute FFT in Python.

Look at the amplitude to find strong frequencies in your signal.

Practice

1. What does the scipy.fft.fft() function do in data analysis?

easy

A. It converts time-domain data into frequency-domain data.

B. It sorts data in ascending order.

C. It calculates the average of the data points.

D. It removes noise from the data.

Solution

1. Step 1: Understand the purpose of FFT

   FFT stands for Fast Fourier Transform, which changes data from time domain to frequency domain. This function computes the FFT, converting time-based signals into frequency components.

2. Final Answer:

   It converts time-domain data into frequency-domain data. -> Option A

3. Quick Check:

   FFT = Time to Frequency [OK]

Hint: FFT changes time data to frequency data fast [OK]

Common Mistakes:

• Thinking FFT sorts or averages data
• Confusing FFT with noise removal
• Assuming FFT works only on sorted data

2. Which of the following is the correct way to import and use FFT from scipy?

easy

A. from scipy import fft
result = fft(data)

B. from scipy.fft import fft
result = fft(data)

C. import scipy.fft
result = scipy.fft(data)

D. import fft from scipy
result = fft(data)

Solution

1. Step 1: Check correct import syntax

   The correct import is from scipy.fft import fft, not from scipy import fft or import fft from scipy. After importing, call fft(data) directly. Using scipy.fft(data) is incorrect because scipy.fft is a module, not a function.

2. Final Answer:

   from scipy.fft import fft result = fft(data) -> Option B

3. Quick Check:

   Correct import and call = from scipy.fft import fft result = fft(data) [OK]

Hint: Import fft directly from scipy.fft module [OK]

Common Mistakes:

• Trying to import fft directly from scipy
• Calling scipy.fft(data) instead of fft(data)
• Using wrong import syntax causing errors

3. What is the output of this code snippet?

import numpy as np
from scipy.fft import fft
x = np.array([1, 0, -1, 0])
result = fft(x)
print(np.round(result, 2))

medium

A. [0.+0.j 2.+0.j 0.+0.j 2.+0.j]

B. [0.+0.j 0.+0.j 0.+0.j 0.+0.j]

C. [0.+0.j 0.-2.j 0.+0.j 0.+2.j]

D. [0.+0.j 2.+0.j 0.+0.j -2.+0.j]

Solution

1. Step 1: Understand input signal

   The input array is [1, 0, -1, 0], a simple wave with 4 points. FFT of this sequence results in [0.+0.j, 2.+0.j, 0.+0.j, -2.+0.j].

2. Final Answer:

   [0.+0.j 2.+0.j 0.+0.j -2.+0.j] -> Option D

3. Quick Check:

   FFT of wave = [0.+0.j 2.+0.j 0.+0.j -2.+0.j] [OK]

Hint: FFT of simple wave shows peaks at frequency bins [OK]

Common Mistakes:

• Miscalculating the last frequency bin
• Confusing real and imaginary parts
• Rounding errors changing values

4. Identify the error in this FFT code and choose the fix:

import numpy as np
from scipy.fft import fft
x = [1, 2, 3, 4]
result = fft(x)
print(result.real)

medium

A. No error; code runs correctly.

B. x should be a numpy array, fix with x = np.array(x).

C. Import fft incorrectly; use import scipy.fft instead.

D. fft requires integer input only.

Solution

1. Step 1: Check input type requirements

   scipy.fft.fft accepts lists or numpy arrays as input. Using a Python list as input works fine; printing real part is valid.

2. Final Answer:

   No error; code runs correctly. -> Option A

3. Quick Check:

   List input accepted = No error; code runs correctly. [OK]

Hint: FFT accepts lists or arrays as input [OK]

Common Mistakes:

• Assuming input must be numpy array
• Wrong import statements causing errors
• Thinking fft only works with integers

5. You have a noisy signal sampled at 8 points: [1, 0, 1, 0, 1, 0, 1, 0]. You want to find the strongest frequency component using FFT. Which code correctly finds the frequency with the highest amplitude?

hard

A. import numpy as np
from scipy.fft import fft
x = np.array([1,0,1,0,1,0,1,0])
fft_vals = fft(x)
freq_index = np.argmin(np.abs(fft_vals))
print(freq_index)

B. import numpy as np
from scipy.fft import fft
x = [1,0,1,0,1,0,1,0]
fft_vals = fft(x)
freq_index = np.min(np.abs(fft_vals))
print(freq_index)

C. import numpy as np
from scipy.fft import fft
x = np.array([1,0,1,0,1,0,1,0])
fft_vals = fft(x)
freq_index = np.argmax(np.abs(fft_vals))
print(freq_index)

D. import numpy as np
from scipy.fft import fft
x = np.array([1,0,1,0,1,0,1,0])
fft_vals = fft(x)
freq_index = np.max(fft_vals.real)
print(freq_index)

Solution

1. Step 1: Compute FFT and get amplitudes

   Use fft(x) to get frequency components, then take absolute values to get amplitudes. Use np.argmax on amplitudes to find the strongest frequency index.

2. Final Answer:

   Use np.argmax(np.abs(fft_vals)) to find strongest frequency index. -> Option C

3. Quick Check:

   Max amplitude index = import numpy as np from scipy.fft import fft x = np.array([1,0,1,0,1,0,1,0]) fft_vals = fft(x) freq_index = np.argmax(np.abs(fft_vals)) print(freq_index) [OK]

Hint: Use np.argmax on absolute FFT values for strongest frequency [OK]

Common Mistakes:

• Using np.min or np.argmin instead of max
• Using only real part instead of magnitude
• Passing list without converting to array (still works but less common)