Первые буквы слов в Python: как избежать IndexError во вложенных циклах

Разбираем ошибку IndexError во вложенных циклах при выводе первых букв слов в Python: причины, воспроизведение, фикс и однопроходный вариант и советы.

Вывести первую букву каждого слова кажется пустяком, но даже в такой мелочи можно споткнуться на управлении вложенными циклами. Типичный подход — пройтись по строке, отлавливать пробелы и выводить следующий непробельный символ. Подводный камень возникает, когда обновления индекса во внутреннем цикле «обгоняют» проверку границ во внешнем, и это приводит к IndexError.

Как воспроизвести проблему

Следующая программа выводит первый символ каждого слова, проходя по строке и переключая флаг состояния. Она падает с IndexError во внутреннем цикле, когда индекс уходит за пределы строки.

line_text = "Humpty Dumpty sat on a wall"
latch = False
ptr = 0
while ptr < len(line_text):
    if latch == False and line_text[ptr] != " ":
        print(line_text[ptr])
        ptr += 1
        latch = True
    else:
        latch = True
    while latch == True:
        if line_text[ptr] == " ":
            latch = False
            ptr += 1
            break
        else:
            ptr += 1

Что на самом деле происходит не так

Сбой происходит во внутреннем блоке while. Представьте строку длиной 27 и момент, когда индекс равен 26. Ветвь else внутри внутреннего цикла увеличивает индекс до 27 и сразу же повторяет итерацию внутреннего цикла. Внешняя проверка while ptr < len(line_text) не выполняется до завершения внутреннего цикла, поэтому следующая попытка чтения обращается к line_text[27], что выходит за границы, и программа падает на проверке, сравнивающей текущий символ с пробелом.

Основная мысль в том, что проверки границ внешнего цикла автоматически не защищают внутренние циклы. Как только индекс выходит за допустимый диапазон внутри вложенного цикла, внешнее условие не успевает сработать до следующего обращения.

Минимальное исправление

Прямой способ обезопасить исходный подход — добавить проверку границ и в условие внутреннего цикла.

line_text = "Humpty Dumpty sat on a wall"
latch = False
ptr = 0
while ptr < len(line_text):
    if latch == False and line_text[ptr] != " ":
        print(line_text[ptr])
        ptr += 1
        latch = True
    else:
        latch = True
    while latch == True and ptr < len(line_text):
        if line_text[ptr] == " ":
            latch = False
            ptr += 1
            break
        else:
            ptr += 1

Так сохраняется исходная логика и предотвращается выход за пределы: внутреннее сканирование останавливается, когда индекс достигает длины строки.

Более опрятный однопроходный вариант

Есть более простой шаблон, который полностью избавляется от вложенного цикла: держать флаг, обозначающий, был ли предыдущий символ пробелом. Для каждого символа либо переключаем флаг на пробеле, либо, если стоим на границе слова, печатаем символ и сбрасываем флаг.

src = "Humpty Dumpty sat on a wall"
seen_space = True
posn = 0
while posn < len(src):
    if src[posn] == " ":
        seen_space = True
    elif seen_space:
        print(src[posn])
        seen_space = False
    posn += 1

Результат тот же, но без внутреннего цикла и с меньшим количеством состояния. К тому же исчезает риск «перескочить» внешнюю проверку границ.

Вариант, близкий к исходной логике

Если ближе исходный замысел с «отслеживанием/выводом», его можно свернуть в один цикл с переменной состояния: она включается на непробельных символах и сбрасывается на пробелах.

text = "Humpty Dumpty sat on a wall"
pause = False
k = 0
while k < len(text):
    if pause:
        pause = text[k] != " "
    elif text[k] != " ":
        print(text[k])
        pause = True
    k += 1

Почему это важно

Вложенные конструкции управления часто скрывают неявные предположения о границах циклов. Здесь ожидание, что внешний while «прикроет» внутренний, оказалось неверным: одно-единственное увеличение индекса за пределы превратилось в IndexError. Важно четко понимать, где именно выполняются проверки границ, чтобы избежать ошибок на единицу и обращений вне диапазона.

Две практики помогают быстро находить такие проблемы. Во‑первых, выведите ключевые значения прямо перед падающей строкой — простой print(ptr, len(line_text)) покажет, что именно собирается сделать код. Во‑вторых, пройдитесь по программе в отладчике и особо посмотрите на момент, когда индекс достигает len(string) - 1, или сразу после последнего пробела во входных данных, чтобы увидеть, как меняются состояние и индекс.

Вывод и практические рекомендации

Сканируя строку посимвольно, следите, чтобы каждый цикл, где происходит разыменование индекса, имел собственную проверку границ. Если используете флаг состояния, попытайтесь развернуть логику в один цикл с разными ветками под каждое состояние — так поток управления будет предсказуемее. Отдавайте предпочтение идиоматичным выражениям вроде not flag вместо flag == False — это снижает визуальный шум и вероятность ошибки. И для стабильного воспроизведения сбоев тестируйте на явной строке, а не на интерактивном вводе, чтобы поведение оставалось неизменным во время итераций. С этими небольшими поправками задача вывода первой буквы каждого слова становится и надежной, и удобной в сопровождении.