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

Une mise en œuvre succincte est :

chunker = lambda iterable, n: (ifilterfalse(lambda x: x == (), chunk) for chunk in (izip_longest(*[iter(iterable)]*n, fillvalue=())))

Cela fonctionne parce que [iter(iterable)]*n est une liste contenant le même itérateur n fois ; le fait de passer dessus prend un élément de chaque itérateur dans la liste, qui est le même itérateur avec pour résultat que chaque élément de zip contient un groupe de n articles.

izip_longest est nécessaire pour consommer entièrement l'itérable sous-jacent, plutôt que d'arrêter l'itération lorsque le premier itérateur épuisé est atteint, ce qui supprime tout reste de l'itérable. iterable . Il est donc nécessaire de filtrer la valeur de remplissage. Une implémentation un peu plus robuste serait donc :

def chunker(iterable, n):
    class Filler(object): pass
    return (ifilterfalse(lambda x: x is Filler, chunk) for chunk in (izip_longest(*[iter(iterable)]*n, fillvalue=Filler)))

Cela garantit que la valeur de remplissage n'est jamais un élément dans l'itérable sous-jacent. En utilisant la définition ci-dessus :

iterable = range(1,11)

map(tuple,chunker(iterable, 3))
[(1, 2, 3), (4, 5, 6), (7, 8, 9), (10,)]

map(tuple,chunker(iterable, 2))
[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]

map(tuple,chunker(iterable, 4))
[(1, 2, 3, 4), (5, 6, 7, 8), (9, 10)]

---

Cette implémentation fait presque ce que vous voulez, mais elle a des problèmes :

def chunks(it, step):
  start = 0
  while True:
    end = start+step
    yield islice(it, start, end)
    start = end

(La différence est que, parce que islice ne lève pas StopIteration ou quoi que ce soit d'autre sur les appels qui vont au-delà de la fin de l'option it ce rendement sera éternel ; il y a aussi la question un peu délicate que la islice les résultats doivent être consommés avant que ce générateur soit itéré).

Pour générer la fenêtre mobile de manière fonctionnelle :

izip(count(0, step), count(step, step))

Donc ça devient :

(it[start:end] for (start,end) in izip(count(0, step), count(step, step)))

Mais, cela crée toujours un itérateur infini. Donc, vous avez besoin de takewhile (ou peut-être quelque chose d'autre serait mieux) pour le limiter :

chunk = lambda it, step: takewhile((lambda x: len(x) > 0), (it[start:end] for (start,end) in izip(count(0, step), count(step, step))))

g = chunk(range(1,11), 3)

tuple(g)
([1, 2, 3], [4, 5, 6], [7, 8, 9], [10])

---

Answer 2

"Le plus simple est mieux que le plus complexe" - un générateur simple de quelques lignes peut faire l'affaire. Il suffit de le placer dans un module utilitaire ou autre :

def grouper (iterable, n):
    iterable = iter(iterable)
    count = 0
    group = []
    while True:
        try:
            group.append(next(iterable))
            count += 1
            if count % n == 0:
                yield group
                group = []
        except StopIteration:
            yield group
            break

Answer 3

J'ai oublié où j'ai trouvé l'inspiration pour ça. Je l'ai un peu modifié pour qu'il fonctionne avec les GUID des MSI dans le registre Windows :

def nslice(s, n, truncate=False, reverse=False):
    """Splits s into n-sized chunks, optionally reversing the chunks."""
    assert n > 0
    while len(s) >= n:
        if reverse: yield s[:n][::-1]
        else: yield s[:n]
        s = s[n:]
    if len(s) and not truncate:
        yield s

reverse ne s'applique pas à votre question, mais c'est quelque chose que j'utilise beaucoup avec cette fonction.

>>> [i for i in nslice([1,2,3,4,5,6,7], 3)]
[[1, 2, 3], [4, 5, 6], [7]]
>>> [i for i in nslice([1,2,3,4,5,6,7], 3, truncate=True)]
[[1, 2, 3], [4, 5, 6]]
>>> [i for i in nslice([1,2,3,4,5,6,7], 3, truncate=True, reverse=True)]
[[3, 2, 1], [6, 5, 4]]

Answer 4

Voilà.

def chunksiter(l, chunks):
    i,j,n = 0,0,0
    rl = []
    while n < len(l)/chunks:        
        rl.append(l[i:j+chunks])        
        i+=chunks
        j+=j+chunks        
        n+=1
    return iter(rl)

def chunksiter2(l, chunks):
    i,j,n = 0,0,0
    while n < len(l)/chunks:        
        yield l[i:j+chunks]
        i+=chunks
        j+=j+chunks        
        n+=1

Exemples :

for l in chunksiter([1,2,3,4,5,6,7,8],3):
    print(l)

[1, 2, 3]
[4, 5, 6]
[7, 8]

for l in chunksiter2([1,2,3,4,5,6,7,8],3):
    print(l)

[1, 2, 3]
[4, 5, 6]
[7, 8]

for l in chunksiter2([1,2,3,4,5,6,7,8],5):
    print(l)

[1, 2, 3, 4, 5]
[6, 7, 8]