Question

我正在尝试查找200个标签的序列并返回其索引。这是我的第一次尝试，但我确信必须有更好的方法（更快）......

序列必须是200的倍数，下一个序列小于200，然后拒绝它。

This image shows what my code does at the moment with labels at the top and indexes on the bottom

对于信号处理问题。新的python。

indexs = []
zeros = [0]*200
ones = [1]*200
twos = [2]*200
threes = [3]*200
fours = [4]*200
fives = [5]*200
i=0
while i < range(len(labels)):

    if i+200 > len(labels):
        break

    if labels[i:i+len(zeros)] == zeros:
        indexs.extend((range(i,i+len(zeros))))
        i+=200
        continue
    if labels[i:i+len(ones)] == ones:
        indexs.extend((range(i,i+len(zeros))))
        i+=200
        continue
    if labels[i:i+len(twos)] == twos:
        indexs.extend((range(i,i+len(zeros))))
        i+=200
        continue
    if labels[i:i+len(threes)] == threes:
        indexs.extend((range(i,i+len(zeros))))
        i+=200
        continue
    if labels[i:i+len(fours)] == fours:
        indexs.extend((range(i,i+len(zeros))))
        i+=200
        continue
    if labels[i:i+len(fives)] == fives:
        indexs.extend((range(i,i+len(zeros))))
        i+=200
        continue
    i+=1

编辑：

感谢所有人的反馈，我们非常感谢。我想我应该提一下，我正在处理大小为1M +且密集的阵列，因为它们大多数是200块。因此，我认为while循环可以让我跳过大多数循环。我的计划的一部分是通过取这200个块的平均值来减少维数，但也为分类器创建了许多功能。我在论文http://www.cis.fordham.edu/wisdm/includes/files/sensorKDD-2010.pdf中遵循了类似的方法。

这是类似（但更小）生成的数据

labels = [0]*1250+[1]*15400+[0]*12245+[5]*1204*[4]*20045

Edit2：继承了一些更简洁的代码，接受你的一些建议

def tensequencer(df):
    labels = df.activity.as_matrix().tolist()
    #find and store all indexs
    indexs = []
    zeros = [0]*200
    ones = [1]*200
    twos = [2]*200
    threes = [3]*200
    fours = [4]*200
    fives = [5]*200
    numbers = [zeros, ones, twos, threes, fours, fives]
    i=0
    while i < range(len(labels)):

        if i+200 > len(labels):
            break

        if labels[i:i+200] in numbers  :
            indexs.extend((range(i,i+len(zeros))))
            i+=200
            continue

        i+=1


    #index dataframe


    df = df.iloc[indexs,:]
    df.index=range(df.shape[0])
    return df

Answer 1

扫描标签，跟踪相同数字的序列以当前值结束的时间长度。只要该序列符合您的标准（即足够长），就将其添加到索引中。

一个皱纹：说有一个400 3的运行。从您的描述中不清楚这是否应该被计为2个200或1或400或两者的序列。如果只是最长的，那么在运行结束之前不要决定添加索引。

Answer 2

您提前知道需要多少次迭代：使用进行循环：

for i in range(len(labels) - 200):

这会消除您的中断语句。

接下来，您有六组几乎相同的检查序列。将所有六个列表放入一个列表（列表中），然后运行一个循环范围（6）进行标签检查。

更好的是，您熟悉地图和减少吗？你可以做一个很好的单行检查，询问标签[i + 1：i + 200]中的每个元素是否等于标签[0]。这将消除六倍的检查。

这会让你感动吗？

Answer 3

我不会讨论算法，只会对代码进行调整。您可以使用集来检查200个元素的列表是否由单个重复元素组成。

for i in range(len(labels) - 200):
    interval = labels[i:i+200]
    reduced = set(interval)
    if len(reduced) == 1:
        repeated_number = reduced.pop()

    # You have founded the number repeated 200 times consecutively.
    # Now do whatever you wish with it.

Answer 4

不确定在执行方面是否会更快，但这绝对是更好地维护：

indexs = []
for i in range(len(labels)):
    if i+200 > len(labels):
        break
    for j in range(0,6):
        cset = [j] * 200
        if labels[i:i+len(cset)] == cset:
            indexs.extend((range(i,i+len(cset))))
            i += 200
            break

如何在列表中查找值序列的索引？

4 个答案: