Itérer un itérateur par morceaux (de n) en Python ?

Question

Pouvez-vous penser à un moyen agréable (peut-être avec itertools) de diviser un itérateur en morceaux de taille donnée ?

Par conséquent, l=[1,2,3,4,5,6,7] con chunks(l,3) devient un itérateur [1,2,3], [4,5,6], [7]

Je peux penser à un petit programme pour le faire mais pas à une manière agréable avec peut-être itertools.

Answer 1

Le site grouper() recette du itertools de la documentation recettes se rapproche de ce que vous voulez :

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

Il remplira le dernier morceau avec une valeur de remplissage, cependant.

Une solution moins générale qui ne fonctionne que sur les séquences mais qui gère le dernier morceau comme souhaité est

[my_list[i:i + chunk_size] for i in range(0, len(my_list), chunk_size)]

Enfin, une solution qui fonctionne sur des itérateurs généraux et se comporte comme souhaité est

def grouper(n, iterable):
    it = iter(iterable)
    while True:
        chunk = tuple(itertools.islice(it, n))
        if not chunk:
            return
        yield chunk

Answer 2

Bien que l'OP demande à la fonction de retourner des morceaux sous forme de liste ou de tuple, si vous avez besoin de retourner des itérateurs, alors Sven Marnach's peut être modifiée :

def grouper_it(n, iterable):
    it = iter(iterable)
    while True:
        chunk_it = itertools.islice(it, n)
        try:
            first_el = next(chunk_it)
        except StopIteration:
            return
        yield itertools.chain((first_el,), chunk_it)

Quelques points de repère : http://pastebin.com/YkKFvm8b

Elle ne sera légèrement plus efficace que si votre fonction itère sur les éléments de chaque chunk.

Answer 3

Cela fonctionnera sur n'importe quel itérable. Elle renvoie le générateur de générateurs (pour une flexibilité totale). Je réalise maintenant que c'est fondamentalement la même chose que la solution de @reclosedevs, mais sans le superflu. Pas besoin de try...except comme le StopIteration se propage vers le haut, ce qui est ce que nous voulons.

Le site next(iterable) est nécessaire pour relever le StopIteration lorsque l'itérable est vide, puisque islice continuera à produire des générateurs vides pour toujours si vous le laissez faire.

C'est mieux parce qu'il ne fait que deux lignes, tout en étant facile à comprendre.

def grouper(iterable, n):
    while True:
        yield itertools.chain((next(iterable),), itertools.islice(iterable, n-1))

Notez que next(iterable) est mis dans un tuple. Dans le cas contraire, si next(iterable) était lui-même itérable, alors itertools.chain l'aplatirait. Merci à Jeremy Brown d'avoir signalé ce problème.

Answer 4

Je travaillais sur quelque chose aujourd'hui et j'ai trouvé ce que je pense être une solution simple. Elle est similaire à jsbueno's réponse, mais je crois que la sienne serait vide group lorsque la longueur de iterable est divisible par n . Ma réponse effectue une simple vérification lorsque le iterable est épuisé.

def chunk(iterable, chunk_size):
    """Generate sequences of `chunk_size` elements from `iterable`."""
    iterable = iter(iterable)
    while True:
        chunk = []
        try:
            for _ in range(chunk_size):
                chunk.append(iterable.next())
            yield chunk
        except StopIteration:
            if chunk:
                yield chunk
            break

Answer 5

En voici un qui renvoie des morceaux paresseux ; utilisez map(list, chunks(...)) si vous voulez des listes.

from itertools import islice, chain
from collections import deque

def chunks(items, n):
    items = iter(items)
    for first in items:
        chunk = chain((first,), islice(items, n-1))
        yield chunk
        deque(chunk, 0)

if __name__ == "__main__":
    for chunk in map(list, chunks(range(10), 3)):
        print chunk

    for i, chunk in enumerate(chunks(range(10), 3)):
        if i % 2 == 1:
            print "chunk #%d: %s" % (i, list(chunk))
        else:
            print "skipping #%d" % i