## Question

Asked By – dcrosta

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?.}

**Now we will see solution for issue: How can I iterate over overlapping (current, next) pairs of values from a list? **

## Answer

Here’s a relevant example from the itertools module docs:

```
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, you need `itertools.izip`

instead of `zip`

:

```
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.

One caveat: the `tee()`

function produces two iterators that can advance independently of each other, but it comes at a cost. If one of the iterators advances further than the other, then `tee()`

needs to keep the consumed elements in memory until the second iterator comsumes them too (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.

And since `tee()`

can take an `n`

parameter, this can also be used for more than two parallel iterators:

```
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)
```

This question is answered By – Rafał Dowgird

**This answer is collected from stackoverflow and reviewed by FixPython community admins, is licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 **