podziel generator / iterowalny co N elementów w Pythonie (podziel)

Oto szybka wersja jednowarstwowa. Jak u Haskella, jest leniwy.

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

Wymaga to użycia iter przed wywołaniem split_every.

Przykład:

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

Chociaż nie jednolinijkowy, poniższa wersja nie wymaga, aby zadzwonić iter, co może być częstą pułapką.

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

(podziękowania dla @ eli-korvigo za ulepszenia.)

Bazując na zaakceptowanej odpowiedzi i stosując mniej znane użycie iter (że po przejściu drugiego arg, wywołuje pierwszą, dopóki nie otrzyma drugiej), możesz to zrobić naprawdę łatwo:

Python3:

from itertools import islice

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

Pyton2:

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

more_itertools ma chunked Funkcja:

import more_itertools as mit


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

Jednoliniowe, inlineable rozwiązanie do tego (obsługuje v2/v3, Iteratory, wykorzystuje standardową bibliotekę i rozumienie pojedynczego generatora):

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

Myślę, że Ci pytania {[5] } są prawie równe

Zmieniając trochę, aby przyciąć ostatni, myślę, że dobrym rozwiązaniem dla przypadku generatora byłoby:

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)

Dla obiektu, który obsługuje plasterki (listy, ciągi znaków, krotki), możemy wykonać:

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

Teraz to tylko kwestia podania poprawnej metody:

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)

Myślę, że mógłbyś to trochę Dopracować: -)

Dlaczego nie zrobić tego w ten sposób? Wygląda prawie jak twoja splitEvery_2 funkcja.

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

W rzeczywistości usuwa tylko niepotrzebny odstęp kroków z plasterka w Twoim roztworze. :)

Jest to odpowiedź, która działa zarówno dla listy, jak i generatora:

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

Natknąłem się na to, ponieważ próbuję też pociąć partie, ale robię to na generatorze ze strumienia, więc większość rozwiązań tutaj nie ma zastosowania, lub nie działa w Pythonie 3.

Dla ludzi wciąż natykających się na to, oto ogólne rozwiązanie przy użyciu 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)

Oto jak radzisz sobie z list vs iterator:

def isList(L): # Implement it somehow - returns True or false
...
return (list, lambda x:x)[int(islist(L))](result)

def chunks(iterable,n):
    """assumes n is an integer>0
    """
    iterable=iter(iterable)
    while True:
        result=[]
        for i in range(n):
            try:
                a=next(iterable)
            except StopIteration:
                break
            else:
                result.append(a)
        if result:
            yield result
        else:
            break

g1=(i*i for i in range(10))
g2=chunks(g1,3)
print g2
'<generator object chunks at 0x0337B9B8>'
print list(g2)
'[[0, 1, 4], [9, 16, 25], [36, 49, 64], [81]]'

This will do the trick

from itertools import izip_longest
izip_longest(it[::2], it[1::2])

Gdzie * to * jest jakieś iterable

Przykład:

izip_longest('abcdef'[::2], 'abcdef'[1::2]) -> ('a', 'b'), ('c', 'd'), ('e', 'f')

Let ' s break this down

'abcdef'[::2] -> 'ace'
'abcdef'[1::2] -> 'bdf'

Jak widać, ostatnia liczba w plasterku określa interwał, który będzie używany do podnoszenia przedmiotów. Więcej o używaniu plastrów rozszerzonych przeczytasz tutaj .

Funkcja zip pobiera pierwszą pozycję z pierwszej iterable i łączy ją z pierwszą pozycją z drugą iterable. Funkcja zip następnie robi to samo dla drugiej i trzeciej pozycji, dopóki jedna z iterabli nie skończy się z wartościami.

Rezultatem jest iterator. Jeśli chcesz mieć listę, użyj funkcji list () na wyniku.

Jeśli chcesz rozwiązania, które

• używa tylko generatorów (bez list pośrednich i krotek),
• działa przez bardzo długie (lub nieskończone) Iteratory,
• działa na bardzo duże partie,

To robi sztuczkę:

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)

Działa poprzez Podglądanie następnej wartości w iteratorze i przekazanie jej jako pierwszej wartości generatorowi (one_batch()), który uzyska ją wraz z resztą partii.

Krok peek podniesie StopIteration dokładnie wtedy, gdy wejście iterator jest wyczerpany i nie ma więcej partii. Ponieważ jest to właściwy czas na wywołanie StopIteration w metodzie batch_iterator(), nie ma potrzeby przechwytywania wyjątku.

To będzie przetwarzać linie ze standardowego wejścia w partiach:

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

Uznałem to za przydatne do przetwarzania wielu danych i przesyłania wyników partiami do zewnętrznego sklepu.