разделить генератор / повторяемый каждые n элементов в Python (splitEvery)

Question

Я пытаюсь написать функцию Haskel 'splitEvery' на Python. Вот его определение:

splitEvery :: Int -> [e] -> [[e]]
    @'splitEvery' n@ splits a list into length-n pieces.  The last
    piece will be shorter if @n@ does not evenly divide the length of
    the list.

Базовая версия этого прекрасно работает, но я хочу версию, которая работает с выражениями генератора, списками и итераторами. И , если в качестве входа используется генератор, он должен возвращать генератор в качестве выхода!

Тесты

# should not enter infinite loop with generators or lists
splitEvery(itertools.count(), 10)
splitEvery(range(1000), 10)

# last piece must be shorter if n does not evenly divide
assert splitEvery(5, range(9)) == [[0, 1, 2, 3, 4], [5, 6, 7, 8]]

# should give same correct results with generators
tmp = itertools.islice(itertools.count(), 10)
assert list(splitEvery(5, tmp)) == [[0, 1, 2, 3, 4], [5, 6, 7, 8]]

Текущая реализация

Вот код, который у меня сейчас есть, но он не работает с простым списком.

def splitEvery_1(n, iterable):
    res = list(itertools.islice(iterable, n))
    while len(res) != 0:
        yield res
        res = list(itertools.islice(iterable, n))

Это не работает с выражением генератора (спасибо jellybean за исправление):

def splitEvery_2(n, iterable): 
    return [iterable[i:i+n] for i in range(0, len(iterable), n)]

Должен быть простой фрагмент кода, который выполняет разбиение. Я знаю, что у меня могут быть разные функции, но кажется, что это должно быть легко сделать. Я, вероятно, застреваю на неважной проблеме, но это действительно беспокоит меня.

---

Это похоже на grouper из http://docs.python.org/library/itertools.html#itertools.groupby, но я не хочу, чтобы он заполнял дополнительные значения.

def grouper(n, iterable, fillvalue=None):
    "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

В нем упоминается метод, который усекает последнее значение. Это тоже не то, чего я хочу.

Порядок вычислений итераций слева направо гарантирован. Это делает возможным объединение ряда данных в группы n-длины с использованием izip (* [iter (s)] * n).

list(izip(*[iter(range(9))]*5)) == [[0, 1, 2, 3, 4]]
# should be [[0, 1, 2, 3, 4], [5, 6, 7, 8]]

Answer 1

from itertools import islice

def split_every(n, iterable):
    i = iter(iterable)
    piece = list(islice(i, n))
    while piece:
        yield piece
        piece = list(islice(i, n))

Некоторые тесты:

>>> list(split_every(5, range(9)))
[[0, 1, 2, 3, 4], [5, 6, 7, 8]]

>>> list(split_every(3, (x**2 for x in range(20))))
[[0, 1, 4], [9, 16, 25], [36, 49, 64], [81, 100, 121], [144, 169, 196], [225, 256, 289], [324, 361]]

>>> [''.join(s) for s in split_every(6, 'Hello world')]
['Hello ', 'world']

>>> list(split_every(100, []))
[]

Answer 2

Вот быстрая однострочная версия. Как и у Хаскелла, он ленивый.

from itertools import islice, takewhile, repeat
split_every = (lambda n, it:
    takewhile(bool, (list(islice(it, n)) for _ in repeat(None))))

Это требует, чтобы вы использовали iter до вызова split_every.

Пример:

list(split_every(5, iter(xrange(9))))
[[0, 1, 2, 3, 4], [5, 6, 7, 8]]

Хотя это и не одна строка, в приведенной ниже версии не требуется, чтобы вы вызывали iter, что может быть распространенной ошибкой.

from itertools import islice, takewhile, repeat

def split_every(n, iterable):
    """
    Slice an iterable into chunks of n elements
    :type n: int
    :type iterable: Iterable
    :rtype: Iterator
    """
    iterator = iter(iterable)
    return takewhile(bool, (list(islice(iterator, n)) for _ in repeat(None)))

