Path: csiph.com!x330-a1.tempe.blueboxinc.net!newsfeed.hal-mli.net!feeder1.hal-mli.net!feeder.news-service.com!newsfeed.xs4all.nl!newsfeed6.news.xs4all.nl!xs4all!post.news.xs4all.nl!not-for-mail
Date: Thu, 8 Sep 2011 08:48:24 +1000
From: Cameron Simpson <cs@zip.com.au>
To: comp.lang.python@googlegroups.com
Subject: Re: Best way to check that you are at the beginning (the end) of an iterable?
MIME-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline
Content-Transfer-Encoding: quoted-printable
In-Reply-To: <264a83d7-aa43-4e36-b39e-3e67488279b6@glegroupsg2000goo.googlegroups.com>
User-Agent: Mutt/1.5.21 (2010-09-15)
References: <264a83d7-aa43-4e36-b39e-3e67488279b6@glegroupsg2000goo.googlegroups.com>
Cc: python-list@python.org
Precedence: list
Newsgroups: comp.lang.python
Message-ID: <mailman.849.1315435715.27778.python-list@python.org>
Lines: 130
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: x330-a1.tempe.blueboxinc.net comp.lang.python:12917

On 07Sep2011 14:35, Laurent <laurent.payot@gmail.com> wrote:
| What is the simplest way to check that you are at the beginning or at
| the end of an iterable? I'm using enumerate with Python 3.2 (see below)
| but I'm wondering if there would be a better way.
|=20
| l =3D ['a', 'b', 'a', 'c']
|=20
| for pos, i in enumerate(l):
|     if pos =3D=3D 0:
|         print("head =3D", i)
|     else:
|         print(i)
|=20
| I know that Python is not exactly a functional language but wouldn't
| something like "ishead()" or "istail()" be useful?

There are a few reasons these do not exist out of the box (quite aside
=66rom how easy it is to do on the occasions you actually want it).
Tackling ishead and istail in turn...

The "ishead()" would need to be a top level function (like "len()")
because if it were an iterator method, every iterator would need to have
it implemented; currently the number of methods needed to roll your own
iterator is just two (iter and next). ishead() could be done as a top
level function, though it would need the storage cost of an additional
state value to every iterator (i.e. a "first" boolean or equivalent). So
you'd be proposing more memory cost and possibly a retrospective code
change for all the existing planetwide code, for a minor convenient. As
you note, enumerate gets you a pos value, and it is easy enough to write
a for loop like this:

  first =3D True
  for i in iterable_thing:
    if first:
      print "head =3D", i
    else:
      print i
    first =3D False

Your istail() is much worse.

A generator would need to do lookahead to answer istail() in the general
case. Consider iterating over the lines in a file, or better still the
lines coming from a pipeline. Or iteraing over packets received on a
network connection. You can't answer "istail()" there until you have
seen the next line/packet (or EOF/connection close). And that may be an
arbitrary amount of time in the future. You're going to stall your whole
program for such a question?

You can do this easily enough for yourself as an itertools-like thing:
write a wrapper generator that answers ishead() and istail() for
arbitrary iterators. Completely untested example code:

  class BoundSensitiveIterator(object):
    def __init__(self, subiter):
      self.sofar =3D 0
      self.subiter =3D subiter
      self.pending =3D ()
    def iter(self):
      return self
    def next(self):
      self.sofar +=3D 1
      if self.pending is None:
        raise StopIteration
      if self.pending:
        nxt =3D self.pending[0]
        self.pending =3D ()
        return nxt
      return self.subiter.next()
    def ishead(self):
      # maybe <=3D 1, depending on what you want it to mean
      return self.sofar =3D=3D 1
    def istail(self):
      if self.pending is None:
        return True
      if self.pending:
        return False
      try:
        nxt =3D self.subiter.next()
      except StopIteration:
        self.pending =3D None
        return True
      else:
        self.pending =3D (nxt,)
        return False

  I =3D BoundSensitiveIterator(other_iterable)
  for n in I:
    print n, "ishead =3D", I.ishead(), "istail =3D", I.istail()

You can see it adds some performance and storage overhead, and of course
may stall if you every ask istail() of an "on demand" iterable.

About the only time I do this is my personal "the()" convenience
function:

  def the(list, context=3DNone):
    ''' Returns the first element of an iterable, but requires there to be
        exactly one.
    '''
    icontext=3D"expected exactly one value"
    if context is not None:
      icontext=3Dicontext+" for "+context

    first=3DTrue
    for elem in list:
      if first:
        it=3Delem
        first=3DFalse
      else:
        raise IndexError, "%s: got more than one element (%s, %s, ...)" \
                          % (icontext, it, elem)

    if first:
      raise IndexError, "%s: got no elements" % icontext
     =20
    return it

Which I use as a definite article in places where an iterable _should_
yield exactly one result (eg SQL SELECTs that _ought_ to get exactly
one hit). I can see I wrote that a long time ago - it could do with some
style fixes. And a code scan shows it sees little use:-)

Cheers,
--=20
Cameron Simpson <cs@zip.com.au> DoD#743
http://www.cskk.ezoshosting.com/cs/

Electronic cardboard blurs the line between printed objects and the virtual
world.  - overhead by WIRED at the Intelligent Printing conference Oct2006