Fatal编程技术网
  • python-3.x/
  • Python 3.x 用二进制文件条带分析表以选择较大的组元素

Python 3.x 用二进制文件条带分析表以选择较大的组元素

python-3.x

Python 3.x 用二进制文件条带分析表以选择较大的组元素,python-3.x,Python 3.x,我有一张如下所示的桌子（只长了很多）： 我只想收集与二进制==1相对应的所有时间，并且在小的组中，收集那些对应的频率值较高的组。在上表中，这将导致： times = 3.2, 14.1, 32.1 我不知道首先如何处理表的顺序，然后如何比较它们之间的值，只返回相应的时间（例如，不返回最大频率）。时间隐藏了一个周期性，因此我将避免构建另一个只包含binary==1元素的表 使用我的时间、二进制和频率数组，我可以通过以下方式隔离相关元素： condition = (binary == 1) tim

我有一张如下所示的桌子（只长了很多）：

我只想收集与
二进制==1
相对应的所有
时间，并且在小的组中，收集那些对应的
频率
值较高的组。在上表中，这将导致：


times = 3.2, 14.1, 32.1


我不知道首先如何处理表的顺序，然后如何比较它们之间的值，只返回相应的时间（例如，不返回最大频率）。时间隐藏了一个周期性，因此我将避免构建另一个只包含
binary==1
元素的表

使用我的
时间
、
二进制
和
频率
数组，我可以通过以下方式隔离相关元素：


condition = (binary == 1)
time1 = time(condition)
frequency1 = frequency(condition)



但我不知道如何继续分离各种条纹。我可以使用哪些有用的函数？
我不知道有什么聪明的函数可以用于此。这里有一些代码可以完成这项工作。请注意，我从您的文件中删除了标题


binary
为零或一，具体取决于组中是否包含其他值。最初，将组中的
设置为
False
，表示没有启动组。当读取行时，
binary
为零时，如果代码一直在为组读取行，因此，
in_group
为真，
in_group
设置为
False
，因为现在遇到零，该组已经结束。由于组的处理已经结束，现在是打印结果的时候了。读取行时，当
binary
为1时，如果
in_group
为True，则代码已经开始处理行是一个组，并且代码检查最新的
频率是否大于以前看到的值。如果是这样，它会同时更新
rep_time
和
rep_frequency
。如果组中的
为False，则这是新组的第一行，组中的
为True，并设置
重复时间
和
重复频率
的初始值


with open('pyser.txt') as pyser:
    in_group = False
    for line in pyser:
        _, time, binary, frequency = [float(_) for _ in line.rstrip().split()]
        if binary == 0:
            if in_group:
                in_group = False
                print (rep_time)
        else:
            if in_group:
                if frequency > rep_frequency:
                    rep_time, rep_frequency = time, frequency 
            else:
                in_group = True
                rep_time, rep_frequency = time, frequency 
if in_group:
    print (rep_time)


输出：


3.2
14.1
32.1


编辑：我们似乎使用了不同的问题定义



在第一组中，我们同意。但是，在第二组中，最大振幅约为4.07E-01，对应于约5.4740E+04的时间

我还用Pandas编写了代码：


>>> import pandas as pd
>>> df = pd.read_csv('Gyd9P1rb.txt', sep='\s+', skiprows=2, header=None, names='Row TSTOP PSRTIME DETECTED FDOTMAX AMPLITUDE AMPLITUDE_ERR'.split())
>>> del df['Row']
>>> del df['TSTOP']
>>> del df['FDOTMAX']
>>> del df['AMPLITUDE_ERR']
>>> groups = []
>>> in_group = False
>>> group_number = 1
>>> for b in df['DETECTED']:
...     if b:
...         if not in_group:
...             group_number +=1
...             in_group = True
...         groups.append(group_number)
...     else:
...         groups.append(0)
...         in_group = False
... 

>>> df['groups'] = pd.Series(groups, index=df.index)
>>> df.head()
        PSRTIME  DETECTED  AMPLITUDE  groups
