["python"]
How can I iterate over overlapping (current, next) pairs of values from a list?

I sometimes need to iterate a list in Python looking at the "current" element and the "next" element. I have, till now, done so with code like: for current, next in zip(the_list, the_list[1:]): # Do something This works and does what I expect, but is there's a more idiomatic or efficient way to do the same thing? Some answers to this problem can simplify by addressing the specific case of taking only two elements at a time. For the general case of N elements at a time, see Rolling or sliding window iterator?.
The documentation for 3.8 provides this recipe: 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 to get the same kind of lazy iterator (zip will instead create a list): 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) How this works: First, two parallel iterators, a and b are created (the tee() call), both pointing to the first element of the original iterable. The second iterator, b is moved 1 step forward (the next(b, None)) call). At this point a points to s0 and b points to s1. Both a and b can traverse the original iterator independently - the izip function takes the two iterators and makes pairs of the returned elements, advancing both iterators at the same pace. Since tee() can take an n parameter (the number of iterators to produce), the same technique can be adapted to produce a larger "window". For example: 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: If one of the iterators produced by tee advances further than the others, then the implementation needs to keep the consumed elements in memory until every iterator has consumed them (it cannot 'rewind' the original iterator). Here it doesn't matter because one iterator is only 1 step ahead of the other, but in general it's easy to use a lot of memory this way.