请求关于python写入excel文件的问题

incrediblejack

本例的主要功能：
将时域信号通过快速傅里叶变换FFT，转变为频域信号，并对频域信号提取特征，形成新的数据集。
其中，时域信号是很长的，傅里叶变换在原始时域信号上进行多次分段采样，之后的频域信号也是一段数据，而特征提取之后变成一个点，这样一段时域信号--对应一段频域信号--对应一个特征点，多段时域信号--对应多段频域信号--对应多个特征点。
最终形成一个集成了所有特征点的数据集excel文件。

但是目前有bug
错误为：
Traceback (most recent call last):
  File "C:/Users/Administrator/PycharmProjects/feature202005/p_61_03.py", line 185, in <module>
    ff1 = function_f1(xfp_value)    #调用f_1函数  输入是加了绝对值的频谱幅值xfp_value
  File "C:/Users/Administrator/PycharmProjects/feature202005/p_61_03.py", line 47, in function_f1
    sum_mid_f1_v1 = input[i]
IndexError: index 125 is out of bounds for axis 0 with size 125

源代码已附上。

各位大神帮忙看看咯！
谢谢！

另外，怎么添加附件呀？我没找到添加附件的选项，我的框框中只有表情和图片，没有“文件”那个按钮啊，所以我附上个链接吧，里面是数据集。
链接: https://pan.baidu.com/s/1U4gADju6QtH2ZRFDLEb3-g 提取码: fgcu

1. #这个版本是在p_61_02基础上改的。
   
2. #20200612  19:16
   
3. #时域和频域分别绘图
   
4. import numpy as np
   
5. import matplotlib.pyplot as plt
   
6. 
   
7. import os
   
8. os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
   
9. import xlrd
   
10. import math
    
11. import xlwt
    
12. 
    
13. workbook = xlwt.Workbook(encoding='utf-8')   #写入数据是用的临时变量
    
14. booksheet = workbook.add_sheet('Sheet 1', cell_overwrite_ok=True)
    
15. 
    
16. train1 = xlrd.open_workbook('shuangtu_13_14.xlsx')  #读取原始数据文件
    
17. table1 = train1.sheets()[0]    #提第一页sheet
    
18. len_train = 1000               #设置取用数据长度（可更改）
    
19. # p_a = [0 for i in range(len_train)]      #中间变量，列表p_a
    
20. # for i in range(len_train):             #1000次
    
21. #     p_a[i] = table1.row_values(i)[1]        #将第1列的内容，逐行读取，存入p_a列表
    
22. #原始数据集装入a
    
23. a = [0 for i in range(len_train)]      #中间变量，列表a
    
24. for i in range(len_train):             #1000次
    
25.     a[i]=table1.row_values(i)[1]       #将第1列的内容，逐行读取，存入a列表
    
26. 
    
27. fft_size = 250  #快速傅里叶变换长度
    
28. start_i = 1 #设置初始提取位置
    
29. #傅里叶变换的方法，封装成函数：
    
30. def Fast_Fourier_Trans(x):
    
31.     sampling_rate = 500    #采样频率
    
32.     t = np.linspace(0, 1, sampling_rate)  # 截取一段时间，截取是任意的，这里截取了0~1秒的一段时间。
    
33. 
    
34.     xs = x[start_i:start_i + fft_size]    #进行原始数据分割和提取，将用于进行傅里叶变换
    
35.     xf = 2*np.fft.rfft(xs) / fft_size  # 傅里叶变换公式，得到频谱幅值
    
