How to Efficiently Iterate Over Overlapping Pairs (and Triples) in Python Lists?

How to Iterate Overlapping Value Pairs from a List

When working with lists in Python, it's often necessary to iterate over values in pairs. A common approach is to use a construct such as:

for current, next in zip(the_list, the_list[1:]):
    # Do something

While this code works, there is a more idiomatic and efficient solution using the pairwise function from the itertools module. Here's a revised Python 3.8 implementation:

import itertools

def pairwise(iterable):
    "s -> (s0, s1), (s1, s2), (s2, s3), ..."
    a, b = itertools.tee(iterable)
    next(b, None)
    return zip(a, b)

For Python 2, use itertools.izip instead of zip (since zip in Python 2 creates a list instead of a lazy iterator).

The pairwise function works by creating two parallel iterators, a and b, pointing to the same first element. b is then advanced one step ahead using next. The izip function combines the elements from the two iterators to form overlapping pairs.

This approach can also be generalized to handle larger "windows" of values. For example, to iterate over triples of values, use the following function:

def threes(iterator):
    "s -> (s0, s1, s2), (s1, s2, s3), (s2, s3, 4), ..."
    a, b, c = itertools.tee(iterator, 3)
    next(b, None)
    next(c, None)
    next(c, None)
    return zip(a, b, c)

Caveat: It's important to note that if one of the iterators advances further than the others due to the use of next, the implementation will hold the consumed elements in memory until all iterators have consumed them.

The above is the detailed content of How to Efficiently Iterate Over Overlapping Pairs (and Triples) in Python Lists?. For more information, please follow other related articles on the PHP Chinese website!