how to make a generator use the last yielded value when it regainscontrol

[John Salerno]

Ok, I wrote this all by myself, which explains why it doesn't work. It
is meant to take a number and generate the next number that follows
according to the Morris sequence. It works for a single number, but what
I'd like it to do is either:

1. repeat indefinitely and have the number of times controlled elsewhere
in the program (e.g., use the morris() generator in a for loop and use
that context to tell it when to stop)

2. just make it a function that takes a second argument, that being the
number of times you want it to repeat itself and create numbers in the
sequence

Here's the code so far, and any general comments are always appreciated
as well:

def morris(seed):
seed = list(str(seed))
grouping = []
nextNum = []
for i in range(len(seed) ):
try:
if seed[i] == seed[i + 1]:
grouping.append (seed[i])
else:
grouping.append (seed[i])
nextNum.append( str(len(groupin g)) + seed[i])
grouping = []
except IndexError:
grouping.append (seed[i])
nextNum.append( str(len(groupin g)) + seed[i])
seed = ''.join(nextNum )
yield seed

I thought the second to last line might rebind 'seed' to the new value,
and it would use that again the next time through, but it seems to just
keep using the original value each time and yielding the same output.

[Michael Spencer]

John Salerno wrote:

Ben Cartwright wrote:

Definitely go for (1). The Morris sequence is a great candidate to
implement as a generator. As a generator, it will be more flexible and
efficient than (2).

Actually I was just thinking about this and it seems like, at least for
my purpose (to simply return a list of numbers), I don't need a
generator. My understanding of a generator is that you do something to
each yielded value before returning to the generator (so that you might
not return at all), but since I'm not handling the individual numbers,
just getting a list, it seems I don't need them to be yielded. Of
course, a generator would allow the process to be done over and over, I
suppose, which is what I wanted, I just couldn't figure out how to keep
using the new values.

itertools.group by makes this very straightforward :

from itertools import groupby .... def lookandsay(seed ): .... seed = str(seed)
.... while 1:
.... seed = "".join("%s %s" % (len(list(group )), item)
.... for item, group in groupby(seed))
.... yield seed
....
seq = lookandsay(1)
seq.next() '11' seq.next() '21' seq.next() '1211' seq.next() '111221' seq.next() '312211'

If you want to get just part of the infinite series, use itertools.islic e:
from itertools import islice
list(islice(loo kandsay(1),10)) ['11', '21', '1211', '111221', '312211', '13112221', '1113213211',
'31131211131221 ', '13211311123113 112211', '11131221133112 132113212221'] list(islice(loo kandsay(1),10,2 0)) ['31131122212321 121113122113121 13211',
'13211321321112 131221123113112 221131112211312 21',
'11131221131211 131231121113112 221121321132132 211331222113112 211',
'31131122211311 123113111213211 231132132211211 131221131211132 221231132211321 2221',
'13211321322113 311213211331121 113122112132113 121113222112311 311222113111231 133211121321132 2211312113211',
'11131221131211 132221232112111 312212321123113 112221121113122 113111231133221 121321132132211 331121321231231 121113122113322 113111221131221 ',
'31131122211311 123113321112131 221123113112211 121312211213211 321322112311311 222113311213212 322211211131221 131211132221232 112111312111213 111213211231131 122212322211331 222113112211',
'13211321322113 311213212312311 211131122211213 211321223112111 311222112111312 211312111322211 213211321322123 211211131211121 332211231131122 211311123113321 112131221123113 111231121113311 211131221121321 132132111213322 123113221132122 21',
'11131221131211 132221232112111 312111213111213 211231132132211 211131221131211 221321123113213 221123113112221 131112311332211 211131221131211 132211121312211 231131112311211 232221121321132 132211331121321 231231121113112 221121321133112 132112312321123 113112221121113 122113121113123 112112322111213 211322211312113 211',
'31131122211311 123113321112131 221123113111231 121113311211131 221121321131211 132221123113112 221131112212211 131221121321131 211132221121321 132132211331121 321232221123113 112221131112311 322311211131122 211213211331121 321122112133221 121113122113121 113222123211211 131211121311121 321123113213221 121113122123211 211131221121311 121312211213211 321322112311311 222113111231131 112132112211213 223112111312211 332211311122113 1221']

HTH
Michael

[John Salerno]

Michael Spencer wrote:

itertools.group by makes this very straightforward :

I was considering this function, but then it seemed like it was only
used for determing consecutive numbers like 1, 2, 3 -- not consecutive
equivalent numbers like 1, 1, 1. But is that not right?

[Gerard Flanagan]

John Salerno wrote:

Michael Spencer wrote:

itertools.group by makes this very straightforward :

I was considering this function, but then it seemed like it was only
used for determing consecutive numbers like 1, 2, 3 -- not consecutive
equivalent numbers like 1, 1, 1. But is that not right?

data = [1, 1, 1, 2, 2, 3, 4, 4, 3, 2, 2, 1, 1, 2, 2,4, 2, 2]

