Pythonic approach to zipping items in a list

Question

Say I want to iterate through a list. Each time I iterate I want to compute something using both the current and next terms. I could do something like

mylist = [1, 2, 3, 4]
for i in range(len(mylist)):
    try:
        compute(mylist[i], mylist[i+1])
    except IndexError:
        compute(mylist[i])

I could also do

mylist = [1, 2, 3, 4]
for num in mylist:
    try:
        compute(num, mylist[mylist.index(num)+1])
    except IndexError:
        compute(num)

Neither of these seems particularly good. Is there a more pythonic approach to doing this?

You can try using the `pairwise` recipe from the [itertools documentation](http://docs.python.org/2/library/itertools.html#recipes). — Wessie, Nov 27 '12 at 00:25
@Wessie: That's exactly what he should do... You should make that into an answer. — Joel Cornett, Nov 27 '12 at 00:26
Why do you call `compute` with only one argument on the last iteration? — Eric, Nov 27 '12 at 00:36

score 1 · Answer 1 · answered Nov 27 '12 at 00:31

You can use built-in function enumerate:

mylist = [1, 2, 3, 4]
for i, num in enumerate(mylist):
    try:
        compute(num, mylist[i+1])
    except IndexError:
        compute(num)

But choosing between your two implementations is rather easy - second is not only far slower (O(n^2)), but also has weird semantics for repeating elements.

score 1 · Accepted Answer · answered Nov 27 '12 at 00:36

There are three ways to do that (although I would probably prefer first one, unless your conditions are different):

Use itertools.izip() - it will be efficient and Pythonic:

for item1, item2 in itertools.izip(my_list, my_list[1:]):
    # do something...

Use enumerate():

for index, item in enumerate(my_list):
    # do something...

Store previous row in a variable (the example assumes there is no None in your list):

previous = None
for item in my_list:
    if previous is None:
        previous = item
        continue
    # do something...

+1 Option 1 is probably the best imho. – arshajii Nov 27 '12 at 00:37 — arshajii, Nov 27 '12 at 00:37

cmh · Answer 3 · 2012-11-27T00:38:31.243

0

A functional style that doesn't use itertools might look something like:

for t in zip(mylist, mylist[1:]):
    compute(*t)

If performance is tantamount you can prevent the creation of the intermeida list during zip by using itertools.izip.

To cover the special case as shown in the question, use:

for t in zip(mylist, mylist[1:]) + [(mylist[-1],)]
    compute(*t)

edited Nov 27 '12 at 00:38

answered Nov 27 '12 at 00:27

cmh

10,612
5
30
40

Why is this inefficient? – Bruno Nov 27 '12 at 00:33
It isn't actually that bad, but zip creates an intermediate list that is unnecessary. Using [itertools.izip](http://docs.python.org/2/library/itertools.html#itertools.izip), is preferable. – cmh Nov 27 '12 at 00:37

score 0 · Answer 4 · answered Nov 27 '12 at 00:35

0

To cover your special case at the end, you need:

for t in zip(mylist, mylist[1:]) + [(mylist[-1],)]
    compute(*t)

answered Nov 27 '12 at 00:35

Eric

95,302
53
242
374

Pythonic approach to zipping items in a list

4 Answers4