Разбить список на части на основе набора индексов в Python

Каков наилучший способ разбить список на части на основе произвольного количества индексов? Например, учитывая код ниже

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

вернуть что-то подобное

 part1 = list[:5] part2 = list[5:12] part3 = list[12:17] part4 = list[17:] 

Если индексов нет, он должен вернуть весь список.

9 Solutions collect form web for “Разбить список на части на основе набора индексов в Python”

Это самое простое и самое питоническое решение, о котором я могу думать:

 def partition(alist, indices): return [alist[i:j] for i, j in zip([0]+indices, indices+[None])] 

если входы очень большие, то решение итераторов должно быть более удобным:

 from itertools import izip, chain def partition(alist, indices): pairs = izip(chain([0], indices), chain(indices, [None])) return (alist[i:j] for i, j in pairs) 

и, конечно же, очень, очень ленивое решение парня (если вы не против получать массивы вместо списков, но в любом случае вы всегда можете вернуть их в списки):

 import numpy partition = numpy.split 

Мне было бы интересно увидеть более питонический способ сделать это. Но это дрянное решение. Вам нужно будет добавить проверку списка индексов 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 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])] 
 >>> 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 , и он не использует вещи whizzbang, такие как itertools, zip (), None как контролер, списки, …

😉

 indices = [5, 12, 17] input = range(20) output = [] reduce(lambda x, y: output.append(input[x:y]) or y, indices + [len(input)], 0) print output 

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

 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:])] 

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)] 

Конечно, копии массивов довольно дешевы (собственный код) по сравнению с интерпретированным 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(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]] >>> 

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

 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() 
Python - лучший язык программирования в мире.