Loop in a loop?

[Sacred Heart]

Hi,
I'm new to Python and have come across a problem I don't know how to
solve, enter com.lang.python :)

I'm writing some small apps to learn the language, and I like it a lot
so far.

My problem I've stumbled upon is that I don't know how to do what I
want. I want to do a loop in a loop. I think.

I've got two arrays with some random stuff in, like this.

array1 = ['one','two','th ree','four']
array2 = ['a','b','c','d']

I want to loop through array1 and add elements from array2 at the end,
so it looks like this:

one a
two b
three c
four c

I'm stuck. I know how to loop through the arrays separatly and print
them, but both at the same time? Hmmm.

A push in the right direction, anyone?

R,
SH

[Paul Hankin]

On Jan 17, 4:38 pm, Bruno Desthuilliers <bruno.
42.desthuilli.. [e-mail] ro.oops.comwrot e:

Now there are very certainly smart solutions using itertools, but the
one I cooked is way too ugly so I'll leave this to itertools masters !-)

Here's my effort:

from itertools import izip, islice, chain, repeat

def padzip(*xs, **kw):
pad = kw.get('padding ', None)
maxlen = max(len(x) for x in xs)
return islice(izip(*[chain(x, repeat(pad)) for x in xs]), maxlen)

--
Paul Hankin

[Roel Schroeven]

Sacred Heart schreef:

On Jan 17, 1:35 pm, cokofree...@gma il.com wrote:

>for i in zip(array1, array2):
print i

Although I take it you meant four d, the issue with this method is
that once you hit the end of one array the rest of the other one is
ignored.

Yes, small typo there.

Okey, so if my array1 is has 4 elements, and array2 has 6, it won't
loop trough the last 2 in array2? How do I make it do that?

One solution is with map() instead if zip(). map() with None as the
first argument works much like zip(), but it keeps looping if one of the
lists is exhausted. When that happens, it uses None for those values:

words = ['zero', 'one', 'two', 'three']
numbers = [0, 1, 2, 3, 4, 5, 6]
for word, number in map(None, words, numbers):
print word, number
zero 0
one 1
two 2
three 3
None 4
None 5
None 6

--
The saddest aspect of life right now is that science gathers knowledge
faster than society gathers wisdom.
-- Isaac Asimov

Roel Schroeven

[Paul Rubin]

Sacred Heart <sc*****@gmail. comwrites:

array1 = ['one','two','th ree','four']
array2 = ['a','b','c','d']

I want to loop through array1 and add elements from array2 at the end,
so it looks like this:

one a
two b
three c
four c

The "functional " style is to use the zip function that someone
described. The old-fashioned way is simply:

n = len(array1)
for i in xrange(n):
print array1[i], array2[i]

You can modify this in various ways if the lengths of the lists are
not equal. E.g.

[George Sakkis]

On Jan 17, 12:25 pm, Paul Hankin <paul.han...@gm ail.comwrote:

On Jan 17, 4:38 pm, Bruno Desthuilliers <bruno.

42.desthuilli.. [e-mail] ro.oops.comwrot e:

Now there are very certainly smart solutions using itertools, but the
one I cooked is way too ugly so I'll leave this to itertools masters !-)

Here's my effort:

from itertools import izip, islice, chain, repeat

def padzip(*xs, **kw):
pad = kw.get('padding ', None)
maxlen = max(len(x) for x in xs)
return islice(izip(*[chain(x, repeat(pad)) for x in xs]), maxlen)

--
Paul Hankin

And if the iterables don't necessarily support len(), here's a more
general solution:

from itertools import repeat

def izippad(*iterab les, **kw):
pad = kw.get('padding ', None)
next_pad = repeat(pad).nex t
getnext = [iter(iterable). next for iterable in iterables]
pending = size = len(iterables)
while True:
slice = [None] * size
for i in xrange(size):
try: slice[i] = getnext[i]()
except StopIteration:
pending -= 1
if not pending: return
getnext[i] = next_pad
slice[i] = pad
yield slice
George

[Paul Hankin]

On Jan 17, 7:02*pm, George Sakkis <george.sak...@ gmail.comwrote:

On Jan 17, 12:25 pm, Paul Hankin <paul.han...@gm ail.comwrote:

On Jan 17, 4:38 pm, Bruno Desthuilliers <bruno.

42.desthuilli.. [e-mail] ro.oops.comwrot e:

Now there are very certainly smart solutions using itertools, but the
one I cooked is way too ugly so I'll leave this to itertools masters !-)

Here's my effort:

from itertools import izip, islice, chain, repeat

def padzip(*xs, **kw):
* * pad = kw.get('padding ', None)
* * maxlen = max(len(x) for x in xs)
* * return islice(izip(*[chain(x, repeat(pad)) for x in xs]), maxlen)

--
Paul Hankin

And if the iterables don't necessarily support len(), here's a more
general solution:

from itertools import repeat

