can't generate iterator from list

[Dr. Phillip M. Feldman]

It is supposed to be possible to generate a list representation of any
iterator that produces a sequence of finite length, but this doesn't always
work. Here's a case where it does work:

Input:

from itertools import combinations
list(combinations(range(4),2))

Output:

[(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]

When I define my own classes that produce iterators, conversion to a list
works for some of these classes but not for others. Here's a case where it
doesn't work:

In:  list(balls_in_numbered_boxes(2, [3,3,3]))

Out:

[array([0, 0, 1]),
 array([0, 0, 1]),
 array([0, 0, 1]),
 array([0, 0, 1]),
 array([0, 0, 1])]

Note that if I apply the `next` method to the object, the output is correct:

In [5]: x=balls_in_numbered_boxes(3,[3,3,3])

In [6]: x.next()
Out[6]: array([3, 0, 0])

In [7]: x.next()
Out[7]: array([2, 1, 0])

In [8]: x.next()
Out[8]: array([1, 2, 0])

In [9]: x.next()
Out[9]: array([0, 3, 0])

In [10]: x.next()
Out[10]: array([0, 2, 1])

In [11]: x.next()
Out[11]: array([0, 1, 2])

In [12]: x.next()
Out[12]: array([0, 0, 3])

In [13]: x.next()
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)

Code is attached (see below). Any suggestions as to what's going wrong will
be appreciated.

class balls_in_numbered_boxes(object):
   """
   OVERVIEW

   This class generates an iterator that produces all distinct distributions
of
   indistinguishable balls among numbered boxes with specified capacity
limits.
   (This is a generalization of the most common formulation of the problem,
   where each box is sufficiently large to accommodate all of the balls, and
is
   an important example of a class of combinatorics problems called 'weak
   composition' problems).


   CONSTRUCTOR INPUTS

   n: the number of balls

   limits: This argument is a list of length 1 or greater.  The length of
the
   list corresponds to the number of boxes.  `limits[i]` is a positive
integer
   that specifies the maximum capacity of the ith box.  If `limits[i]`
equals
   `n` (or greater), then the ith box can accommodate all `n` balls and thus
   effectively has unlimited capacity.
   """

   def __init__(self, n=None, limits=None):
      if n < 0 or not isinstance(n,int):
         raise BadInput("The number of balls n must be a non-negative
integer.")

      if not isinstance(limits,list) or len(limits)<1:
         raise BadInput("`limits` must be a non-empty list.")
      for limit in limits:
         if not isinstance(limit,int) or limit<1:
            raise BadInput("Items in `limits` must be positive integers.")

      # Copy constructor inputs to object attributes.  We make a `deepcopy`
of
      # `limits` to protect against the possibility of the calling program
      # modifying it before all calls to the `next` method have been
completed.
      self.n= n
      self.limits= deepcopy(limits)
      self.distribution= None


   def __iter__(self):
      return self


   def next(self):

      # If `self.distribution` is `None`, this is the initial call to
`next`,
      # in which case we generate the initial distribution by assigning as
many
      # balls as possible to the first box, as many balls that remain to the
      # next box, and so on.
      if self.distribution is None:
         self.distribution= zeros(len(self.limits), dtype='i4')

         balls= self.n

         for box in xrange(len(self.limits)):

            # Store as many balls as possible in the current box:
            self.distribution[box]= min(balls,self.limits[box])
            balls-= self.distribution[box]
            if balls == 0: break

         else:

            # We fell through the above loop, which means that it was
impossible
            # to distribute all of the balls:
            raise BadInput("The total capacity of the boxes is less than the
"
              "number of balls to be distributed.")

         # Make first box the "current" box, i.e., the box from which a ball
         # will be moved when the `next` method is invoked:
         self.box= 0

         return self.distribution

      # `self.distribution` is not `None`, which means that this is not the
      # initial invocation of `next`.  We create the next distribution by
moving
      # one ball to the right, unless this is impossible.

      self.distribution[self.box]-= 1

      for box in xrange(self.box+1,len(self.limits)):

         # If this box is full, advance to the next one:
         if self.distribution[box] == self.limits[box]: continue
         self.distribution[box]+= 1
         break

      else:

         # We fell through the above loop, which means that it was
impossible
         # to find a new home for the ball that we were trying to move.
         raise StopIteration

      # If the current box--the box from which we have been removing balls--
is
      # empty, advance to the next box:
      if self.distribution[self.box] == 0: self.box+= 1

      return self.distribution
-- 
View this message in context: http://old.nabble.com/can%27t-generate-iterator-from-list-tp32435519p32435519.html
Sent from the Python - python-list mailing list archive at Nabble.com.