0  54695.471283         1   0.466410       2
1  54698.532412         1   0.389607       2
2  54701.520814         1   0.252858       2
3  54704.557583         0   0.103460       0
4  54707.557563         0   0.088215       0
>>> gb = df.groupby(by=df['groups'])
>>> def f(x):
...     the_max = x['AMPLITUDE'].idxmax()
...     print ( x['groups'][the_max], x['PSRTIME'][the_max])
... 
>>> gb.apply(f)
0 58064.3656376
0 58064.3656376
2 54695.4712834
3 54740.4917137
4 54788.477571
5 54836.472922
6 54881.4605511
7 54926.4664883
8 54971.4932866
9 55019.5021472
10 55064.5029133
11 55109.4948108
12 55154.414381
13 55202.488766
14 55247.4721132
15 55292.5301332
16 55340.4728542
17 55385.5229596
18 55430.5332147
19 55478.4812671
20 55523.4894451
21 55568.4626766
22 55616.4630348
23 55661.4969604
24 55709.4504634
25 55754.4711994
26 55799.4736923
27 55844.5050404
28 55892.4699313
29 55937.4721754
30 55985.4677572
31 56030.5119765
32 56075.5517149
33 56168.4447074
34 56213.507484
35 56306.5133063
36 56351.4943058
37 56396.579122
38 56441.5683651
39 56489.5321173
40 56534.4838082
41 56582.469025
42 56627.4135202
43 56672.4926625
44 56720.582296
45 56768.5232469
46 56813.4997925
47 56858.3890558
48 56903.5182596
49 56951.4892721
50 56996.5787435
51 57086.3948136
52 57179.5421833
53 57272.5059448
54 57362.452523
55 57635.5013047
56 57728.4925251
57 57773.5235416
58 57821.5390364
59 57866.5205882
60 57911.5590132
61 57956.5699637
62 58001.4331976
Empty DataFrame
Columns: []
Index: []


这两种方法的结果是相同的，只是表示精度不同

我还创建了一个小数据集，可以给出容易计算的结果。就是这样。原程序执行正确


0 -1 0 -1
1 0 1 2
2 -1 0 -1
3 -1 0 -1
4 0 1 0
5 1 1 1
6 -1 0 -1
7 -1 0 -1
8 -1 0 -1
9 0 1 4
10 1 1 3
11 2 1 2
12 -1 0 -1
13 -1 0 -1
14 -1 0 -1
15 -1 0 -1
16 0 1 0
17 1 1 1
18 2 1 2
19 3 1 3
20 -1 0 -1
21 -1 0 -1
22 -1 0 -1
23 -1 0 -1
24 -1 0 -1
25 0 1 6
26 1 1 5
27 2 1 4
28 3 1 3
29 4 1 2
30 -1 0 -1
31 -1 0 -1
32 -1 0 -1
33 -1 0 -1
34 -1 0 -1
35 -1 0 -1
36 0 1 0
37 1 1 1
38 2 1 2
39 3 1 3
40 4 1 4
41 5 1 5
41 -1 0 -1
41 -1 0 -1



非常感谢。所以你决定按行而不是按行解析，我想这是有道理的。。。请你对代码稍加注释好吗？尤其是
if in_group:
对我来说不是很清楚。还有一点是错误的：它返回的
次数远远超过预期。这意味着它可能在同一时间计算更多的
时间
（它为每个
二进制==1
子组分配了不止一个
时间
。@Py ser:对不起！请你在某个地方发布一个更大的数据样本。@Py ser:。。。给我你对这个样本的预期结果。这里是一个数据示例。我所期望的是与局部最大
振幅相对应的时间列表（其中“局部”表示
检测==1
）：
时间=5.469547128344E+04、5.473746894780E+04、5.478847757096E+04、5.483948119222E+04、5.487547385719E+04等

0 -1 0 -1
1 0 1 2
2 -1 0 -1
3 -1 0 -1
4 0 1 0
5 1 1 1
6 -1 0 -1
7 -1 0 -1
8 -1 0 -1
9 0 1 4
10 1 1 3
11 2 1 2
12 -1 0 -1
13 -1 0 -1
14 -1 0 -1
15 -1 0 -1
16 0 1 0
17 1 1 1
18 2 1 2
19 3 1 3
20 -1 0 -1
21 -1 0 -1
22 -1 0 -1
23 -1 0 -1
24 -1 0 -1
25 0 1 6
26 1 1 5
27 2 1 4
28 3 1 3
29 4 1 2
30 -1 0 -1
31 -1 0 -1
32 -1 0 -1
33 -1 0 -1
34 -1 0 -1
35 -1 0 -1
36 0 1 0
37 1 1 1
38 2 1 2
39 3 1 3
40 4 1 4
41 5 1 5
41 -1 0 -1
41 -1 0 -1