iterator question

[Neal Becker]

Any suggestions for transforming the sequence:

[1, 2, 3, 4...]
Where 1,2,3.. are it the ith item in an arbitrary sequence

into a succession of tuples:

[(1, 2), (3, 4)...]

In other words, given a seq and an integer that specifies the size of tuple
to return, then for example:

seq = [a,b,c,d,e,f]
for e in transform (seq, 2):
print e

would return
(a,b)
(c,d)
(e,f)

[johnzenger]

def transform(seq, size):
i = 0
while i < len(seq):
yield tuple(seq[i:i+size])
i += size

Neal Becker wrote:

Any suggestions for transforming the sequence:

[1, 2, 3, 4...]
Where 1,2,3.. are it the ith item in an arbitrary sequence

into a succession of tuples:

[(1, 2), (3, 4)...]

In other words, given a seq and an integer that specifies the size of tuple
to return, then for example:

seq = [a,b,c,d,e,f]
for e in transform (seq, 2):
print e

would return
(a,b)
(c,d)
(e,f)

[John Hicken]

Neal Becker wrote:

Any suggestions for transforming the sequence:

[1, 2, 3, 4...]
Where 1,2,3.. are it the ith item in an arbitrary sequence

into a succession of tuples:

[(1, 2), (3, 4)...]

In other words, given a seq and an integer that specifies the size of tuple
to return, then for example:

seq = [a,b,c,d,e,f]
for e in transform (seq, 2):
print e

would return
(a,b)
(c,d)
(e,f)

How about this:

def transform(seq,n):
for k in xrange(0,len(seq),n):
yield tuple(seq[k:k+n])

[George Sakkis]

jo********@gmail.com wrote:

def transform(seq, size):
i = 0
while i < len(seq):
yield tuple(seq[i:i+size])
i += size

Or for arbitrary iterables, not just sequences:

from itertools import islice
def transform(iterable, size):
it = iter(iterable)
while True:
window = tuple(islice(it,size))
if not window:
break
yield window

George

[Neil Cerutti]

On 2006-09-26, Neal Becker <nd*******@gmail.comwrote:

Any suggestions for transforming the sequence:

[1, 2, 3, 4...]
Where 1,2,3.. are it the ith item in an arbitrary sequence

into a succession of tuples:

[(1, 2), (3, 4)...]

In other words, given a seq and an integer that specifies the
size of tuple to return, then for example:

It turns out there's a itertools recipe to do this; the last one
in the itertools recipe book:

def grouper(n, iterable, padvalue=None):
"""
grouper(3, 'abcdefg', 'x') --('a','b','c'), ('d','e','f'), ('g','x','x')

"""
return izip(*[chain(iterable, repeat(padvalue, n-1))]*n)

--
Neil Cerutti
There are two ways to argue with a woman, and neither of them
work. --Carlos Boozer

[George Sakkis]

Neil Cerutti wrote:

On 2006-09-26, Neal Becker <nd*******@gmail.comwrote:

Any suggestions for transforming the sequence:

[1, 2, 3, 4...]
Where 1,2,3.. are it the ith item in an arbitrary sequence

into a succession of tuples:

[(1, 2), (3, 4)...]

In other words, given a seq and an integer that specifies the
size of tuple to return, then for example:

It turns out there's a itertools recipe to do this; the last one
in the itertools recipe book:

def grouper(n, iterable, padvalue=None):
"""
grouper(3, 'abcdefg', 'x') --('a','b','c'), ('d','e','f'), ('g','x','x')

"""
return izip(*[chain(iterable, repeat(padvalue, n-1))]*n)

That's not quite the same as the previous suggestions; if the last
tuple is shorter than n, it pads the last tuple with padvalue. The OP
didn't mention if he wants that or he'd rather have a shorter last
tuple.

George

[Boris Borcic]

Neal Becker wrote:

Any suggestions for transforming the sequence:

[1, 2, 3, 4...]
Where 1,2,3.. are it the ith item in an arbitrary sequence

into a succession of tuples:

[(1, 2), (3, 4)...]

In other words, given a seq and an integer that specifies the size of tuple
to return, then for example:

