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.

[John Salerno]

John Salerno wrote:

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

Well, I suppose I could just do:

num = 1
for x in range(some_limi t):
num = morris(num)
print num,

But that isn't as much of a challenge as the other two options. :) I'd
like the function to do all the work of returning multiple numbers
(which probably means that option 1 isn't the best either)

[John Salerno]

John Salerno wrote:

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 what I've come up with so far. Probably not the most elegant
solution because of the nested function, but it does work! :)

def morris(seed, limit):
num = seed
numberSet = []

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

for x in range(limit):
numberSet.appen d(int(num))
num = nextNum(num)

return numberSet

[Lonnie Princehouse]

The generator in your original post /does/ rebind seed, but only on the
last iteration of the loop. You'll need to wrap that loop in another
loop if you want the generator to yield more than once.

As for "communicat ing" with a generator --- e.g. telling it to stop ---
this might be done by passing some kind of mutable argument to the
generator and then changing the value of that mutable object. However,
it's not a very elegant solution, and in this case there's not really
any reason to do it. Instead, if you want the generator to stop, just
stop asking it to yield:

for number in morris_sequence _generator(seed ):
if it_is_time_to_s top():
break

And:
- No need to convert str(seed) to a list! Strings are indexable.
- Instead of using "try...exce pt IndexError" to detect the end of the
loop, just change the loop to range(len(seed) - 1) and do the yield
after the loop finishes.
- Use xrange instead of range. range is evil.

Bonus points:
Write the generator to work on a seed which is an iterable of unknown
length.

Super bonus points:
Print the Nth element in the sequence without holding more than N
groups of {digit, number of occurences} of state information. You'll
need to do this if you want to get very far: According to Wikipedia,
the 70th term of the look-and-say sequence has 179,691,598 digits.

[Ben Cartwright]

John Salerno wrote:

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

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).

def morris(num):
"""Generate the Morris sequence starting at num."""
num = str(num)
yield num
while True:
result, cur, run = [], None, 0
for digit in num+'\n':
if digit == cur:
run += 1
else:
if cur is not None:
result.append(s tr(run))
result.append(c ur)
cur, run = digit, 1
num = ''.join(result)
yield num

# Example usage:
from itertools import islice
for n in islice(morris(1 ), 10):
print n

# Output:
"""
1
11
21
1211
111221
312211
13112221
1113213211
31131211131221
132113111231131 12211
"""

--Ben

[John Salerno]

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.

[Ben Cartwright]

John Salerno wrote:

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.
Yes, if it's just a list of numbers you need, a generator is more
flexibility than you need. A generator would only come in handy if,
say, you wanted to give your users the option of getting the next N
items in the sequence, *without* having to recompute everything from
scratch.

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),

A generator is just an object that spits out values upon request; it
doesn't care what the caller does with those values.

There's many different ways to use generators; a few examples:

# Get a list of the first 10
from itertools import islice
m = [n for n in islice(morris(1 ), 10)]

# Prompt user between each iteration
for n in morris(1):
if raw_input('keep going? ') != 'y':
break
print n

# Alternate way of writing the above
g = morris(1)
while raw_input('keep going? ') == 'y':
print g.next()

--Ben

[Lonnie Princehouse]

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)

[Azolex]

just couldn't help taking the bait...

def morris(seed) :

"""

m = morris('3447221 ')
m.next() '1324172211' m.next() '11131214111722 21' m.next()

'31131112111431 173211'
"""

assert isinstance(seed ,basestring) and seed.isdigit(), "bad seed"

def itially(z) :
feedback.z = z
while True :
yield feedback.z

def feedback(gen) :
while True :
feedback.z = gen.next()
yield feedback.z

def morrisify(numbe r) :
from itertools import groupby
for digit,sequence in groupby(number) :
yield str(len(tuple(s equence)))
yield digit

return feedback(''.joi n(morrisify(num ber))
for number in itially(seed))

[John Salerno]

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)

yikes, scary! :)

there was always the hint that using itertools might be helpful, as you
guys are doing, but i could never quite figure out how, but looking at
these alternate methods is definitely helpful