To iterate over an iterable in fixed-size batches or chunks.

Express the intention to process data in batches of a given size.

Processing data in batches (e.g., reading files in chunks) Grouping items for batch processing When you need to iterate over an iterable in fixed-size groups

Data processing pipelines Batch processing of files or records Grouping items for batch operations Streaming data processing

for <variable> in zip(*[iter(<iterable>)]*<chunk_size>):

for <variable> in zip(*[iter(<iterable>)]*<n>):

{"variable":"chunk","iterable":"data","chunk_size":"n"}

• data n chunk iterable batch group

• variable name can be any identifier (e.g.
• batch
• group) chunk size can be any positive integer iterable can be any iterable (list
• tuple
• generator)

Assuming leftover items are yielded (they are dropped if length not a multiple of n) Using a list instead of an iterator causing all iterators to be the same object Misunderstanding that * creates references to the same iterator, not copies

itertools.islice in a loop for slicing more-itertools.chunked list comprehension with step numpy.array_split

Confusing * [iterator]*n with [iterator]*n (creates list of same iterator) Confusing with map(zip, ...) which behaves differently Assuming zip stops at the longest input (it stops at the shortest)

• iteration idioms / batching patterns

The idiom creates n references to the same iterator; zip draws one item from each per iteration, effectively grouping the iterable into n-sized tuples. If the iterable length is not a multiple of n, the final incomplete group is discarded.

Signals the programmer's intent to process data in fixed-size batches, emphasizing memory efficiency and chunked processing.

Think 'zip star iterator times n' to remember the chunking idiom.

Known as the 'grouper' recipe from the itertools documentation.

Consider using itertools.islice loops or more-itertools.chunked for handling leftovers or more flexible chunking.