On Feb 8, 3:40 pm, Arnaud Delobelle <[EMAIL PROTECTED]> wrote:
> On Feb 8, 7:20 pm, "Zack" <[EMAIL PROTECTED]> wrote:
>
>
>
> > Hi all. I'm just starting to pick up python. I wanted to play with nested
> > lists so first I wrote a little bit of code to create arbitrarily nested
> > lists (grow). Then I wrote a breadth first search. I'm putting this small
> > snippet up asking for criticism. Was there a more elegant way to do what I'm
> > doing? Anything that goes against convention? Anything that fingers me as a
> > c++ programmer? Are there standard modules that do these kind of things?
> > Thanks for any feedback.
>
> > ##############################
> > from random import randint
>
> > Val = 0
>
> > def grow(L,depth):
> > '''grows L by appending integers and arbitrarily nested lists with a
> > maximum
> > depth. Returns L.'''
> > global Val
> > if depth == 0:
> > return L
> > else:
> > choice = randint(1,2)
> > if 1 == choice:
> > # add a numerical literal
> > Val += 1
> > L.append(Val)
> > return grow(L,depth-1)
> > elif 2 == choice:
> > # add a list
> > L.append( grow([],depth-1) )
> > return grow(L,depth-1)
>
> How about:
>
> from itertools import count
> from random import randrange
>
> def grow(L, depth, counter=count()):
> '''grow L by appending integers and arbitrarily nested lists with a
> maximum depth. Returns L.'''
> if depth == 0:
> return L
> else:
> L.append(counter.next() if randrange(2) else grow([], depth-1))
> return grow(L, depth-1)
Or you may write a more flexible generator version of the above. If
you're not familiar with generators, think of them as lazy sequences
that generate successive elements only when needed:
import random
from itertools import count
def igrow(depth, next=count(1).next, nest=list, random=random.random):
'''Generate integers and arbitrarily nested iterables with a
maximum depth.'''
if depth:
depth -= 1
yield next() if random()<0.5 else
nest(igrow(depth,next,nest,random))
for e in igrow(depth,next,nest,random):
yield e
With this you can just as easily generate nested tuples (or other
containers) instead of lists:
nested = tuple(igrow(10, nest=tuple))
You may even avoid allocating nested containers altogether:
from types import GeneratorType
for x in igrow(10, nest=iter):
if isinstance(x, GeneratorType):
# process nested generator
else:
# x is an 'atom'
HTH,
George
--
http://mail.python.org/mailman/listinfo/python-list