(Спасибо @ eli-korvigo за улучшения.)

Answer 3

more_itertools имеет функцию chunked:

import more_itertools as mit


list(mit.chunked(range(9), 5))
# [[0, 1, 2, 3, 4], [5, 6, 7, 8]]

Answer 4

построение на основе принятого ответа и использование менее известного использования iter (то есть, когда передается второй аргумент, он вызывает первое до получения второго), вы можете сделать это очень легко:

python3:

from itertools import islice

def split_every(n, iterable):
    iterable = iter(iterable)
    yield from iter(lambda: list(islice(iterable, n)), [])

python2:

def split_every(n, iterable):
    iterable = iter(iterable)
    for chunk in iter(lambda: list(islice(iterable, n)), []):
        yield chunk

Answer 5

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

import itertools
def split_groups(iter_in, group_size):
     return ((x for _, x in item) for _, item in itertools.groupby(enumerate(iter_in), key=lambda x: x[0] // group_size))

Answer 6

Я сталкивался с этим, когда тоже пытался разделять партии, но делал это на генераторе из потока, поэтому большинство решений здесь не применимы или не работают в Python 3.

Для тех, кто все еще сталкивается с этим, вот общее решение с использованием itertools:

from itertools import islice, chain

def iter_in_slices(iterator, size=None):
    while True:
        slice_iter = islice(iterator, size)
        # If no first object this is how StopIteration is triggered
        peek = next(slice_iter)
        # Put the first object back and return slice
        yield chain([peek], slice_iter)

Answer 7

Я думаю те вопросы почти равны

Если немного подрезать последнее, я думаю, что хорошим решением для корпуса генератора будет:

from itertools import *
def iter_grouper(n, iterable):
    it = iter(iterable)
    item = itertools.islice(it, n)
    while item:
        yield item
        item = itertools.islice(it, n)

для объекта, который поддерживает фрагменты (списки, строки, кортежи), мы можем сделать:

def slice_grouper(n, sequence):
   return [sequence[i:i+n] for i in range(0, len(sequence), n)]

Теперь нужно просто найти правильный метод:

def grouper(n, iter_or_seq):
    if hasattr(iter_or_seq, "__getslice__"):
        return slice_grouper(n, iter_or_seq)
    elif hasattr(iter_or_seq, "__iter__"):
        return iter_grouper(n, iter_or_seq)

Я думаю, вы могли бы немного отполировать: -)

Answer 8

Это ответ, который работает как для списка, так и для генератора:

from itertools import count, groupby
def split_every(size, iterable):
    c = count()
    for k, g in groupby(iterable, lambda x: next(c)//size):
        yield list(g) # or yield g if you want to output a generator

Answer 9

Почему бы не сделать это так? Выглядит почти как ваша splitEvery_2 функция.

def splitEveryN(n, it):
    return [it[i:i+n] for i in range(0, len(it), n)]

На самом деле это только убирает ненужный интервал шага из среза в вашем решении. :)

Answer 10

Если вы хотите решение, которое

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

это делает трюк:

def one_batch(first_value, iterator, batch_size):
    yield first_value
    for i in xrange(1, batch_size):
        yield iterator.next()

def batch_iterator(iterator, batch_size):
    iterator = iter(iterator)
    while True:
        first_value = iterator.next()  # Peek.
        yield one_batch(first_value, iterator, batch_size)

Он работает, просматривая следующее значение в итераторе и передавая его в качестве первого значения генератору (one_batch()), который выдаст его, вместе с остальной частью пакета.

Шаг просмотра будет повышаться StopIteration точно, когда входной итератор исчерпан, и больше нет пакетов. Поскольку это правильное время для повышения StopIteration в методе batch_iterator(), нет необходимости перехватывать исключение.

Это будет обрабатывать строки из стандартного ввода в пакетном режиме:

for input_batch in batch_iterator(sys.stdin, 10000):
    for line in input_batch:
        process(line)
    finalise()

Я нашел это полезным для обработки большого количества данных и загрузки результатов партиями во внешнее хранилище.