def izippad(*iterab les, **kw):
* * pad = kw.get('padding ', None)
* * next_pad = repeat(pad).nex t
* * getnext = [iter(iterable). next for iterable in iterables]
* * pending = size = len(iterables)
* * while True:
* * * * slice = [None] * size
* * * * for i in xrange(size):
* * * * * * try: slice[i] = getnext[i]()
* * * * * * except StopIteration:
* * * * * * * * pending -= 1
* * * * * * * * if not pending: return
* * * * * * * * getnext[i] = next_pad
* * * * * * * * slice[i] = pad
* * * * yield slice

Instead of counting the exceptions, we can limit the padding iterables
by using an iterator that returns len(iterables) - 1 padding
generators, use a sort of lazy chain, and then just izip.

from itertools import izip, repeat

def chain_next(xs, yg):
for x in xs: yield x
for y in yg.next(): yield y

def izippad(*xs, **kw):
padder = repeat(kw.get(' padding', None))
padder_gen = repeat(padder, len(xs) - 1)
return izip(*[chain_next(x, padder_gen) for x in xs])

--
Paul Hankin

[Paul Rubin]

George Sakkis <ge***********@ gmail.comwrites :

And if the iterables don't necessarily support len(), here's a more
general solution:

Not trying to pick on you personally but there's this disease
when a newbie comes with a basically simple question (in this case,
how to solve the problem with ordinary lists) and gets back a lot
of complex, overly general "graduate level" solutions.

There's a humorous set of Haskell examples that takes this to extremes:

http://www.willamette.edu/~fruehr/ha...evolution.html

[Ben Finney]

Paul Rubin <http://ph****@NOSPAM.i nvalidwrites:

Not trying to pick on you personally but there's this disease when a
newbie comes with a basically simple question (in this case, how to
solve the problem with ordinary lists) and gets back a lot of
complex, overly general "graduate level" solutions.

Is that a disease?

I would characterise it as symptomatic of a very healthy programming
community. We like interesting problems, and enjoy coming up with ever
more elegant solutions. The discussions that ensue are healthy, not
diseased.

Whether that's exactly what the original poster in such a thread wants
is beside the point. This forum is for the benefit of all
participants, and discussing an apparently simple problem to discover
its complexities is part of the enjoyment.

Enjoyment of the discussion, after all, is the main reward most people
can ever hope to get for participation in most threads here.

--
\ "Remember: every member of your 'target audience' also owns a |
`\ broadcasting station. These 'targets' can shoot back." -- |
_o__) Michael Rathbun to advertisers, news.admin.net-abuse.email |
Ben Finney

[George Sakkis]

On Jan 17, 7:13 pm, Paul Rubin <http://phr...@NOSPAM.i nvalidwrote:

George Sakkis <george.sak...@ gmail.comwrites :

And if the iterables don't necessarily support len(), here's a more
general solution:

Not trying to pick on you personally but there's this disease
when a newbie comes with a basically simple question (in this case,
how to solve the problem with ordinary lists) and gets back a lot
of complex, overly general "graduate level" solutions.

Fair enough, although I don't think it's bad to show more general/
efficient/flexible solutions after the simple quick & dirty ones have
been shown, as in this thread. My solution is just a step further from
Paul Hankin's, not a direct response to the OP.

There's a humorous set of Haskell examples that takes this to extremes:

http://www.willamette.edu/~fruehr/ha...evolution.html

Hehe.. I remember seeing a similar one for Java and "Hello world"
using more and more elaborate abstractions and design patterns but I
can't find the link.

George

[Paul Rubin]

Ben Finney <bi************ ****@benfinney. id.auwrites:

Enjoyment of the discussion, after all, is the main reward most people
can ever hope to get for participation in most threads here.

Well then, in that case, what the heck.

from itertools import *
def padzip(*xs, **kw):
pad = kw.get('padding ', None)
ts = izip(*[chain(((y,) for y in x), repeat(None)) for x in xs])
def m(t): return tuple((x[0] if x else pad) for x in t)
return imap(m, takewhile(any, ts))

[Arnaud Delobelle]

On Jan 17, 11:59*pm, Paul Hankin <paul.han...@gm ail.comwrote:

Instead of counting the exceptions, we can limit the padding iterables
by using an iterator that returns len(iterables) - 1 padding
generators, use a sort of lazy chain, and then just izip.

from itertools import izip, repeat

def chain_next(xs, yg):
* * for x in xs: yield x
* * for y in yg.next(): yield y

def izippad(*xs, **kw):
* * padder = repeat(kw.get(' padding', None))
* * padder_gen = repeat(padder, len(xs) - 1)
* * return izip(*[chain_next(x, padder_gen) for x in xs])

I have had the need for such a 'padded zip' before and my
implementation was eerily similar:

from itertools import repeat, chain, izip

def repeatnext(iter ator):
val = iterator.next()
while True: yield val

def longzip(default , *iterables):
defaultgen = repeat(default, len(iterables) - 1)
return izip(*[chain(it, repeatnext(defa ultgen)) for it in
iterables])

--
Arnaud