Python拆分列表（如果找到数字序列）

Question

I've been trying to find a relevant question, though I can't seem to search for the right words and all I'm finding is how to check if a list contains an intersection.

Basically, I need to split a list once a certain sequence of numbers is found, similar to doing str.split(sequence)[0] , but with lists instead. I have working code, though it doesn't seem very efficient (also no idea if raising an error was the right way to go about it), and I'm sure there must be a better way to do it.

For the record, long_list could potentially have a length of a few million values, which is why I think iterating through them all might not be the best idea.

long_list = [2,6,4,2,7,98,32,5,15,4,2,6,43,23,95,10,31,5,1,73]
end_marker = [6,43,23,95]
end_marker_len = len(end_marker)

class SuccessfulTruncate(Exception):
    pass
try:
    counter = 0
    for i in range(len(long_list)):
        if long_list[i] == end_marker[counter]:
            counter += 1
        else:
            counter = 0
        if counter == end_marker_len:
            raise SuccessfulTruncate()
except SuccessfulTruncate:
    long_list = long_list[:2 + i - end_marker_len]
else:
    raise IndexError('sequence not found')

>>> long_list
[2,6,4,2,7,98,32,5,15,4,2]

Ok, timing a few answers with a big list of 1 million values (the marker is very near the end):

Tim: 3.55 seconds
Mine: 2.7 seconds
Dan: 0.55 seconds
Andrey: 0.28 seconds
Kasramvd: still executing :P

Answer 1

I have working code, though it doesn't seem very efficient (also no idea if raising an error was the right way to go about it), and I'm sure there must be a better way to do it.

I commented on the exception raising in my comment

Instead of raising an exception and catching it in the same try/except you can just omit the try/except and do if counter == end_marker_len: long_list = long_list[:2 + i - end_marker_len] . Successful is not a word thats fitting for an exception name. Exceptions are used to indicate that something failed

Anyway, here is a shorter way:

>>> long_list = [2,6,4,2,7,98,32,5,15,4,2,6,43,23,95,10,31,5,1,73]
>>> end_marker = [6,43,23,95]
>>> index = [i for i in range(len(long_list)) if long_list[i:i+len(end_marker)] == end_marker][0]
>>> long_list[:index]
[2, 6, 4, 2, 7, 98, 32, 5, 15, 4, 2]

List comprehension inspired by this post

Answer 2

As a more pythonic way instead of multiple slicing you can use itertools.islice within a list comprehension :

>>> from itertools import islice
>>> M,N=len(long_list),len(end_maker)
>>> long_list[:next((i for i in range(0,M) if list(islice(long_list,i,i+N))==end_marker),0)]
[2, 6, 4, 2, 7, 98, 32, 5, 15, 4, 2]

Note that since the default value of next function is 0 if it doesn't find any match it will returns the whole of long_list .

Answer 3

If the values are of limited range, say fit in bytes (this can also be adapted to larger types), why not then encode the lists so that the string method find could be used:

long_list = [2,6,4,2,7,98,32,5,15,4,2,6,43,23,95,10,31,5,1,73]
end_marker = [6,43,23,95]

import struct

long_list_p = struct.pack('B'*len(long_list), *long_list)
end_marker_p = struct.pack('B'*len(end_marker), *end_marker)

print long_list[:long_list_p.find(end_marker_p)]

Prints:

[2, 6, 4, 2, 7, 98, 32, 5, 15, 4, 2]

I tried using bytes as in but the find method they had didn't work:

print long_list[:bytes(long_list).find(bytes(end_marker))]

Answer 4

In my solution used approach with index method:

input = [2,6,4,2,7,98,32,5,15,4,2,6,43,23,95,10,31,5,1,73]
brk = [6,43,23,95]
brk_len = len(brk)
brk_idx = 0
brk_offset = brk_idx + brk_len

try:
    while input[brk_idx:brk_offset] != brk:
        brk_idx = input.index(brk[0], brk_idx + 1)
        brk_offset = brk_idx + brk_len
except ValueError: 
    print("Not found")
else:
    print(input[:brk_idx])