请帮我用python写一个FFT程序

我可以为你提供一个简单的FFT程序的python代码：

import numpy as np

def fft(x):
"""A recursive implementation of the 1D Cooley-Tukey FFT"""
x = np.asarray(x, dtype=float)
N = x.shape[0]

if N % 2 > 0:
raise ValueError("size of x must be a power of 2")
elif N <= 32: # this cutoff should be optimized
return dft_slow(x)
else:
X_even = fft(x[::2])
X_odd = fft(x[1::2])
factor = np.exp(-2j * np.pi * np.arange(N) / N)
return np.concatenate([X_even + factor[:N // 2] * X_odd,
X_even + factor[N // 2:] * X_odd])

相关问题

用python 写一个fft滤波程序

好的，以下是一个使用Python实现FFT滤波的示例代码：

import numpy as np
import matplotlib.pyplot as plt

# 生成测试信号
fs = 1000  # 采样率
t = np.arange(0, 1, 1/fs)  # 时间序列
f1 = 50  # 信号1频率
f2 = 150  # 信号2频率
x = np.sin(2*np.pi*f1*t) + 0.5*np.sin(2*np.pi*f2*t)

# 可视化原始信号
plt.subplot(2, 1, 1)
plt.plot(t, x)
plt.title('Original Signal')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')

# 计算FFT
N = len(x)  # 信号长度
X = np.fft.fft(x)  # FFT结果
f = np.arange(0, fs/2, fs/N)  # 频率序列

# 可视化FFT结果
plt.subplot(2, 1, 2)
plt.plot(f, abs(X[:N//2]))
plt.title('FFT Result')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Amplitude')

# 进行滤波
fc = 80  # 截止频率
H = np.zeros(N//2)  # 滤波器频率响应
H[:fc] = 1  # 低通滤波器
H[-fc:] = 1  # 高通滤波器
X_filtered = X * H  # 滤波后的FFT结果
x_filtered = np.fft.ifft(X_filtered)  # 恢复时域信号

# 可视化滤波后的信号
plt.figure()
plt.plot(t, x_filtered.real)
plt.title('Filtered Signal')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.show()

上述代码首先生成了一个包含两个正弦波的测试信号，然后对其进行了FFT计算并可视化了结果。接下来，我们根据需要设定一个截止频率，生成一个低通或高通滤波器，并将其应用于FFT结果中。最后，使用ifft函数将滤波后的FFT结果转换回时域信号，并可视化滤波后的信号。

请用python 写一个 FFT程序，基2的FFT，点数可以通过参数配置

当然，我很乐意为您提供一个基于 Python 的基2的FFT程序。以下是实现过程：

import cmath

def fft(x):
    n = len(x)
    if n == 1:
        return x
    even = fft(x[0::2])
    odd = fft(x[1::2])
    T = [cmath.exp(-2j * cmath.pi * k / n) * odd[k] for k in range(n // 2)]
    return [even[k] + T[k] for k in range(n // 2)] + \
           [even[k] - T[k] for k in range(n // 2)]

def fft2(x):
    return fft(x)

def fftn(x):
    return fft(x)

def fftn_base(x, m, axes):
    n = x.shape
    return _fftnd(x, axes, [m] * len(axes), n)

def _fftnd(a, axes, s, n=None):
    if axes is None:
        axes = list(range(a.ndim))
    if n is None:
        n = a.shape
    for axis in axes:
        n = list(n)
        n[axis] = s[axes.index(axis)]
        n = tuple(n)
        a = a.swapaxes(axis, axes[0])
        a = a.reshape(n[0], -1)
        for ii in range(1, len(n)):
            n1 = n[ii]
            n2 = a.shape[1]
            coefs = np.zeros((n1, n2), a.dtype)
            for i in range(n1):
                for j in range(n2):
                    coefs[i, j] = np.exp((-2j * np.pi / n1) * (i * j % n1))
            a = coefs @ a
            a = a.reshape((n[ii], -1) + a.shape[2:]).swapaxes(0, axis)
    return a

def fft2_base(x, shape=None, axes=None):
    return _fft2nd(x, shape, axes, lambda a: fft(a, axis=-1))

def _fft2nd(a, s, axes, function):
    if s is None:
        s = a.shape
    if axes is None:
        axes =list(range(a.ndim))
    for ii in range(len(s)):
        if s[ii] is not None:
            a = ifftshift(a, axes[ii])
            n = a.shape
            d = s[ii] - n[ii]
            if d > 0:
                a = np.pad(a, [(0,0)] * a.ndim, 'constant')
            elif d < 0:
                l = [-d // 2] * a.ndim
                r = [(d + 1) // 2] * a.ndim
                r[ii] += d % 2
                slices = tuple([slice(None)] * a.ndim)
                for i in range(a.ndim):
                    if i != ii:
                        slices = slices[:i] + (l[i], r[i]) + slices[i+1:]
                a = a[slices]
            a = function(a, axis=-1)
            a = fftshift(a, axes[ii])
    return a

def fftfreq(n, d=1.0):
    return np.fft.fftfreq(n, d)

def fftshift(x, axes=None):
    if axes is None:
        axes = list(range(x.ndim))
    shift = [-(n // 2) for n in x.shape]
    for ax in axes:
        shift[ax] = x.shape[ax] - shift[ax]
    return np.roll(x, shift, axis=axes)

def ifftshift(x, axes=None):
    if axes is None:
        axes = list(range(x.ndim))
    shift = [-(n // 2) for n in x.shape]
    for ax in axes:
        shift[ax] = x.shape[ax] - shift[ax]
    return np.roll(x, shift, axis=axes)

调用方式如下：

x = [0, 1, 2, 3, 4, 5, 6, 7]
fft_result = fft(x)
print(fft_result)

我们可以通过调用 `fft` 函数来计算 `x` 的基2的FFT。在这个例子中，`x` 是一个8点序列。我们需要注意的一点是，在调用 `fft` 函数时，我们需要传递一个长度为2的幂的序列。另外，该程序实现了一系列其他的FFT函数，例如 `fftn`、`fft2`、`fftshift` 和 `ifftshift`，可以在您需要的时候使用。

希望以上代码对您有所帮助！