How do I make a `for`

loop or a list comprehension so that every iteration gives me two elements?

```
l = [1,2,3,4,5,6]
for i,k in ???:
print str(i), '+', str(k), '=', str(i+k)
```

Output:

```
1+2=3
3+4=7
5+6=11
```

You need a ** pairwise()** (or

**) implementation.**

`grouped()`

For Python 2:

```
from itertools import izip
def pairwise(iterable):
"s -> (s0, s1), (s2, s3), (s4, s5), ..."
a = iter(iterable)
return izip(a, a)
for x, y in pairwise(l):
print "%d + %d = %d" % (x, y, x + y)
```

Or, more generally:

```
from itertools import izip
def grouped(iterable, n):
"s -> (s0,s1,s2,...sn-1), (sn,sn+1,sn+2,...s2n-1), (s2n,s2n+1,s2n+2,...s3n-1), ..."
return izip(*[iter(iterable)]*n)
for x, y in grouped(l, 2):
print "%d + %d = %d" % (x, y, x + y)
```

In Python 3, you can replace `izip`

with the built-in `zip()`

function, and drop the `import`

.

All credit to martineau for his answer to my question, I have found this to be very efficient as it only iterates once over the list and does not create any unnecessary lists in the process.

**N.B**: This should not be confused with the ** pairwise** recipe in Python’s own

**documentation, which yields**

`itertools`

`s -> (s0, s1), (s1, s2), (s2, s3), ...`

, as pointed out by @lazyr in the comments.Well you need tuple of 2 elements, so

```
data = [1,2,3,4,5,6]
for i,k in zip(data[0::2], data[1::2]):
print str(i), '+', str(k), '=', str(i+k)
```

Where:

`data[0::2]`

means create subset collection of elements that`(index % 2 == 0)`

`zip(x,y)`

creates a tuple collection from x and y collections same index elements.

```
>>> l = [1,2,3,4,5,6]
>>> zip(l,l[1:])
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
>>> zip(l,l[1:])[::2]
[(1, 2), (3, 4), (5, 6)]
>>> [a+b for a,b in zip(l,l[1:])[::2]]
[3, 7, 11]
>>> ["%d + %d = %d" % (a,b,a+b) for a,b in zip(l,l[1:])[::2]]
['1 + 2 = 3', '3 + 4 = 7', '5 + 6 = 11']
```

A simple solution.

l = [1, 2, 3, 4, 5, 6] for i in range(0, len(l), 2): print str(l[i]), '+', str(l[i + 1]), '=', str(l[i] + l[i + 1])

While all the answers using `zip`

are correct, I find that implementing the functionality yourself leads to more readable code:

```
def pairwise(it):
it = iter(it)
while True:
yield next(it), next(it)
```

The `it = iter(it)`

part ensures that `it`

is actually an iterator, not just an iterable. If `it`

already is an iterator, this line is a no-op.

Usage:

```
for a, b in pairwise([0, 1, 2, 3, 4, 5]):
print(a + b)
```

```
for (i, k) in zip(l[::2], l[1::2]):
print i, "+", k, "=", i+k
```

`zip(*iterable)`

returns a tuple with the next element of each iterable.

`l[::2]`

returns the 1st, the 3rd, the 5th, etc. element of the list: the first colon indicates that the slice starts at the beginning because there’s no number behind it, the second colon is only needed if you want a ‘step in the slice’ (in this case 2).

`l[1::2]`

does the same thing but starts in the second element of the lists so it returns the 2nd, the 4th, 6th, etc. element of the **original** list.

Apologies for being late.I hope this will be even more elegant way of doing it.

```
a = [1,2,3,4,5,6]
zip(a[::2], a[1::2])
[(1, 2), (3, 4), (5, 6)]
```

For anyone it might help, here is a solution to a similar problem but with overlapping pairs (instead of mutually exclusive pairs).

From the Python itertools documentation:

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

Or, more generally:

```
from itertools import izip
def groupwise(iterable, n=2):
"s -> (s0,s1,...,sn-1), (s1,s2,...,sn), (s2,s3,...,sn+1), ..."
t = tee(iterable, n)
for i in range(1, n):
for j in range(0, i):
next(t[i], None)
return izip(*t)
```

Closest to the code you wrote:

```
l = [1,2,3,4,5,6]
for i,k in zip(l[::2], l[1::2]):
print(str(i), '+', str(k), '=', str(i+k))
```

Output:

```
1+2=3
3+4=7
5+6=11
```

Thought that this is a good place to share my generalization of this for n>2, which is just a sliding window over an iterable:

```
def sliding_window(iterable, n):
its = [ itertools.islice(iter, i, None)
for i, iter
in enumerate(itertools.tee(iterable, n)) ]
return itertools.izip(*its)
```

Here we can have `alt_elem`

method which can fit in your for loop.

```
def alt_elem(list, index=2):
for i, elem in enumerate(list, start=1):
if not i % index:
yield tuple(list[i-index:i])
a = range(10)
for index in [2, 3, 4]:
print("With index: {0}".format(index))
for i in alt_elem(a, index):
print(i)
```

Output:

```
With index: 2
(0, 1)
(2, 3)
(4, 5)
(6, 7)
(8, 9)
With index: 3
(0, 1, 2)
(3, 4, 5)
(6, 7, 8)
With index: 4
(0, 1, 2, 3)
(4, 5, 6, 7)
```

Note: Above solution might not be efficient considering operations performed in func.

The title of this question is misleading, you seem to be looking for consecutive pairs, but if you want to iterate over the set of all possible pairs than this will work :

```
for i,v in enumerate(items[:-1]):
for u in items[i+1:]:
```

you can use more_itertools package.

```
import more_itertools
lst = range(1, 7)
for i, j in more_itertools.chunked(lst, 2):
print(f'{i} + {j} = {i+j}')
```

Tags: laravellist