As long as there is no chance of StopIteration being called by something else, the above could be rewritten using a try-except.

However, this particular application would be best solved by a regular expression: indentChars, textChars, suffixChars = re.match(‘({indent}*)(.*?)(?:{symbol}(.*))?’, line).groups().

First of all, the demonstration. Here is a full Python program using the ReadAhead technique.

###################################################################
indentCount = 0
textChars = []
suffixChars = []

INDENT_CHAR = " " # space character
SYMBOL = "!"
line = "   this is the line body ! this is the line suffix !!!"

def ReadAhead(sequence):
    for item in sequence:
        yield item
    yield None # return the "end of file mark" after the last item

#feed the line to the ReadAhead generator
chars = ReadAhead(line)

# This code works for Python 2.x
# For Python 3.x, change "chars.next()" to "next(chars)"
c = chars.next() # get first

while c and c == INDENT_CHAR:
    # process indent characters
    indentCount += 1
    c = chars.next()

while c and c != SYMBOL:
    # process text characters
    textChars.append(c)
    c = chars.next()

if c and c == SYMBOL:
    c = chars.next() # read past the SYMBOL
    while c:
        # process suffix characters
        suffixChars.append(c)
        c = chars.next()

print('Line (input)= "' + line + '"')
print('Line indent = ' + str(indentCount))
print('Line text   = "' + "".join(textChars) + '"')
print('Line suffix = "' + "".join(suffixChars) + '"')
##################################################################

It produces this output.

Line (input)= "   this is the line body ! this is the line suffix !!!"
Line indent = 3
Line text   = "this is the line body "
Line suffix = " this is the line suffix !!!"

Now replace the relevant code with your suggested code and look at the output.

Second, the explanation. To understand why your suggested code does not work, the best place to start is Michael Jackson’s famous paper
Getting It Wrong — A Cautionary Tale

After that, his book Principles of Program Design would be a good place to go.

For online resources about the Jackson methods, see http://www.jacksonworkbench.co.uk/stevefergspages/jsp_and_jsd/index.html.

    indentCount = 0
    textChars = []
    suffixChars = []

    # convert the line into a list of characters
    for c in line:
        if c == INDENT_CHAR:
            # process indent characters
            indentCount += 1
            continue

        if c != SYMBOL:
            # process text characters
            textChars.append(c)
            continue

        if c == SYMBOL:
            for c2 in line:
                # process suffix characters
                suffixChars.append(c2)

The bad news is that it doesn’t work. The good news is that understanding why it doesn’t work is really useful and interesting, because it helps point out an important feature of the ReadAhead technique and the ReadAhead generator.

I ran this program under Python 2.5:

import sys
print(sys.version)
listOfItems ="abcd"
items = (x for x in listOfItems)
item = items.next()  # get first
while item:
    print(item)
    item = items.next()  # get next

And got this.

2.5.2 (r252:60911, Feb 21 2008, 13:11:45) [MSC v.1310 32 bit (Intel)]
a
b
c
d
Traceback (most recent call last):
  File "c:\junk\test.py", line 9, in 
    item = items.next()  # get next
StopIteration

The “trick” with the ReadAhead generator is that after yielding all of the members of the list, it yields None, thus avoiding the raising of StopIteration. In the classic formulation of the ReadAhead technique, the yield None corresponds to returning the end-of-file mark.

NOTE that with Python 3.x, instead of items.next() you need to use next(items).

I don’t know that it isn’t pythonic overall, but it would be _more_ pythonic to replace the function ReadAhead with a generator expression:

items = (x for x in listOfItems)
item = items.next()  # get first
while item:
    processItem(item)
    item = items.next()  # get next

Incidentally, there’s no need to convert the line via list in the final example: since strings are sequences in Python, the ReadAhead generator will iterate over it as-is on a character-by-character basis.