Wie kann ich eine Liste in gleich große Stücke aufteilen?

Question

Wie kann ich eine Liste beliebiger Länge in gleich große Stücke aufteilen?

---

_{Siehe auch: <a href="https://stackoverflow.com/q/434287">Wie man über eine Liste in Stücken iteriert</a>.<br>Um Zeichenfolgen zu segmentieren, siehe <a href="https://stackoverflow.com/questions/9475241">Zeichenfolge alle n Zeichen aufteilen?</a>.}

Answer 1

Hier ist ein Generator, der gleich große Abschnitte generiert:

def chunks(lst, n):
    """Gibt aufeinanderfolgende Abschnitte der Größe n von lst zurück."""
    for i in range(0, len(lst), n):
        yield lst[i:i + n]

import pprint
pprint.pprint(list(chunks(range(10, 75), 10)))
[[10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
 [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
 [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
 [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
 [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
 [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
 [70, 71, 72, 73, 74]]

Für Python 2, Verwendung von xrange anstelle von range:

def chunks(lst, n):
    """Gibt aufeinanderfolgende Abschnitte der Größe n von lst zurück."""
    for i in xrange(0, len(lst), n):
        yield lst[i:i + n]

---

Im Folgenden finden Sie einen List Comprehension One-Liner. Die oben genannte Methode ist jedoch vorzuziehen, da die Verwendung benannter Funktionen den Code leichter verständlich macht. Für Python 3:

[lst[i:i + n] for i in range(0, len(lst), n)]

Für Python 2:

[lst[i:i + n] for i in xrange(0, len(lst), n)]

Answer 2

Etwas super Einfaches:

def chunks(xs, n):
    n = max(1, n)
    return (xs[i:i+n] for i in range(0, len(xs), n))

Für Python 2, verwenden Sie xrange() anstelle von range().

Answer 3

Ich weiß, dass dies etwas alt ist, aber bisher hat noch niemand numpy.array_split erwähnt:

import numpy as np

lst = range(50)
np.array_split(lst, 5)

Ergebnis:

[array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
 array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19]),
 array([20, 21, 22, 23, 24, 25, 26, 27, 28, 29]),
 array([30, 31, 32, 33, 34, 35, 36, 37, 38, 39]),
 array([40, 41, 42, 43, 44, 45, 46, 47, 48, 49])]

Answer 4

Direkt aus der (alten) Python-Dokumentation (Rezepte für itertools):

from itertools import izip, chain, repeat

def grouper(n, iterable, padvalue=None):
    "grouper(3, 'abcdefg', 'x') --> ('a','b','c'), ('d','e','f'), ('g','x','x')"
    return izip(*[chain(iterable, repeat(padvalue, n-1))]*n)

Die aktuelle Version, wie von J.F.Sebastian vorgeschlagen:

#from itertools import izip_longest as zip_longest # für Python 2.x
from itertools import zip_longest # für Python 3.x
#from six.moves import zip_longest # für beide (verwendet die six-Kompatibilitätsbibliothek)

def grouper(n, iterable, padvalue=None):
    "grouper(3, 'abcdefg', 'x') --> ('a','b','c'), ('d','e','f'), ('g','x','x')"
    return zip_longest(*[iter(iterable)]*n, fillvalue=padvalue)

Ich nehme an, Guidos Zeitmaschine funktioniert — funktionierte — wird funktionieren — wird funktioniert haben — funktionierte wieder.

Diese Lösungen funktionieren, weil [iter(iterable)]*n (oder das Äquivalent in der früheren Version) einen ein Iterator erzeugt, der n Mal in der Liste wiederholt wird. izip_longest führt dann effektiv eine Rundum-Robin von "jedem" Iterator durch; da dies derselbe Iterator ist, wird er bei jedem Aufruf vorangebracht, was dazu führt, dass jedes solche Zip-Roundrobin ein Tupel von n Elementen erzeugt.

Python 3.12

itertools.batched ist verfügbar.

Answer 5

Ich bin überrascht, dass niemand daran gedacht hat, die iter Zwei-Argument-Form zu verwenden:

from itertools import islice

def chunk(it, size):
    it = iter(it)
    return iter(lambda: tuple(islice(it, size)), ())

Demo:

>>> list(chunk(range(14), 3))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13)]

Dies funktioniert mit jedem Iterable und gibt die Ausgabe träge aus. Es gibt Tupel zurück anstatt Iteratoren, aber ich denke, es hat dennoch eine gewisse Eleganz. Es füllt auch nicht auf; wenn Sie eine Füllung möchten, reicht eine einfache Variation des obigen aus:

from itertools import islice, chain, repeat

def chunk_pad(it, size, padval=None):
    it = chain(iter(it), repeat(padval))
    return iter(lambda: tuple(islice(it, size)), (padval,) * size)

Demo:

>>> list(chunk_pad(range(14), 3))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, None)]
>>> list(chunk_pad(range(14), 3, 'a'))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, 'a')]

Wie die auf izip_longest basierenden Lösungen füllt das obige immer. Soweit ich weiß, gibt es kein ein- oder zwei-Zeilen-Itertools-Rezept für eine Funktion, die optional füllt. Durch die Kombination der obigen beiden Ansätze kommt diese ziemlich nah dran:

_no_padding = object()

def chunk(it, size, padval=_no_padding):
    if padval == _no_padding:
        it = iter(it)
        sentinel = ()
    else:
        it = chain(iter(it), repeat(padval))
        sentinel = (padval,) * size
    return iter(lambda: tuple(islice(it, size)), sentinel)

Demo:

>>> list(chunk(range(14), 3))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13)]
>>> list(chunk(range(14), 3, None))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, None)]
>>> list(chunk(range(14), 3, 'a'))
[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, 'a')]

Ich glaube, dass dies der kürzeste vorgeschlagene Chunker ist, der optionale Füllung ermöglicht.

Wie Tomasz Gandor beobachtet hat, werden die beiden Padding-Chunker unerwartet stoppen, wenn sie auf eine lange Sequenz von Füllwerten treffen. Hier ist eine letzte Variation, die dieses Problem auf vernünftige Weise umgeht:

_no_padding = object()
def chunk(it, size, padval=_no_padding):
    it = iter(it)
    chunker = iter(lambda: tuple(islice(it, size)), ())
    if padval == _no_padding:
        yield from chunker
    else:
        for ch in chunker:
            yield ch if len(ch) == size else ch + (padval,) * (size - len(ch))

Demo:

>>> list(chunk([1, 2, (), (), 5], 2))
[(1, 2), ((), ()), (5,)]
>>> list(chunk([1, 2, None, None, 5], 2, None))
[(1, 2), (None, None), (5, None)]