36.     freqs = np.linspace(0, sampling_rate // 2, fft_size // 2 + 1)  #横轴： 表示频率, 从0开始，到采样频率//2，一共显示有包括首尾的fft_size/2  +1个数
    
37.     xfp = np.clip(np.abs(xf), 1e-20, 1e100)  #为了避免频谱幅值出现负数，添加的取绝对值的步骤。
    
38.     t_heng = t[start_i:start_i + fft_size]   # 为了后面显示用
    
39. 
    
40.     return (freqs, xfp, t_heng, xs, t, xf)  #多个返回值。
    
41. 
    
42. #特征函数，求f_1   对应公式5-12
    
43. def function_f1(input):
    
44.     sum_mid_f1_v1 = 0
    
45.     sum_mid_f1_v2 = 0
    
46.     for i in range(len(freqs_value)):
    
47.         sum_mid_f1_v1 = input[i]
    
48.         sum_mid_f1_v2 += sum_mid_f1_v1
    
49. 
    
50.         f_1 = sum_mid_f1_v2 / len(freqs_value)
    
51.     # print('平均能量,即f1：')
    
52.     # print(f_1)
    
53.     # print(' ')
    
54.     return f_1
    
55. 
    
56. #特征函数，求f_2    对应公式5-13
    
57. def function_f2(input):
    
58.     sum_mid_f2_v1 = 0
    
59.     sum_mid_f2_v2 = 0
    
60.     for i in range(len(freqs_value)):
    
61.         sum_mid_f2_v1 = (input[i] - function_f1(input)) ** 2  # 式子5-13分子括号里的
    
62.         sum_mid_f2_v2 += sum_mid_f2_v1  # 式子5-13分子。
    
63.         f_2 = sum_mid_f2_v2 / (len(freqs_value) - 1)
    
64.     # print('f2：')
    
65.     # print(f_2)
    
66.     # print(' ')
    
67.     return f_2
    
68. 
    
69. #特征函数，求f_3    对应公式5-14
    
70. def function_f3(input):
    
71.     sum_mid_f3_v1 = 0
    
72.     sum_mid_f3_v2 = 0
    
73.     for i in range(len(freqs_value)):
    
74.         sum_mid_f3_v1 = (input[i] - function_f1(input)) ** 3
    
75.         sum_mid_f3_v2 += sum_mid_f3_v1
    
76.         f_3 = sum_mid_f3_v2 / (len(freqs_value) * ((function_f2(input)) ** 1.5))
    
77.     # print('f3：')
    
78.     # print(f_3)
    
79.     # print(' ')
    
80.     return f_3
    
81. 
    
82. #特征函数，求f_4    对应公式5-15
    
83. def function_f4(input):
    
84.     sum_mid_f4_v1 = 0
    
85.     sum_mid_f4_v2 = 0
    
86.     for i in range(len(freqs_value)):
    
87.         sum_mid_f4_v1 = (input[i] - function_f1(input)) ** 4
    
88.         sum_mid_f4_v2 += sum_mid_f4_v1
    
89.         f_4 = sum_mid_f4_v2 / (len(freqs_value) * ((function_f2(input)) ** 2))
    
90.     # print('f4：')
    
91.     # print(f_4)
    
92.     # print(' ')
    
93.     return f_4
    
94. 
    
95. #特征函数，求f_5    对应公式5-16
    
96. def function_f5(input):
    
97.     sum_mid_f5_v1 = 0
    
98.     sum_mid_f5_v2 = 0
    
99.     sum_vid_f5_v3 = 0
    
100.     sum_mid_f5_v4 = 0
     
101.     for i in range(len(freqs_value)):
     
102.         sum_mid_f5_v1 = (freqs_value[i]) * (input[i])
     
103.         sum_mid_f5_v2 += sum_mid_f5_v1
     
104.         sum_mid_f5_v3 = input[i]
     
105.         sum_mid_f5_v4 += sum_mid_f5_v3
     
106.         f_5 = sum_mid_f5_v2/ sum_mid_f5_v4
     
107.     # print('f5:')
     
108.     # print(f_5)
     
109.     # print(' ')
     
110.     return f_5
     
111. 
     
112. #特征函数，求f_6    对应公式5-17
     
113. def function_f6(input):
     
114.     sum_mid_f6_v1 = 0  # fk^2*X(k)
     
115.     sum_mid_f6_v2 = 0  # ∑fk^2*X(k)
     
116.     sum_mid_f6_v3 = 0  # (∑fk^2*X(k))^0.5
     
117.     sum_mid_f6_v4 = 0  # 分母
     
118.     for i in range(len(freqs_value)):
     
119.         sum_mid_f6_v1 = ((freqs_value[i]) ** 2) * (input[i])
     
120.         sum_mid_f6_v2 += sum_mid_f6_v1
     
121.         sum_mid_f6_v3 = (sum_mid_f6_v2) ** 0.5  # 这个好像算不出来。
     
122.         sum_mid_f6_v4 += input[i]
     
123.         f_6 = sum_mid_f6_v3 / sum_mid_f6_v4
     
124.     # print('f6:')
     
125.     # print(f_6)
     
126.     # print(' ')
     
127.     return f_6
     
128. 
     
129. #特征函数，求f_7    对应公式5-18
     
130. def function_f7(input):
     
131.     sum_mid_f7_v1 = 0  # fk^4*X(k)
     
132.     sum_mid_f7_v2 = 0  # ∑fk^4*X(k)
     
133.     sum_mid_f7_v3 = 0  # (∑fk^4*X(k))^0.5
     
134.     sum_mid_f7_v4 = 0  # fk^2*X(k)
     
135.     sum_mid_f7_v5 = 0  # ∑fk^2*X(k)
     
136.     for i in range(len(freqs_value)):
     
137.         sum_mid_f7_v1 = ((freqs_value[i]) ** 4) * (input[i])
     
138.         sum_mid_f7_v2 += sum_mid_f7_v1
     
139.         sum_mid_f7_v3 = (sum_mid_f7_v2) ** 0.5
     
140.         sum_mid_f7_v4 = ((freqs_value[i]) ** 2) * (input[i])
     
141.         sum_mid_f7_v5 += sum_mid_f7_v4
     
142.         f_7 = sum_mid_f7_v3 / sum_mid_f7_v5
     
143.     # print('f7:')
     
144.     # print(f_7)
     
145.     # print(' ')
     
146.     return f_7
     
147. 
     
148. #特征函数，求f_8    对应公式5-19
     
149. def function_f8(input):
     
150.     sum_mid_f8_v1 = 0  # fk^2*X(k)
     
151.     sum_mid_f8_v2 = 0  # ∑fk^2*X(k)
     
152.     sum_mid_f8_v3 = 0  # fk^4*X(k)
     
153.     sum_mid_f8_v4 = 0  # ∑fk^4*X(k)
     
154.     sum_mid_f8_v5 = 0  # X(k)
     
155.     sum_mid_f8_v6 = 0  # ∑X(k)
     
156.     sum_mid_f8_v7 = 0  # (∑fk^4*X(k))*(∑X(k))
     
157.     for i in range(len(freqs_value)):
     
158.         sum_mid_f8_v1 = ((freqs_value[i]) ** 2) * (input[i])
     
159.         sum_mid_f8_v2 += sum_mid_f8_v1
     
160.         sum_mid_f8_v3 = ((freqs_value[i]) ** 4) * (input[i])
     
161.         sum_mid_f8_v4 += sum_mid_f8_v3
     
162.         sum_mid_f8_v5 = input[i]
     
163.         sum_mid_f8_v6 += sum_mid_f8_v5
     
164.         sum_mid_f8_v7 = (sum_mid_f8_v4) * (sum_mid_f8_v6)
     
165.         f_8 = (sum_mid_f8_v7) ** 0.5
     
166.     # print('f8:')
     
167.     # print(f_8)
     
168.     # print(' ')
     
169.     return f_8
     
170. 
     
171. #主流程
     
172. for j in range(len_train // fft_size):    #这个变量是为了控制写入数据的行数 j
     
173.     if j < 2:
     
174. 
     
175.         for er in range(len_train // fft_size):  #这个变量是为了控制运行傅立叶变换Fft函数的次数 er
     
176.             Fft = Fast_Fourier_Trans(a)     #调用快速傅里叶变换函数Fft，输入是提取了len_train长度的原始a列表数据
     
177. 
     
178.             freqs_value = Fft[0]    #Fft返回值，这个是干啥的？
     
179.             xfp_value = Fft[1]      #Fft返回值，返回加了绝对值的频谱幅值
     
180.             t_heng_value = Fft[2]   #Fft返回值，返回当前时域（Fft变换之前的）横坐标值
     
181.             xs_value = Fft[3]       #Fft返回值，返回当前时域（Fft变换之前的）纵坐标值
     
182.             t_value = Fft[4]        #Fft返回值，返回采样间隔么？
     
183.             xf_value = Fft[5]       #Fft返回值，返回未加绝对值的频谱幅值（可能会有负的，所以不用这个）
     
184. 
     
185.             ff1 = function_f1(xfp_value)    #调用f_1函数  输入是加了绝对值的频谱幅值xfp_value
     
186.             print("ff1:")
     
187.             print(ff1)    #测试用
     
188.             print(' ')
     
189.             ff2 = function_f2(xfp_value)    #调用f_2函数。。。下面道理类同
     
190.             print("ff2:")
     
191.             print(ff2)
     
192.             print(' ')
     
193.             ff3 = function_f3(xfp_value)
     
194.             ff4 = function_f4(xfp_value)
     
195.             ff5 = function_f5(xfp_value)
     
196.             ff6 = function_f6(xfp_value)
     
197.             ff7 = function_f7(xfp_value)
     
198.             ff8 = function_f8(xfp_value)
     
199. 
     
200. 
     
201. 
     
202.             rowdata = [ff1, ff2, ff3, ff4, ff5, ff6, ff7, ff8]   #形成一行数值
     
203.             print('rowdata:')
     
204.             print(rowdata)   #测试用
     
205.             print(' ')
     
206. 
     
207.             for i in range(len(rowdata)):    #这个变量i是为了遍历上面的rowdata，为了将来写入excel表格
     
208. 
     
209.                 booksheet.write(j,i, rowdata[i])   #读取rowdata的第i个，写入excel的第j列，第i行
     
210.                 i += 1
     
211. 
     
212. 
     
213.             er += 1
     
214.             start_i += fft_size  #执行完一轮Fft之后变量start_i增加一个采样周期fft_size之后重新计算
     
215. 
     
216.         j += 1
     
217. 
     
218.     else:
     
219.         break
     
220. 
     
221. 
     
222. 
     
223. plt.figure(figsize=(8,8))  #生成画布
     
224. plt.subplot(211)    #生成子图  #这个图是
     
225. plt.plot(t_heng_value, xs_value)  #时域图
     
226. plt.xlabel(u'时间（秒）', fontproperties='FangSong')
     
227. plt.title(u'原始幅值',fontproperties='FangSong')
     
228. 
     
229. plt.subplot(212)
     
230. plt.plot(freqs_value, xfp_value)  ##频域图
     
231. plt.xlabel(u'频率（HZ）', fontproperties='FangSong')
     
232. plt.ylabel(u'幅值',fontproperties='FangSong')
     
233. plt.subplots_adjust(hspace=0.4)
     
234. 
     
235. 
     
236. 
     
237. plt.show()
     
238. # print('xfp_value')
     
239. # print(xfp_value)
     
240. # print(' ')
     
241. # print('xfp_value 傅立叶变换后的点纵坐标的个数：')
     
242. # print(len(xfp_value))
     
243. # print(' ')
     
244. # print('xs_value 傅里叶变换后的点横坐标的个数：')
     
245. # print(len(xs_value))
     
246. # print(' ')
     
247. 
     
248. 
     
249. workbook.save('p_61_02.xls')   #保存
     
250. 
     

复制代码

Twilight6

IndexError: index 125 is out of bounds for axis 0 with size 125

应该是你的 excel 文件数据有问题，看下125行是不是空行？

jijidebaba

将时域信号通过快速傅里叶变换FFT，转变为频域信号，并对频域信号提取特征，形成新的数据集。

我记得Origin有直接FFT的选项，你可以试试这个，看看原始数据有没有问题

incrediblejack

Twilight6 发表于 2020-6-3 07:32
应该是你的 excel 文件数据有问题，看下125行是不是空行？

我看了，原始数据没有空行。我如果更改sampling_rate、fft_size等参数，这个报错的125还会变成其他数值的。

incrediblejack

jijidebaba 发表于 2020-6-3 07:58
我记得Origin有直接FFT的选项，你可以试试这个，看看原始数据有没有问题

谢谢，回头我可以试试，但是这个基于numpy的FFT的组装成新表格的例子，我没有搞定的话实在是迈不过去这个坎儿啊

Twilight6

incrediblejack 发表于 2020-6-3 09:03
我看了，原始数据没有空行。我如果更改sampling_rate、fft_size等参数，这个报错的125还会变成其他数值的 ...

好吧

rsj0315

上传附件是有权限的，不同账号等级，功能不能。
努力回帖，发帖升级吧。
到达鱼油1，就可以发截图了。

incrediblejack

一直没有人回复给我正确的答案，我写了个简单版的，以排除傅里叶变换对结果可能带来的影响，见帖子：https://fishc.com.cn/forum.php?mod=viewthread&tid=171185&page=1#pid4738298
感谢在这个帖子中 @yifenyu 提供的修改思路。
我在那个帖子的答案的基础上，把傅里叶变换内容加进去了，经过运行结果正确。鉴于目前没人提供答案，那我就自己把改过的代码粘上来咯。只能发自己最佳答案了嘿嘿，各位见谅~
改后的代码：

1. #本例在20200603的基础上，加上了傅里叶变换的内容，也就是频域特征提取，然后看能否实现提取后形成一个新的表格功能。
   
2. #20200605写的
   
3. import numpy as np
   
4. import matplotlib.pyplot as plt
   
5. import os
   
6. os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
   
7. import xlrd
   
8. import xlwt
   
9. import typing
   
10. 
    
11. workbook = xlwt.Workbook(encoding='utf-8')
    
12. booksheet = workbook.add_sheet('Sheet 1', cell_overwrite_ok=True)
    
13. 
    
14. train1 = xlrd.open_workbook('shuangtu_13_14.xlsx')  #读取原始数据文件
    
15. table1 = train1.sheets()[0]    #提第一页sheet
    
16. len_train = 20003              #设置取用数据长度（可更改）
    
17. a = [0 for i in range(len_train)]      #中间变量，列表a
    
18. for i in range(len_train):             #1000次
    
19.     a[i]=table1.row_values(i)[1]       #将第1列的内容，逐行读取，存入a列表
    
20. 
    
21. 
    
22. #全局变量
    
23. changdu = 250
    
24. start_i = 1
    
25. 
    
26. def calculateMean(x, start_i):    #注意，这里我原来写的是这样，def calculateMean(x)，别人帮我改了。就是这个新逻辑。
    
27. 
    
28.     xf = []
    
29.     xs = x[start_i:start_i + changdu]
    
30.     for p in xs:
    
31.         xf.append(p*p*3)   #注意这里不要写成 xf = xf.apppend(p*3)
    
32. 
    
33.     return (x, xs, xf)
    
34. 
    
35. #傅立叶变换函数
    
36. def Fast_Fourier_Trans(x, start_i):
    
37.     sampling_rate = 500 #采样频率
    
38.     t = np.linspace(0,1,sampling_rate)   #截取一段时间，这个有待研究
    
39.     xs = x[start_i:start_i+changdu]
    
40.     xf = 2*np.fft.rfft(xs) / changdu   #傅立叶变换计算公式，得到频谱幅值
    
41.     freqs = np.linspace(0, sampling_rate // 2, changdu//2 + 1)    #这个干啥用的？回头自己在图中改改试试
    
42.     xft = np.clip(np.abs(xf), 1e-10, 1e100) #频谱幅值加了绝对值之后的。为了避免出现负数。
    
43.     t_heng = t[start_i:start_i+changdu]   #不知道用上用不上。随后再更改。
    
44. 
    
45.     return (t, xs, xf, freqs, xft, t_heng)   #[0]:t  [1]:xs  [2]:xf  [3]:freqs  [4]:xft  [5]t_heng
    
46. 
    
47. 
    
48. #f1
    
49. def func_f1(input):
    
50.     sum_mid_f1_v1 = 0  # 当前值
    
51.     sum_mid_f1_v2 = 0  # 加和值
    
52.     for i in range(len(res_freqs)):
    
53.         sum_mid_f1_v1 = input[i]
    
54.         sum_mid_f1_v2 += sum_mid_f1_v1
    
55.     f_1 = sum_mid_f1_v2 / len(res_freqs)
    
56.     return f_1
    
57. 
    
58. #f2
    
59. def func_f2(input):
    
60.     sum_mid_f2_v1 = 0
    
61.     sum_mid_f2_v2 = 0
    
62.     for i in range(len(res_freqs)):
    
63.         sum_mid_f2_v1 = (input[i] - func_f1(input)) ** 2  # 式子5-13分子括号里的   #注意这里func_f1不能去掉(input)
    
64.         sum_mid_f2_v2 += sum_mid_f2_v1  # 式子5-13分子。
    
65.     f_2 = sum_mid_f2_v2 / (len(res_freqs) - 1)
    
66.     return f_2
    
67. 
    
68. #f3
    
69. def func_f3(input):
    
70.     sum_mid_f3_v1 = 0
    
71.     sum_mid_f3_v2 = 0
    
72.     for i in range(len(res_freqs)):
    
73.         sum_mid_f3_v1 = (input[i] - func_f1(input)) ** 3   #注意这里先不去掉(input)试试，后同。
    
74.         sum_mid_f3_v2 += sum_mid_f3_v1
    
75.     f_3 = sum_mid_f3_v2 / (len(res_freqs) * ((func_f2(input)) ** 1.5))
    
76.     return f_3
    
77. 
    
78. #f4
    
79. def func_f4(input):
    
80.     sum_mid_f4_v1 = 0
    
81.     sum_mid_f4_v2 = 0
    
82.     for i in range(len(res_freqs)):
    
83.         sum_mid_f4_v1 = (input[i] - func_f1(input)) ** 4
    
84.         sum_mid_f4_v2 += sum_mid_f4_v1
    
85.     f_4 = sum_mid_f4_v2 / (len(res_freqs) * ((func_f2(input)) ** 2))
    
86.     return f_4
    
87. 
    
88. #f5
    
89. def func_f5(input):
    
90.     sum_mid_f5_v1 = 0
    
91.     sum_mid_f5_v2 = 0
    
92.     sum_vid_f5_v3 = 0
    
93.     sum_mid_f5_v4 = 0
    
94.     for i in range(len(res_freqs)):
    
95.         sum_mid_f5_v1 = (res_freqs[i]) * (input[i])   #这个公式对么？对照公式看一看。后面也检查下
    
96.         sum_mid_f5_v2 += sum_mid_f5_v1
    
97.         sum_mid_f5_v3 = input[i]
    
98.         sum_mid_f5_v4 += sum_mid_f5_v3
    
99.     f_5 = sum_mid_f5_v2/ sum_mid_f5_v4
    
100.     return f_5
     
101. 
     
102. #f6:
     
103. def func_f6(input):
     
104.     sum_mid_f6_v1 = 0  # fk^2*X(k)
     
105.     sum_mid_f6_v2 = 0  # ∑fk^2*X(k)
     
106.     sum_mid_f6_v3 = 0  # (∑fk^2*X(k))^0.5
     
107.     sum_mid_f6_v4 = 0  # 分母
     
108.     for i in range(len(res_freqs)):
     
109.         sum_mid_f6_v1 = ((res_freqs[i]) ** 2) * (input[i])
     
110.         sum_mid_f6_v2 += sum_mid_f6_v1
     
111.         sum_mid_f6_v3 = (sum_mid_f6_v2) ** 0.5  # 这个好像算不出来。
     
112.         sum_mid_f6_v4 += input[i]
     
113.     f_6 = sum_mid_f6_v3 / sum_mid_f6_v4
     
114.     return f_6
     
115. 
     
116. #f7:
     
117. def func_f7(input):
     
118.     sum_mid_f7_v1 = 0  # fk^4*X(k)
     
119.     sum_mid_f7_v2 = 0  # ∑fk^4*X(k)
     
120.     sum_mid_f7_v3 = 0  # (∑fk^4*X(k))^0.5
     
121.     sum_mid_f7_v4 = 0  # fk^2*X(k)
     
122.     sum_mid_f7_v5 = 0  # ∑fk^2*X(k)
     
123.     for i in range(len(res_freqs)):
     
124.         sum_mid_f7_v1 = ((res_freqs[i]) ** 4) * (input[i])
     
125.         sum_mid_f7_v2 += sum_mid_f7_v1
     
126.         sum_mid_f7_v3 = (sum_mid_f7_v2) ** 0.5
     
127.         sum_mid_f7_v4 = ((res_freqs[i]) ** 2) * (input[i])
     
128.         sum_mid_f7_v5 += sum_mid_f7_v4
     
129.     f_7 = sum_mid_f7_v3 / sum_mid_f7_v5
     
130.     return f_7
     
131. 
     
132. #f8:
     
133. def func_f8(input):
     
134.     sum_mid_f8_v1 = 0  # fk^2*X(k)
     
135.     sum_mid_f8_v2 = 0  # ∑fk^2*X(k)
     
136.     sum_mid_f8_v3 = 0  # fk^4*X(k)
     
137.     sum_mid_f8_v4 = 0  # ∑fk^4*X(k)
     
138.     sum_mid_f8_v5 = 0  # X(k)
     
139.     sum_mid_f8_v6 = 0  # ∑X(k)
     
140.     sum_mid_f8_v7 = 0  # (∑fk^4*X(k))*(∑X(k))
     
141.     for i in range(len(res_freqs)):
     
142.         sum_mid_f8_v1 = ((res_freqs[i]) ** 2) * (input[i])
     
143.         sum_mid_f8_v2 += sum_mid_f8_v1
     
144.         sum_mid_f8_v3 = ((res_freqs[i]) ** 4) * (input[i])
     
145.         sum_mid_f8_v4 += sum_mid_f8_v3
     
146.         sum_mid_f8_v5 = input[i]
     
147.         sum_mid_f8_v6 += sum_mid_f8_v5
     
148.         sum_mid_f8_v7 = (sum_mid_f8_v4) * (sum_mid_f8_v6)
     
149.     f_8 = (sum_mid_f8_v7) ** 0.5
     
150.     return f_8
     
151. 
     
152. for j in range(len_train // changdu):
     
153.     fun_FFT = Fast_Fourier_Trans(a, j*changdu)
     
154.     res_t = fun_FFT[0]
     
155.     res_xs = fun_FFT[1]
     
156.     res_xf = fun_FFT[2]
     
157.     res_freqs = fun_FFT[3]
     
158.     res_xft = fun_FFT[4]
     
159.     res_t_heng = fun_FFT[5]
     
160. 
     
161.     ff1 = func_f1(res_xft)
     
162.     ff2 = func_f2(res_xft)
     
163.     ff3 = func_f3(res_xft)
     
164.     ff4 = func_f4(res_xft)
     
165.     ff5 = func_f5(res_xft)
     
166.     ff6 = func_f6(res_xft)
     
167.     ff7 = func_f7(res_xft)
     
168.     ff8 = func_f8(res_xft)
     
169. 
     
170.     rowdata = [ff1,ff2,ff3,ff4,ff5,ff6,ff7,ff8]
     
171.     for i in range(len(rowdata)):
     
172.         booksheet.write(j, i, rowdata[i])
     
173. 
     
174. workbook.save('20200605_fourier.xls')
     
175. 
     
176. 
     
177. #这个例子可以实现喔。
     

复制代码

incrediblejack

incrediblejack 发表于 2020-6-5 15:22
一直没有人回复给我正确的答案，我写了个简单版的，以排除傅里叶变换对结果可能带来的影响，见帖子：https: ...

诶？自己没法给自己设置最佳答案诶

jijidebaba

向楼主学习，以后批量处理时域场的数据说不定可以用到

incrediblejack

jijidebaba 发表于 2020-6-6 16:08
向楼主学习，以后批量处理时域场的数据说不定可以用到

过奖过奖，是我应该多虚心学习