>>trf = lambda iterable,n : zip(*[iter(iterable)]*n)
trf(range(15),3)

[(0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11), (12, 13, 14)]
note though that it will silently drop any remainder.

hth, bb

[Bruno Desthuilliers]

Neal Becker a écrit :

Any suggestions for transforming the sequence:

[1, 2, 3, 4...]
Where 1,2,3.. are it the ith item in an arbitrary sequence

into a succession of tuples:

[(1, 2), (3, 4)...]

In other words, given a seq and an integer that specifies the size of tuple
to return, then for example:

seq = [a,b,c,d,e,f]
for e in transform (seq, 2):
print e

would return
(a,b)
(c,d)
(e,f)

Just for the fun (I'm sure someone already posted a far better solution):

def transform(seq, step):
return [tuple(seq[x: x+step]) \
for x in range(0, len(seq)-(step -1), step)]

[Steve Holden]

George Sakkis wrote:

Neil Cerutti wrote:

>>On 2006-09-26, Neal Becker <nd*******@gmail.comwrote:

>>>Any suggestions for transforming the sequence:

[1, 2, 3, 4...]
Where 1,2,3.. are it the ith item in an arbitrary sequence

into a succession of tuples:

[(1, 2), (3, 4)...]

In other words, given a seq and an integer that specifies the
size of tuple to return, then for example:

It turns out there's a itertools recipe to do this; the last one
in the itertools recipe book:

def grouper(n, iterable, padvalue=None):
"""
grouper(3, 'abcdefg', 'x') --('a','b','c'), ('d','e','f'), ('g','x','x')

"""
return izip(*[chain(iterable, repeat(padvalue, n-1))]*n)

That's not quite the same as the previous suggestions; if the last
tuple is shorter than n, it pads the last tuple with padvalue. The OP
didn't mention if he wants that or he'd rather have a shorter last
tuple.

In which case why not go in for a bit of requirements gold-plating and
add a keyword Boolean argument that allows you to specify which
behaviour you want. Or, alternatively, let the OP make sense of the
suggestions already made.

regards
Steve
--
Steve Holden [phone] [phone]
Holden Web LLC/Ltd http://www.holdenweb.com
Skype: holdenweb http://holdenweb.blogspot.com
Recent Ramblings http://del.icio.us/steve.holden

[Rob Williscroft]

Neal Becker wrote in
news:ma**************************************@pyth on.org in
comp.lang.python:

Any suggestions for transforming the sequence:

[1, 2, 3, 4...]
Where 1,2,3.. are it the ith item in an arbitrary sequence

into a succession of tuples:

[(1, 2), (3, 4)...]

In other words, given a seq and an integer that specifies the size of
tuple to return, then for example:

seq = [a,b,c,d,e,f]
for e in transform (seq, 2):
print e

would return
(a,b)
(c,d)
(e,f)

>>seq = range(11)
zip(seq[::2], seq[1::2] + [None])

[(0, 1), (2, 3), (4, 5), (6, 7), (8, 9), (10, None)]

>>seq = range(10)
zip(seq[::2], seq[1::2] + [None])

[(0, 1), (2, 3), (4, 5), (6, 7), (8, 9)]
Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Rob Williscroft]

Rob Williscroft wrote in news:Xns984ACDA635C9rtwfreenetREMOVEcouk@
216.196.109.145 in comp.lang.python:

>>>seq = range(11)
zip(seq[::2], seq[1::2] + [None])

[(0, 1), (2, 3), (4, 5), (6, 7), (8, 9), (10, None)]

>>>seq = range(10)
zip(seq[::2], seq[1::2] + [None])

[(0, 1), (2, 3), (4, 5), (6, 7), (8, 9)]

For bigger sequences:

>>import itertools as it
seq = range(11)
even = it.islice( seq, 0, None, 2 )
odd = it.islice( seq, 1, None, 2 )
zipped = it.izip( even, it.chain( odd, [None] ) )
list( zipped )

[(0, 1), (2, 3), (4, 5), (6, 7), (8, 9), (10, None)]
Rob.
--
http://www.victim-prime.dsl.pipex.com/

[George Sakkis]