from itertools import groupby
for k, g in groupby( data ):
print k, list(g)

1 [1, 1, 1]
2 [2, 2]
3 [3]
4 [4, 4]
3 [3]
2 [2, 2]
1 [1, 1]
2 [2, 2]
4 [4]
2 [2, 2]

for k, g in groupby( data, lambda x: x<2 ):
print k, list(g)

True [1, 1, 1]
False [2, 2, 3, 4, 4, 3, 2, 2]
True [1, 1]
False [2, 2, 4, 2, 2]

Gerard

[Michael Spencer]

John Salerno wrote:

Michael Spencer wrote:

itertools.group by makes this very straightforward :

I was considering this function, but then it seemed like it was only
used for determing consecutive numbers like 1, 2, 3 -- not consecutive
equivalent numbers like 1, 1, 1. But is that not right?

With one argument, groupby assembles groups of equal consecutive elements:

list((key, list(group)) for key, group in groupby("AAABBC AAA")) [('A', ['A', 'A', 'A']), ('B', ['B', 'B']), ('C', ['C']), ('A', ['A', 'A', 'A'])]

With a second keyfunc argument, groupby assembles groups where keyfunc(element )
is equal for consecutive elements list((key, list(group)) for key, group in groupby("AAAaaa AAA",str.isuppe r)) [(True, ['A', 'A', 'A']), (False, ['a', 'a', 'a']), (True, ['A', 'A', 'A'])]

HTH
Michael

[John Salerno]

Gerard Flanagan wrote:

John Salerno wrote:

Michael Spencer wrote:

itertools.group by makes this very straightforward :

I was considering this function, but then it seemed like it was only
used for determing consecutive numbers like 1, 2, 3 -- not consecutive
equivalent numbers like 1, 1, 1. But is that not right?

data = [1, 1, 1, 2, 2, 3, 4, 4, 3, 2, 2, 1, 1, 2, 2,4, 2, 2]

from itertools import groupby
for k, g in groupby( data ):
print k, list(g)

1 [1, 1, 1]
2 [2, 2]
3 [3]
4 [4, 4]
3 [3]
2 [2, 2]
1 [1, 1]
2 [2, 2]
4 [4]
2 [2, 2]

for k, g in groupby( data, lambda x: x<2 ):
print k, list(g)

True [1, 1, 1]
False [2, 2, 3, 4, 4, 3, 2, 2]
True [1, 1]
False [2, 2, 4, 2, 2]

Gerard

Interesting. After following along with the doc example, it seemed like
I had to do complicated stuff with the keys parameter, and I kind of
lost track of it all.

[Azolex]

Lonnie Princehouse wrote:

Here's my take on the thing. It only prints one term, though.

http://www.magicpeacefarm.com/lonnie...morris.py.html

(a bit too long to post)

excerpt :

def morris(seed, n):
"""..."""
if n == 1:
return seed
else:
return length_encode(m orris(seed,n-1))

What's wrong with the following ?

def morris(seed,n) :
"""..."""
for k in xrange(n-1) :
seed=length_enc ode(seed)
return seed

or even

def morris(seed,n) :
return reduce(lambda x,y:y(x),n*[length_encode],seed)

I'd defend using recursion when it allows a more concise expression of
an algorithm, but not in other cases.

Mmmhhh, btw, strangely, it looks like a hole in the library that you
can't write eg

morris= lambda seed,n: reduce(operator .__rcall__,n*[length_encode],seed)

[Lonnie Princehouse]

> What's wrong with the following ?

def morris(seed,n) :
"""..."""
for k in xrange(n-1) :
seed=length_enc ode(seed)
return seed

Nothing's wrong with it.

I happen to think the recursive version is more elegant, but that's
just me ;-)

[Felipe Almeida Lessa]

Em Seg, 2006-04-10 Ã*s 10:05 -0700, Lonnie Princehouse escreveu:

I happen to think the recursive version is more elegant, but that's
just me ;-)

It may be elegant, but it's not efficient when you talk about Python.
Method calls are expensive:

$ python2.4 -mtimeit 'pass'
10000000 loops, best of 3: 0.0585 usec per loop
$ python2.4 -mtimeit -s 'def x(): pass' 'x()'
1000000 loops, best of 3: 0.291 usec per loop
$ calc 0.291/0.0585
~4.974358974358 97435897
$ calc 0.291-0.0585
0.2325
This happens because of the dynamic nature of Python and its lack of
tail call optimization. IOW, avoid recursive methods when possible (I
usually write those for the first version of a method then rethink it
using a non-recursive approach), specially if they are part of a hot
spot.

--
Felipe.

[Lonnie Princehouse]

In general, you're right - if speed is a concern, loops should be used
instead of recursion in Python when possible.

In this case, the recursive overhead is insignificant compared to the
expense of iterating over the sequence at every iteration. By the time
there are 70 stack frames of recursion (i.e. not much), the sequence is
more than 170 million elements long.