FFT computation (fft) in SciPy - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does FFT stand for and what is its main purpose?

FFT stands for Fast Fourier Transform. It is a fast way to convert a signal from time domain to frequency domain, showing the different frequencies inside the signal.

beginner

In scipy, which function is commonly used to compute the FFT of a signal?

The function scipy.fft.fft() is used to compute the Fast Fourier Transform of a signal in Python using scipy.

intermediate

What type of data does scipy.fft.fft() accept and return?

scipy.fft.fft() accepts a 1D array of real or complex numbers representing the signal in time domain. It returns a 1D array of complex numbers representing the signal in frequency domain.

intermediate

Why is the output of FFT complex numbers?

The FFT output is complex because it contains both amplitude and phase information of each frequency component. The real part shows the cosine (in-phase) part, and the imaginary part shows the sine (out-of-phase) part.

intermediate

How can you get the frequency values corresponding to FFT output in scipy?

You can use scipy.fft.fftfreq() to get the frequency bins that correspond to each FFT output value. You need to provide the length of the signal and the sample spacing (time between samples).

What does scipy.fft.fft() return when applied to a time-domain signal?

A Time domain signal shifted by one sample

B Frequency domain representation as complex numbers

C Real numbers representing signal amplitude only

D Filtered signal with noise removed

scipy.fft.fft() converts a time-domain signal into its frequency domain representation, which is complex to hold amplitude and phase.

Which function helps find the frequency bins corresponding to FFT output in scipy?

A scipy.fft.fftfreq()

B scipy.fft.ifft()

C scipy.signal.freqz()

D scipy.fft.rfft()

scipy.fft.fftfreq() returns the frequency values for each FFT output index.

Why is FFT output complex instead of just real numbers?

A To make computation faster

B Because input must be complex

C To reduce noise in the signal

D To store both amplitude and phase information

Complex numbers in FFT output represent amplitude (magnitude) and phase (angle) of frequency components.

What is the main advantage of FFT over a direct Fourier transform?

A It removes noise automatically

B It uses less memory

C It is much faster to compute

D It works only on real signals

FFT is an algorithm that speeds up the Fourier transform calculation significantly.

If you have a signal sampled at 1000 Hz with 500 samples, what parameter do you pass to fftfreq() to get correct frequencies?

A Sample spacing = 1/1000

B Sample spacing = 1000

C Sample spacing = 500

D Sample spacing = 1/500

Sample spacing is the time between samples, which is the inverse of sampling rate (1/1000 seconds).

Explain in your own words what FFT does and why it is useful in analyzing signals.

Think about how music or sound can be broken down into notes or frequencies.

Describe how you would use scipy to compute the FFT of a signal and find the corresponding frequencies.

Consider the steps from raw data to frequency analysis.

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)