Steve Holden wrote:

George Sakkis wrote:

Neil Cerutti wrote:

>On 2006-09-26, Neal Becker <nd*******@gmail.comwrote:

Any suggestions for transforming the sequence:

[1, 2, 3, 4...]
Where 1,2,3.. are it the ith item in an arbitrary sequence

into a succession of tuples:

[(1, 2), (3, 4)...]

In other words, given a seq and an integer that specifies the
size of tuple to return, then for example:

It turns out there's a itertools recipe to do this; the last one
in the itertools recipe book:

def grouper(n, iterable, padvalue=None):
"""
grouper(3, 'abcdefg', 'x') --('a','b','c'), ('d','e','f'), ('g','x','x')

"""
return izip(*[chain(iterable, repeat(padvalue, n-1))]*n)

That's not quite the same as the previous suggestions; if the last
tuple is shorter than n, it pads the last tuple with padvalue. The OP
didn't mention if he wants that or he'd rather have a shorter last
tuple.

In which case why not go in for a bit of requirements gold-plating and
add a keyword Boolean argument that allows you to specify which
behaviour you want.

Ok, I'll bite. Here's an overgeneralized, itertools-infested
conglomerate of all the suggestions so far. Season to taste:

from itertools import islice,izip,chain,repeat,takewhile,count

def iterwindows(iterable, n=2, mode='keep', padvalue=None):
it = iter(iterable)
if mode == 'keep':
return takewhile(bool, (tuple(islice(it,n)) for _ in count()))
elif mode == 'drop':
return izip(*[it]*n)
elif mode == 'pad':
return izip(*[chain(it,repeat(padvalue,n-1))]*n)
else:
raise ValueError('Unknown mode: %r' % mode)

>>list(iterwindows('abcdefgh',3))

[('a', 'b', 'c'), ('d', 'e', 'f'), ('g', 'h')]

>>list(iterwindows('abcdefgh',3,mode='drop'))

[('a', 'b', 'c'), ('d', 'e', 'f')]
list(iterwindows('abcdefgh',3,mode='pad'))
[('a', 'b', 'c'), ('d', 'e', 'f'), ('g', 'h', None)]
George

[Neal Becker]

George Sakkis wrote:

jo********@gmail.com wrote:

>def transform(seq, size):
i = 0
while i < len(seq):
yield tuple(seq[i:i+size])
i += size

Or for arbitrary iterables, not just sequences:

from itertools import islice
def transform(iterable, size):
it = iter(iterable)
while True:
window = tuple(islice(it,size))
if not window:
break
yield window

George

Thanks guys!

This one above is my personal favorite.

[dannycolligan]

Simple list comprehension?

>>l = [1,2,3,4,5,6,7,8,9,0]
[(x, x+1) for x in l if x%2 == 1]

[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]

Danny

Neal Becker wrote:

George Sakkis wrote:

jo********@gmail.com wrote:

def transform(seq, size):
i = 0
while i < len(seq):
yield tuple(seq[i:i+size])
i += size

Or for arbitrary iterables, not just sequences:

from itertools import islice
def transform(iterable, size):
it = iter(iterable)
while True:
window = tuple(islice(it,size))
if not window:
break
yield window

George

Thanks guys!

This one above is my personal favorite.

[dannycolligan]

Er, whoops. That would work if the last item in the list was 10 (and,
of course, this doesn't work for any arbitrary sequence). Is there any
"look-ahead" function for list comprehensions?

Danny

da***********@gmail.com wrote:

Simple list comprehension?

>l = [1,2,3,4,5,6,7,8,9,0]
[(x, x+1) for x in l if x%2 == 1]

[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]

Danny

Neal Becker wrote:

George Sakkis wrote:

jo********@gmail.com wrote:
>
>def transform(seq, size):
> i = 0
> while i < len(seq):
> yield tuple(seq[i:i+size])
> i += size
>
Or for arbitrary iterables, not just sequences:
>
from itertools import islice
def transform(iterable, size):
it = iter(iterable)
while True:
window = tuple(islice(it,size))
if not window:
break
yield window
>
George
>

Thanks guys!

This one above is my personal favorite.