FFT computation (fft) in SciPy - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the FFT function from scipy.

SciPy

from scipy.fft import [1]

Drag options to blanks, or click blank then click option'

Afft

Bifft

Cfftshift

Drfft

Attempts:

3 left

💡 Hint

Common Mistakes

Importing the inverse FFT function ifft instead of fft.

Importing fftshift which is used for shifting zero frequency components.

The fft function computes the Fast Fourier Transform of a signal.

2fill in blank

medium

Complete the code to compute the FFT of the signal array.

SciPy

result = [1](signal)

Drag options to blanks, or click blank then click option'

Anp.fft

Bfft

Cscipy.fftshift

Difft

Attempts:

3 left

💡 Hint

Common Mistakes

Using ifft which computes the inverse FFT.

Using np.fft which is a module, not a function.

The fft function computes the FFT of the input array signal.

3fill in blank

hard

Fix the error in the code to correctly compute the FFT of the data array.

SciPy

from scipy.fft import fft

output = [1](data, n=128)

Drag options to blanks, or click blank then click option'

Afft

Bifft

Cfftshift

Drfft

Attempts:

3 left

💡 Hint

Common Mistakes

Using ifft instead of fft.

Using fftshift which only shifts the zero frequency component.

The fft function computes the FFT with specified length n=128.

4fill in blank

hard

Fill both blanks to create a dictionary of frequencies and their FFT magnitudes for values greater than 10.

SciPy

freq_magnitudes = {freq: abs(fft_result)[1] for freq, fft_result in zip(freqs, fft_values) if abs(fft_result) [2] 10}

Drag options to blanks, or click blank then click option'

A** 2

B>

C>=

D* 2

Attempts:

3 left

💡 Hint

Common Mistakes

Using multiplication * 2 instead of exponentiation ** 2.

Using >= instead of > in the condition.

The magnitude squared is calculated with abs(fft_result)**2, and we filter values greater than 10.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps frequency labels to FFT magnitudes for frequencies above 5 Hz.

SciPy

freq_dict = [1]: abs([2]) for [3], val in zip(freq_list, fft_vals) if [3] > 5}

Drag options to blanks, or click blank then click option'

Af'Freq_{freq}'

Bval

Cfreq

Dfreq_list

Attempts:

3 left

💡 Hint

Common Mistakes

Using the list name instead of the loop variable in the condition.

Using raw frequency values as keys instead of formatted strings.

The dictionary keys are formatted frequency labels using f'Freq_{freq}'. The values are the magnitudes of FFT values abs(val). The loop variable is freq which is compared to 5.

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)