myList = [1,2,3,4,5,6]

I'd like to be able to pull out two items at a time - simple examples would
be:
Create this output:
1 2
3 4
5 6

Create this list:
[(1,2), (3,4), (5,6)]

I want the following syntax to work, but sadly it does not:
for x,y in myList:
  print x, y

I can do this with a simple foreach statement in tcl, and if it's easy in
tcl it's probably not too hard in Python.

from itertools import izip, islice

data = [1,2,3,4,5,6,7]

for x1, x2 in (data[i:i+2] for i in xrange(0, len(data)/2*2, 2)):
    print x1, x2

for x1, x2 in zip(data[::2], data[1::2]):
    print x1, x2

for x1, x2 in izip(data[::2], data[1::2]):
    print x1, x2

for x1, x2 in izip(islice(data,0,None,2), islice(data,1,None,2)):
    print x1, x2

    >> I'm looking for a way to iterate through a list, two (or more) items
    >> at a time.  Basically...
    >>
    >> myList = [1,2,3,4,5,6]
    >>
    >> I'd like to be able to pull out two items at a time...

    Dan> def pair_list(list_):
    Dan>     return [list_[i:i+2] for i in xrange(0, len(list_), 2)]

Here's another way (seems a bit clearer to me, but each person has their own
way of seeing things):

    >>> import string
    >>> string.letters
    'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
    >>> zip(string.letters[::2], string.letters[1::2])
    [('a', 'b'), ('c', 'd'), ..., ('W', 'X'), ('Y', 'Z')]

It extends readily to longer groupings:

    >>> zip(string.letters[::3], string.letters[1::3], string.letters[2::3])
    [('a', 'b', 'c'), ('d', 'e', 'f'), ('g', 'h', 'i'), ...

Obviously, if your lists are long, you can substitute itertools.izip for
zip.  There's probably some easy way to achieve the same result with
itertools.groupby, but I'm out of my experience there...

b=iter(a)
for x,y in ((item, b.next()) for item in b):
    print x,y

Note that they don't behave the same at the corner cases (empty list,
single item, odd length...)

--
Gabriel Genellina
Softlab SRL

def chunk( seq, size, pad=None ):
    '''
    Slice a list into consecutive disjoint 'chunks' of
    length equal to size. The last chunk is padded if necessary.

    >>> list(chunk(range(1,10),3))
    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    >>> list(chunk(range(1,9),3))
    [[1, 2, 3], [4, 5, 6], [7, 8, None]]
    >>> list(chunk(range(1,8),3))
    [[1, 2, 3], [4, 5, 6], [7, None, None]]
    >>> list(chunk(range(1,10),1))
    [[1], [2], [3], [4], [5], [6], [7], [8], [9]]
    >>> list(chunk(range(1,10),9))
    [[1, 2, 3, 4, 5, 6, 7, 8, 9]]
    >>> for X in chunk([],3): print X
    >>>
    '''
    n = len(seq)
    mod = n % size
    for i in xrange(0, n-mod, size):
        yield seq[i:i+size]
    if mod:
        padding = [pad] * (size-mod)
        yield seq[-mod:] + padding

------------------------------------------------------------------

a = [1,2,3,4,5,6,7]
b = iter(a)
for x in b:
    try:
         y=b.next()
    except StopIteration:
         y=None
    print x,y

Substitute in whatever for y=None that you like.

The following might be more complex than necessary but it solves the
problem, and like groupn()
it works on infinite lists.

from itertools import groupby, imap
def chunk(it, n=0):
    if n == 0:
        return iter([it])
    grouped = groupby(enumerate(it), lambda x: int(x[0]/n))
    counted = imap(lambda x:x[1], grouped)
    return imap(lambda x: imap(lambda y: y[1], x), counted)

Note the chunks are iterators, not tuples as in groupn():

from itertools import groupby

def chunk(it, n=0):
    if n == 0:
        return iter([it])
    def groupfun((x,y)):
        return int(x/n)
    grouped = groupby(enumerate(it), groupfun)
    counted = (y for (x,y) in grouped)
    return ((z for (y,z) in x) for x in counted)

In [51]: chunkgen = chunk(range(10), 3)

In [52]: [list(x) for x in chunkgen]
Out[52]: [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]

But, as you pointed out --

In [57]: chunkgen = chunk(range(10), 3)

In [58]: chunks = list(chunkgen)

In [59]: [list(x) for x in chunks]
Out[59]: [[], [], [], [9]]

So apparently when we list(chunkgen), we are exhausting the generators
that are its members. And if we do it again, we get rid of the [9] --

In [60]: [list(x) for x in chunks]
Out[60]: [[], [], [], []]

I'll admit that chunk() is needlessly tricky for most purposes. I wrote
it to accept a really lengthy, possibly unbounded, iterator and write
out 10,000-line files from it, and also to play with Python's new
functional capabilities.