How Can I Efficiently Iterate Over Overlapping Pairs (or Triples) in a Python List?

Iterating Over Overlapping Value Pairs in Python

Iterating over a list in Python while considering both the "current" and "next" elements is a common need. Traditionally, this has been achieved using code like:

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

While effective, this approach is not the most idiomatic or efficient. A more Pythonic solution is to use the pairwise function from the itertools module:

import itertools

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

The pairwise function creates two parallel iterators, a and b, both pointing to the first element of the original iterable. It then advances b by one step, resulting in a pointing to s0 and b pointing to s1. The zip function then pairs up the elements from a and b, giving you overlapping pairs.

For Python 2, you can use itertools.izip instead of zip to obtain a lazy iterator:

import itertools

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

This technique can be extended to produce larger "windows" using the tee function's n parameter. For example, to produce triples, you can use:

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)

Note that using tee can consume memory if one of the iterators advances further than the others. However, in cases where the iterators advance at the same pace, this approach is memory-efficient and idiomatic.

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