Python Tutorial: Itertools Module - Iterator Functions for Efficient Looping

Itertools is a set of Python standard-library tools built for working with iterators—sequential data you can consume one item at a time without loading everything into memory. The core payoff is efficiency: many itertools helpers can generate values indefinitely (or until a clear stopping condition), yet still let code pull just the next item when needed. That combination—lazy evaluation plus iterator-friendly composition—shows up repeatedly across the module’s functions.

The tutorial starts with itertools.count, which returns an infinite counter iterator. By default it begins at 0 and increments by 1 forever, making it easy to accidentally create an infinite loop if values are consumed without a stop condition. The practical workaround is to fetch items incrementally using next(), which retrieves one value at a time from the iterator. This matters because it enables patterns like pairing unknown-length data with generated indices. Using zip with itertools.count, the code pairs each data element with a running day index (0, 1, 2, …) and stops automatically when the finite data iterable ends. The counter is also configurable: count(start=5) begins at 5, step=5 jumps by fives, and a negative or fractional step supports counting backward or by decimals.

Next comes zip_longest, which differs from built-in zip by continuing until the longest iterable is exhausted. When the shorter iterable runs out, zip_longest fills missing positions with a default placeholder (None unless specified). This is especially useful when one iterable is finite and another is longer or conceptually unbounded—like pairing a finite list with a generated sequence—without forcing everything into memory.

The tutorial then moves through three infinite iterator generators: cycle, which repeats an iterable’s values in order forever; repeat, which yields the same value indefinitely (or a fixed number of times via times); and repeat’s common role as a constant stream feeding functions like map. It also introduces itertools.starmap, a variant of map that expects arguments already grouped into tuples, letting a function receive multiple parameters per iteration.

For terminating combinatorics, itertools.combinations and itertools.permutations generate groupings from an iterable where order does or doesn’t matter, respectively. Neither repeats elements from the original input, so a separate tool is needed when repeats are allowed. itertools.product provides Cartesian-product-style combinations with repetition (controlled by repeat), which can model things like all possible 4-digit codes from a set of digits. For combinations with repetition but without order, itertools.combinations_with_replacement is the matching counterpart.

Finally, the tutorial covers practical data-manipulation helpers: chain to concatenate multiple iterables without building a combined list; islice to slice iterators like list slicing while keeping memory usage low; compress to filter items based on a parallel boolean selector iterable; dropwhile and takewhile to skip or collect items until a predicate flips; accumulate to produce running totals (or running products via operator.mul); and groupby to group items by a key function. groupby requires the input to be sorted by the grouping key, otherwise items with the same key may end up in separate groups. The module closes with tee (itertools.tee) for replicating an iterator into multiple independent iterators, with the important warning that the original iterator should not be used after teeing to avoid exhaustion side effects.