Разделить список на несколько списков на основе индексов [duplicate]

Множество индексов - это индексы. Переход к простоте / удобочитаемости.

indices = [5, 12, 17]
input = range(20)
output = []

for i in reversed(indices):
    output.append(input[i:])
    input[i:] = []
output.append(input)

while len(output):
    print output.pop()

Мое решение похоже на Il-Bhima.

>>> def parts(list_, indices):
...     indices = [0]+indices+[len(list_)]
...     return [list_[v:indices[k+1]] for k, v in enumerate(indices[:-1])]

Альтернативный подход

Если вы хотите немного изменить способ ввода индексов, от абсолютных индексов до относительных (т. е. от [5, 12, 17] до [5, 7, 5], ниже также вы получите желаемый результат, в то время как он не создает списки посредников.

>>> from itertools import islice
>>> def parts(list_, indices):
...     i = iter(list_)
...     return [list(islice(i, n)) for n in chain(indices, [None])]

Cide делает три копии массива: [0] + индексы копируют ([0] + индексы) + [] копирует снова, а индексы [: - 1] копируют в третий раз. Ил-Бхима составляет пять экземпляров. (Я не считаю возвращаемое значение, конечно.)

Эти могут быть уменьшены (izip, islice), но вот версия с нулевой копией:

def iterate_pairs(lst, indexes):
    prev = 0
    for i in indexes:
        yield prev, i
        prev = i
    yield prev, len(lst)

def partition(lst, indexes):
    for first, last in iterate_pairs(lst, indexes):
        yield lst[first:last]

indexes = [5, 12, 17]
lst = range(20)

print [l for l in partition(lst, indexes)]

Of Конечно, копии массивов довольно дешевы (собственный код) по сравнению с интерпретированным Python, но это имеет еще одно преимущество: его легко повторно использовать, чтобы напрямую мутировать данные:

for first, last in iterate_pairs(lst, indexes):
    for i in range(first, last):
        lst[i] = first
print lst
# [0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 5, 12, 12, 12, 12, 12, 17, 17, 17]

(Вот почему я передал индексы iterate_pairs.Если вас это не волнует, вы можете удалить этот параметр и просто иметь окончательную строку: «yield prev, None», который нужен всем разделам ().)

Это все, что я мог бы подумать о

def partition(list_, indexes):
    if indexes[0] != 0:
        indexes = [0] + indexes
    if indexes[-1] != len(list_):
        indexes = indexes + [len(list_)]
    return [ list_[a:b] for (a,b) in zip(indexes[:-1], indexes[1:])]

>>> def burst_seq(seq, indices):
...    startpos = 0
...    for index in indices:
...       yield seq[startpos:index]
...       startpos = index
...    yield seq[startpos:]
...
>>> list(burst_seq(range(20), [5, 12, 17]))
[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16], [17, 18, 19]]
>>> list(burst_seq(range(20), []))
[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]]
>>> list(burst_seq(range(0), [5, 12, 17]))
[[], [], [], []]
>>>

Maxima mea culpa: он использует оператор for, и он не использует такие вещи, как itertools, zip (), None как часовое, списки, ...

; -)

Мне было бы интересно увидеть более питонический способ сделать это. Но это дрянное решение. Вам нужно будет добавить проверку для списка индексов empry.

Что-то по строкам:

indexes = [5, 12, 17]
list = range(20)

output = []
prev = 0

for index in indexes:
    output.append(list[prev:index])
    prev = index

output.append(list[indexes[-1]:])

print output

производит

[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16], [17, 18, 19]]

Вот еще один ответ.

def partition(l, indexes):
    result, indexes = [], indexes+[len(l)]
    reduce(lambda x, y: result.append(l[x:y]) or y, indexes, 0)
    return result

Он поддерживает отрицательные индексы и т. д.

>>> partition([1,2,3,4,5], [1, -1])
[[1], [2, 3, 4], [5]]
>>>